tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Move attribute domain enum to C++ header, use enum class 

Each value is now out of the global namespace, so they can be shorter
and easier to read. Most of this commit just adds the necessary casting
and namespace specification. `enum class` can be forward declared since
it has a specified size. We will make use of that in the next commit.
This commit is contained in:
Hans Goudey 2023-12-20 13:13:16 -05:00
parent 2618c1d71d
commit 19001c9e6c
311 changed files with 2486 additions and 2347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
intern/cycles/blender/curves.cpp
View File

@ -725,18 +725,20 @@ static void attr_create_generic(Scene *scene,
const blender::bke::AttributeMetaData meta_data) { const blender::bke::AttributeMetaData meta_data) {
const ustring name{std::string_view(id.name())}; const ustring name{std::string_view(id.name())};
const eAttrDomain b_domain = meta_data.domain; const blender::bke::AttrDomain b_domain = meta_data.domain;
const eCustomDataType b_data_type = meta_data.data_type; const eCustomDataType b_data_type = meta_data.data_type;
if (need_motion && name == u_velocity) { if (need_motion && name == u_velocity) {
const blender::VArraySpan b_attr = *b_attributes.lookup<blender::float3>(id, const blender::VArraySpan b_attr = *b_attributes.lookup<blender::float3>(
ATTR_DOMAIN_POINT); id, blender::bke::AttrDomain::Point);
attr_create_motion(hair, b_attr, motion_scale); attr_create_motion(hair, b_attr, motion_scale);
return true; return true;
} }
/* Weak, use first float2 attribute as standard UV. */ /* Weak, use first float2 attribute as standard UV. */
if (need_uv && !have_uv && b_data_type == CD_PROP_FLOAT2 && b_domain == ATTR_DOMAIN_CURVE) { if (need_uv && !have_uv && b_data_type == CD_PROP_FLOAT2 &&
b_domain == blender::bke::AttrDomain::Curve)
{
Attribute *attr = attributes.add(ATTR_STD_UV, name); Attribute *attr = attributes.add(ATTR_STD_UV, name);
const blender::VArraySpan b_attr = *b_attributes.lookup<blender::float2>(id); const blender::VArraySpan b_attr = *b_attributes.lookup<blender::float2>(id);
@ -759,10 +761,10 @@ static void attr_create_generic(Scene *scene,
AttributeElement element = ATTR_ELEMENT_NONE; AttributeElement element = ATTR_ELEMENT_NONE;
switch (b_attr.domain) { switch (b_attr.domain) {
case ATTR_DOMAIN_POINT: case blender::bke::AttrDomain::Point:
element = ATTR_ELEMENT_CURVE_KEY; element = ATTR_ELEMENT_CURVE_KEY;
break; break;
case ATTR_DOMAIN_CURVE: case blender::bke::AttrDomain::Curve:
element = ATTR_ELEMENT_CURVE; element = ATTR_ELEMENT_CURVE;
break; break;
default: default:
@ -856,8 +858,8 @@ static void export_hair_curves(Scene *scene,
} }
} }
const blender::VArraySpan b_radius = *b_curves.attributes().lookup<float>("radius", const blender::VArraySpan b_radius = *b_curves.attributes().lookup<float>(
ATTR_DOMAIN_POINT); "radius", blender::bke::AttrDomain::Point);
std::copy(points_by_curve.data().data(), std::copy(points_by_curve.data().data(),
points_by_curve.data().data() + points_by_curve.size(), points_by_curve.data().data() + points_by_curve.size(),
@ -933,8 +935,8 @@ static void export_hair_curves_motion(Hair *hair,
const blender::Span<blender::float3> b_positions = b_curves.positions(); const blender::Span<blender::float3> b_positions = b_curves.positions();
const blender::OffsetIndices points_by_curve = b_curves.points_by_curve(); const blender::OffsetIndices points_by_curve = b_curves.points_by_curve();
const blender::VArraySpan b_radius = *b_curves.attributes().lookup<float>("radius", const blender::VArraySpan b_radius = *b_curves.attributes().lookup<float>(
ATTR_DOMAIN_POINT); "radius", blender::bke::AttrDomain::Point);
for (const int i : points_by_curve.index_range()) { for (const int i : points_by_curve.index_range()) {
const blender::IndexRange points = points_by_curve[i]; const blender::IndexRange points = points_by_curve[i];

46
intern/cycles/blender/mesh.cpp
View File

@ -287,7 +287,7 @@ static void attr_create_generic(Scene *scene,
if (need_motion && name == u_velocity) { if (need_motion && name == u_velocity) {
const blender::VArraySpan b_attribute = *b_attributes.lookup<blender::float3>( const blender::VArraySpan b_attribute = *b_attributes.lookup<blender::float3>(
id, ATTR_DOMAIN_POINT); id, blender::bke::AttrDomain::Point);
attr_create_motion(mesh, b_attribute, motion_scale); attr_create_motion(mesh, b_attribute, motion_scale);
} }
@ -300,10 +300,10 @@ static void attr_create_generic(Scene *scene,
return true; return true;
} }
eAttrDomain b_domain = meta_data.domain; blender::bke::AttrDomain b_domain = meta_data.domain;
if (b_domain == ATTR_DOMAIN_EDGE) { if (b_domain == blender::bke::AttrDomain::Edge) {
/* Blender's attribute API handles edge to vertex attribute domain interpolation. */ /* Blender's attribute API handles edge to vertex attribute domain interpolation. */
b_domain = ATTR_DOMAIN_POINT; b_domain = blender::bke::AttrDomain::Point;
} }
const blender::bke::GAttributeReader b_attr = b_attributes.lookup(id, b_domain); const blender::bke::GAttributeReader b_attr = b_attributes.lookup(id, b_domain);
@ -311,7 +311,8 @@ static void attr_create_generic(Scene *scene,
return true; return true;
} }
if (b_attr.domain == ATTR_DOMAIN_CORNER && meta_data.data_type == CD_PROP_BYTE_COLOR) { if (b_attr.domain == blender::bke::AttrDomain::Corner &&
meta_data.data_type == CD_PROP_BYTE_COLOR) {
Attribute *attr = attributes.add(name, TypeRGBA, ATTR_ELEMENT_CORNER_BYTE); Attribute *attr = attributes.add(name, TypeRGBA, ATTR_ELEMENT_CORNER_BYTE);
if (is_render_color) { if (is_render_color) {
attr->std = ATTR_STD_VERTEX_COLOR; attr->std = ATTR_STD_VERTEX_COLOR;
@ -340,13 +341,13 @@ static void attr_create_generic(Scene *scene,
AttributeElement element = ATTR_ELEMENT_NONE; AttributeElement element = ATTR_ELEMENT_NONE;
switch (b_domain) { switch (b_domain) {
case ATTR_DOMAIN_CORNER: case blender::bke::AttrDomain::Corner:
element = ATTR_ELEMENT_CORNER; element = ATTR_ELEMENT_CORNER;
break; break;
case ATTR_DOMAIN_POINT: case blender::bke::AttrDomain::Point:
element = ATTR_ELEMENT_VERTEX; element = ATTR_ELEMENT_VERTEX;
break; break;
case ATTR_DOMAIN_FACE: case blender::bke::AttrDomain::Face:
element = ATTR_ELEMENT_FACE; element = ATTR_ELEMENT_FACE;
break; break;
default: default:
@ -368,7 +369,7 @@ static void attr_create_generic(Scene *scene,
const blender::VArraySpan src = b_attr.varray.typed<BlenderT>(); const blender::VArraySpan src = b_attr.varray.typed<BlenderT>();
switch (b_attr.domain) { switch (b_attr.domain) {
case ATTR_DOMAIN_CORNER: { case blender::bke::AttrDomain::Corner: {
if (subdivision) { if (subdivision) {
for (const int i : src.index_range()) { for (const int i : src.index_range()) {
data[i] = Converter::convert(src[i]); data[i] = Converter::convert(src[i]);
@ -384,13 +385,13 @@ static void attr_create_generic(Scene *scene,
} }
break; break;
} }
case ATTR_DOMAIN_POINT: { case blender::bke::AttrDomain::Point: {
for (const int i : src.index_range()) { for (const int i : src.index_range()) {
data[i] = Converter::convert(src[i]); data[i] = Converter::convert(src[i]);
} }
break; break;
} }
case ATTR_DOMAIN_FACE: { case blender::bke::AttrDomain::Face: {
if (subdivision) { if (subdivision) {
for (const int i : src.index_range()) { for (const int i : src.index_range()) {
data[i] = Converter::convert(src[i]); data[i] = Converter::convert(src[i]);
@ -419,7 +420,8 @@ static set<ustring> get_blender_uv_names(const ::Mesh &b_mesh)
set<ustring> uv_names; set<ustring> uv_names;
b_mesh.attributes().for_all([&](const blender::bke::AttributeIDRef &id, b_mesh.attributes().for_all([&](const blender::bke::AttributeIDRef &id,
const blender::bke::AttributeMetaData meta_data) { const blender::bke::AttributeMetaData meta_data) {
if (meta_data.domain == ATTR_DOMAIN_CORNER && meta_data.data_type == CD_PROP_FLOAT2) { if (meta_data.domain == blender::bke::AttrDomain::Corner &&
meta_data.data_type == CD_PROP_FLOAT2) {
if (!id.is_anonymous()) { if (!id.is_anonymous()) {
uv_names.emplace(std::string_view(id.name())); uv_names.emplace(std::string_view(id.name()));
} }
@ -466,7 +468,7 @@ static void attr_create_uv_map(Scene *scene,
} }
const blender::VArraySpan b_uv_map = *b_attributes.lookup<blender::float2>( const blender::VArraySpan b_uv_map = *b_attributes.lookup<blender::float2>(
uv_name.c_str(), ATTR_DOMAIN_CORNER); uv_name.c_str(), blender::bke::AttrDomain::Corner);
float2 *fdata = uv_attr->data_float2(); float2 *fdata = uv_attr->data_float2();
for (const int i : corner_tris.index_range()) { for (const int i : corner_tris.index_range()) {
const blender::int3 &tri = corner_tris[i]; const blender::int3 &tri = corner_tris[i];
@ -543,7 +545,7 @@ static void attr_create_subd_uv_map(Scene *scene,
} }
const blender::VArraySpan b_uv_map = *b_attributes.lookup<blender::float2>( const blender::VArraySpan b_uv_map = *b_attributes.lookup<blender::float2>(
uv_name.c_str(), ATTR_DOMAIN_CORNER); uv_name.c_str(), blender::bke::AttrDomain::Corner);
float2 *fdata = uv_attr->data_float2(); float2 *fdata = uv_attr->data_float2();
for (const int i : faces.index_range()) { for (const int i : faces.index_range()) {
@ -828,10 +830,10 @@ static void create_mesh(Scene *scene,
return; return;
} }
const blender::VArraySpan material_indices = *b_attributes.lookup<int>("material_index", const blender::VArraySpan material_indices = *b_attributes.lookup<int>(
ATTR_DOMAIN_FACE); "material_index", blender::bke::AttrDomain::Face);
const blender::VArraySpan sharp_faces = *b_attributes.lookup<bool>("sharp_face", const blender::VArraySpan sharp_faces = *b_attributes.lookup<bool>(
ATTR_DOMAIN_FACE); "sharp_face", blender::bke::AttrDomain::Face);
blender::Span<blender::float3> corner_normals; blender::Span<blender::float3> corner_normals;
if (use_loop_normals) { if (use_loop_normals) {
corner_normals = b_mesh.corner_normals(); corner_normals = b_mesh.corner_normals();
@ -1054,8 +1056,8 @@ static void create_subd_mesh(Scene *scene,
create_mesh(scene, mesh, b_mesh, used_shaders, need_motion, motion_scale, true, subdivide_uvs); create_mesh(scene, mesh, b_mesh, used_shaders, need_motion, motion_scale, true, subdivide_uvs);
const blender::VArraySpan creases = *b_mesh.attributes().lookup<float>("crease_edge", const blender::VArraySpan creases = *b_mesh.attributes().lookup<float>(
ATTR_DOMAIN_EDGE); "crease_edge", blender::bke::AttrDomain::Edge);
if (!creases.is_empty()) { if (!creases.is_empty()) {
size_t num_creases = 0; size_t num_creases = 0;
for (const int i : creases.index_range()) { for (const int i : creases.index_range()) {
@ -1076,8 +1078,8 @@ static void create_subd_mesh(Scene *scene,
} }
} }
const blender::VArraySpan vert_creases = *b_mesh.attributes().lookup<float>("crease_vert", const blender::VArraySpan vert_creases = *b_mesh.attributes().lookup<float>(
ATTR_DOMAIN_POINT); "crease_vert", blender::bke::AttrDomain::Point);
if (!vert_creases.is_empty()) { if (!vert_creases.is_empty()) {
for (const int i : vert_creases.index_range()) { for (const int i : vert_creases.index_range()) {
if (vert_creases[i] != 0.0f) { if (vert_creases[i] != 0.0f) {

10
intern/cycles/blender/pointcloud.cpp
View File

@ -57,7 +57,7 @@ static void copy_attributes(PointCloud *pointcloud,
const float motion_scale) const float motion_scale)
{ {
const blender::bke::AttributeAccessor b_attributes = b_pointcloud.attributes(); const blender::bke::AttributeAccessor b_attributes = b_pointcloud.attributes();
if (b_attributes.domain_size(ATTR_DOMAIN_POINT) == 0) { if (b_attributes.domain_size(blender::bke::AttrDomain::Point) == 0) {
return; return;
} }
@ -103,8 +103,8 @@ static void export_pointcloud(Scene *scene,
const float motion_scale) const float motion_scale)
{ {
const blender::Span<blender::float3> b_positions = b_pointcloud.positions(); const blender::Span<blender::float3> b_positions = b_pointcloud.positions();
const blender::VArraySpan b_radius = *b_pointcloud.attributes().lookup<float>("radius", const blender::VArraySpan b_radius = *b_pointcloud.attributes().lookup<float>(
ATTR_DOMAIN_POINT); "radius", blender::bke::AttrDomain::Point);
pointcloud->resize(b_positions.size()); pointcloud->resize(b_positions.size());
@ -158,8 +158,8 @@ static void export_pointcloud_motion(PointCloud *pointcloud,
const array<float3> &pointcloud_points = pointcloud->get_points(); const array<float3> &pointcloud_points = pointcloud->get_points();
const blender::Span<blender::float3> b_positions = b_pointcloud.positions(); const blender::Span<blender::float3> b_positions = b_pointcloud.positions();
const blender::VArraySpan b_radius = *b_pointcloud.attributes().lookup<float>("radius", const blender::VArraySpan b_radius = *b_pointcloud.attributes().lookup<float>(
ATTR_DOMAIN_POINT); "radius", blender::bke::AttrDomain::Point);
for (int i = 0; i < std::min<int>(num_points, b_positions.size()); i++) { for (int i = 0; i < std::min<int>(num_points, b_positions.size()); i++) {
const float3 P = make_float3(b_positions[i][0], b_positions[i][1], b_positions[i][2]); const float3 P = make_float3(b_positions[i][0], b_positions[i][1], b_positions[i][2]);

51
source/blender/blenkernel/BKE_attribute.h
View File

@ -13,29 +13,15 @@
#include "BKE_customdata.hh" #include "BKE_customdata.hh"
#ifdef __cplusplus namespace blender::bke {
extern "C" { enum class AttrDomain : int8_t;
#endif }
struct CustomData; struct CustomData;
struct CustomDataLayer; struct CustomDataLayer;
struct ID; struct ID;
struct ReportList; struct ReportList;
/** #Attribute.domain */ typedef enum AttrDomainMask {
typedef enum eAttrDomain {
ATTR_DOMAIN_AUTO = -1, /* Use for nodes to choose automatically based on other data. */
ATTR_DOMAIN_POINT = 0, /* Mesh, Curve or Point Cloud Point */
ATTR_DOMAIN_EDGE = 1, /* Mesh Edge */
ATTR_DOMAIN_FACE = 2, /* Mesh Face */
ATTR_DOMAIN_CORNER = 3, /* Mesh Corner */
ATTR_DOMAIN_CURVE = 4, /* A single curve in a larger curve data-block */
ATTR_DOMAIN_INSTANCE = 5, /* Instance */
ATTR_DOMAIN_LAYER = 6, /* A layer in a grease pencil data-block */
} eAttrDomain;
#define ATTR_DOMAIN_NUM 7
typedef enum eAttrDomainMask {
ATTR_DOMAIN_MASK_POINT = (1 << 0), ATTR_DOMAIN_MASK_POINT = (1 << 0),
ATTR_DOMAIN_MASK_EDGE = (1 << 1), ATTR_DOMAIN_MASK_EDGE = (1 << 1),
ATTR_DOMAIN_MASK_FACE = (1 << 2), ATTR_DOMAIN_MASK_FACE = (1 << 2),
@ -43,14 +29,14 @@ typedef enum eAttrDomainMask {
ATTR_DOMAIN_MASK_CURVE = (1 << 4), ATTR_DOMAIN_MASK_CURVE = (1 << 4),
ATTR_DOMAIN_MASK_GREASE_PENCIL_LAYER = (1 << 6), ATTR_DOMAIN_MASK_GREASE_PENCIL_LAYER = (1 << 6),
ATTR_DOMAIN_MASK_ALL = (1 << 7) - 1 ATTR_DOMAIN_MASK_ALL = (1 << 7) - 1
} eAttrDomainMask; } AttrDomainMask;
ENUM_OPERATORS(eAttrDomainMask, ATTR_DOMAIN_MASK_ALL); ENUM_OPERATORS(AttrDomainMask, ATTR_DOMAIN_MASK_ALL);
#define ATTR_DOMAIN_AS_MASK(domain) ((eAttrDomainMask)((1 << (int)(domain)))) #define ATTR_DOMAIN_AS_MASK(domain) ((AttrDomainMask)((1 << (int)(domain))))
/* All domains that support color attributes. */ /* All domains that support color attributes. */
#define ATTR_DOMAIN_MASK_COLOR \ #define ATTR_DOMAIN_MASK_COLOR \
((eAttrDomainMask)((ATTR_DOMAIN_MASK_POINT | ATTR_DOMAIN_MASK_CORNER))) ((AttrDomainMask)((ATTR_DOMAIN_MASK_POINT | ATTR_DOMAIN_MASK_CORNER)))
/* Attributes. */ /* Attributes. */
@ -63,7 +49,7 @@ bool BKE_attribute_allow_procedural_access(const char *attribute_name);
struct CustomDataLayer *BKE_id_attribute_new(struct ID *id, struct CustomDataLayer *BKE_id_attribute_new(struct ID *id,
const char *name, const char *name,
eCustomDataType type, eCustomDataType type,
eAttrDomain domain, blender::bke::AttrDomain domain,
struct ReportList *reports); struct ReportList *reports);
bool BKE_id_attribute_remove(struct ID *id, const char *name, struct ReportList *reports); bool BKE_id_attribute_remove(struct ID *id, const char *name, struct ReportList *reports);
@ -77,19 +63,20 @@ struct CustomDataLayer *BKE_id_attribute_duplicate(struct ID *id,
struct CustomDataLayer *BKE_id_attribute_find(const struct ID *id, struct CustomDataLayer *BKE_id_attribute_find(const struct ID *id,
const char *name, const char *name,
eCustomDataType type, eCustomDataType type,
eAttrDomain domain); blender::bke::AttrDomain domain);
const struct CustomDataLayer *BKE_id_attribute_search(const struct ID *id, const struct CustomDataLayer *BKE_id_attribute_search(const struct ID *id,
const char *name, const char *name,
eCustomDataMask type, eCustomDataMask type,
eAttrDomainMask domain_mask); AttrDomainMask domain_mask);
struct CustomDataLayer *BKE_id_attribute_search_for_write(struct ID *id, struct CustomDataLayer *BKE_id_attribute_search_for_write(struct ID *id,
const char *name, const char *name,
eCustomDataMask type, eCustomDataMask type,
eAttrDomainMask domain_mask); AttrDomainMask domain_mask);
eAttrDomain BKE_id_attribute_domain(const struct ID *id, const struct CustomDataLayer *layer); blender::bke::AttrDomain BKE_id_attribute_domain(const struct ID *id,
const struct CustomDataLayer *layer);
int BKE_id_attribute_data_length(struct ID *id, struct CustomDataLayer *layer); int BKE_id_attribute_data_length(struct ID *id, struct CustomDataLayer *layer);
bool BKE_id_attribute_required(const struct ID *id, const char *name); bool BKE_id_attribute_required(const struct ID *id, const char *name);
bool BKE_id_attribute_rename(struct ID *id, bool BKE_id_attribute_rename(struct ID *id,
@ -98,7 +85,7 @@ bool BKE_id_attribute_rename(struct ID *id,
struct ReportList *reports); struct ReportList *reports);
int BKE_id_attributes_length(const struct ID *id, int BKE_id_attributes_length(const struct ID *id,
eAttrDomainMask domain_mask, AttrDomainMask domain_mask,
eCustomDataMask mask); eCustomDataMask mask);
struct CustomDataLayer *BKE_id_attributes_active_get(struct ID *id); struct CustomDataLayer *BKE_id_attributes_active_get(struct ID *id);
@ -108,13 +95,13 @@ int *BKE_id_attributes_active_index_p(struct ID *id);
CustomData *BKE_id_attributes_iterator_next_domain(struct ID *id, struct CustomDataLayer *layers); CustomData *BKE_id_attributes_iterator_next_domain(struct ID *id, struct CustomDataLayer *layers);
CustomDataLayer *BKE_id_attribute_from_index(struct ID *id, CustomDataLayer *BKE_id_attribute_from_index(struct ID *id,
int lookup_index, int lookup_index,
eAttrDomainMask domain_mask, AttrDomainMask domain_mask,
eCustomDataMask layer_mask); eCustomDataMask layer_mask);
/** Layer is allowed to be nullptr; if so -1 (layer not found) will be returned. */ /** Layer is allowed to be nullptr; if so -1 (layer not found) will be returned. */
int BKE_id_attribute_to_index(const struct ID *id, int BKE_id_attribute_to_index(const struct ID *id,
const CustomDataLayer *layer, const CustomDataLayer *layer,
eAttrDomainMask domain_mask, AttrDomainMask domain_mask,
eCustomDataMask layer_mask); eCustomDataMask layer_mask);
const char *BKE_id_attributes_active_color_name(const struct ID *id); const char *BKE_id_attributes_active_color_name(const struct ID *id);
@ -129,7 +116,3 @@ void BKE_id_attribute_calc_unique_name(struct ID *id, const char *name, char *ou
const char *BKE_uv_map_vert_select_name_get(const char *uv_map_name, char *buffer); const char *BKE_uv_map_vert_select_name_get(const char *uv_map_name, char *buffer);
const char *BKE_uv_map_edge_select_name_get(const char *uv_map_name, char *buffer); const char *BKE_uv_map_edge_select_name_get(const char *uv_map_name, char *buffer);
const char *BKE_uv_map_pin_name_get(const char *uv_map_name, char *buffer); const char *BKE_uv_map_pin_name_get(const char *uv_map_name, char *buffer);
#ifdef __cplusplus
}
#endif

102
source/blender/blenkernel/BKE_attribute.hh
View File

@ -27,6 +27,26 @@ class GField;
namespace blender::bke { namespace blender::bke {
enum class AttrDomain : int8_t {
/* Use for to choose automatically based on other data. */
Auto = -1,
/* Mesh, Curve or Point Cloud Point. */
Point = 0,
/* Mesh Edge. */
Edge = 1,
/* Mesh Face. */
Face = 2,
/* Mesh Corner. */
Corner = 3,
/* A single curve in a larger curve data-block. */
Curve = 4,
/* Instance. */
Instance = 5,
/* A layer in a grease pencil data-block. */
Layer = 6,
};
#define ATTR_DOMAIN_NUM 7
/** /**
* Identifies an attribute with optional anonymous attribute information. * Identifies an attribute with optional anonymous attribute information.
* It does not own the identifier, so it is just a reference. * It does not own the identifier, so it is just a reference.
@ -62,14 +82,14 @@ class AttributeIDRef {
* stored (uv map, vertex group, ...). * stored (uv map, vertex group, ...).
*/ */
struct AttributeMetaData { struct AttributeMetaData {
eAttrDomain domain; AttrDomain domain;
eCustomDataType data_type; eCustomDataType data_type;
BLI_STRUCT_EQUALITY_OPERATORS_2(AttributeMetaData, domain, data_type) BLI_STRUCT_EQUALITY_OPERATORS_2(AttributeMetaData, domain, data_type)
}; };
struct AttributeKind { struct AttributeKind {
eAttrDomain domain; AttrDomain domain;
eCustomDataType data_type; eCustomDataType data_type;
}; };
@ -162,7 +182,7 @@ template<typename T> struct AttributeReader {
/** /**
* Domain where the attribute is stored. This also determines the size of the virtual array. * Domain where the attribute is stored. This also determines the size of the virtual array.
*/ */
eAttrDomain domain; AttrDomain domain;
/** /**
* Information about shared ownership of the attribute array. This will only be provided * Information about shared ownership of the attribute array. This will only be provided
@ -221,7 +241,7 @@ template<typename T> struct AttributeWriter {
* Domain where the attribute is stored on the geometry. Also determines the size of the virtual * Domain where the attribute is stored on the geometry. Also determines the size of the virtual
* array. * array.
*/ */
eAttrDomain domain; AttrDomain domain;
/** /**
* A function that has to be called after the attribute has been edited. This may be empty. * A function that has to be called after the attribute has been edited. This may be empty.
*/ */
@ -256,7 +276,7 @@ template<typename T> struct SpanAttributeWriter {
/** /**
* Domain of the attribute. Also determines the size of the span. * Domain of the attribute. Also determines the size of the span.
*/ */
eAttrDomain domain; AttrDomain domain;
/** /**
* Has to be called after writing to the span. * Has to be called after writing to the span.
*/ */
@ -297,7 +317,7 @@ template<typename T> struct SpanAttributeWriter {
*/ */
struct GAttributeReader { struct GAttributeReader {
GVArray varray; GVArray varray;
eAttrDomain domain; AttrDomain domain;
const ImplicitSharingInfo *sharing_info; const ImplicitSharingInfo *sharing_info;
operator bool() const operator bool() const
@ -325,7 +345,7 @@ struct GAttributeReader {
*/ */
struct GAttributeWriter { struct GAttributeWriter {
GVMutableArray varray; GVMutableArray varray;
eAttrDomain domain; AttrDomain domain;
std::function<void()> tag_modified_fn; std::function<void()> tag_modified_fn;
operator bool() const operator bool() const
@ -351,7 +371,7 @@ struct GAttributeWriter {
*/ */
struct GSpanAttributeWriter { struct GSpanAttributeWriter {
GMutableVArraySpan span; GMutableVArraySpan span;
eAttrDomain domain; AttrDomain domain;
std::function<void()> tag_modified_fn; std::function<void()> tag_modified_fn;
GSpanAttributeWriter() = default; GSpanAttributeWriter() = default;
@ -391,14 +411,14 @@ struct AttributeAccessorFunctions {
bool (*contains)(const void *owner, const AttributeIDRef &attribute_id); bool (*contains)(const void *owner, const AttributeIDRef &attribute_id);
std::optional<AttributeMetaData> (*lookup_meta_data)(const void *owner, std::optional<AttributeMetaData> (*lookup_meta_data)(const void *owner,
const AttributeIDRef &attribute_id); const AttributeIDRef &attribute_id);
bool (*domain_supported)(const void *owner, eAttrDomain domain); bool (*domain_supported)(const void *owner, AttrDomain domain);
int (*domain_size)(const void *owner, eAttrDomain domain); int (*domain_size)(const void *owner, AttrDomain domain);
bool (*is_builtin)(const void *owner, const AttributeIDRef &attribute_id); bool (*is_builtin)(const void *owner, const AttributeIDRef &attribute_id);
GAttributeReader (*lookup)(const void *owner, const AttributeIDRef &attribute_id); GAttributeReader (*lookup)(const void *owner, const AttributeIDRef &attribute_id);
GVArray (*adapt_domain)(const void *owner, GVArray (*adapt_domain)(const void *owner,
const GVArray &varray, const GVArray &varray,
eAttrDomain from_domain, AttrDomain from_domain,
eAttrDomain to_domain); AttrDomain to_domain);
bool (*for_all)(const void *owner, bool (*for_all)(const void *owner,
FunctionRef<bool(const AttributeIDRef &, const AttributeMetaData &)> fn); FunctionRef<bool(const AttributeIDRef &, const AttributeMetaData &)> fn);
AttributeValidator (*lookup_validator)(const void *owner, const AttributeIDRef &attribute_id); AttributeValidator (*lookup_validator)(const void *owner, const AttributeIDRef &attribute_id);
@ -406,7 +426,7 @@ struct AttributeAccessorFunctions {
bool (*remove)(void *owner, const AttributeIDRef &attribute_id); bool (*remove)(void *owner, const AttributeIDRef &attribute_id);
bool (*add)(void *owner, bool (*add)(void *owner,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
eAttrDomain domain, AttrDomain domain,
eCustomDataType data_type, eCustomDataType data_type,
const AttributeInit &initializer); const AttributeInit &initializer);
}; };
@ -460,7 +480,7 @@ class AttributeAccessor {
/** /**
* \return True, when attributes can exist on that domain. * \return True, when attributes can exist on that domain.
*/ */
bool domain_supported(const eAttrDomain domain) const bool domain_supported(const AttrDomain domain) const
{ {
return fn_->domain_supported(owner_, domain); return fn_->domain_supported(owner_, domain);
} }
@ -468,7 +488,7 @@ class AttributeAccessor {
/** /**
* \return Number of elements in the given domain. * \return Number of elements in the given domain.
*/ */
int domain_size(const eAttrDomain domain) const int domain_size(const AttrDomain domain) const
{ {
return fn_->domain_size(owner_, domain); return fn_->domain_size(owner_, domain);
} }
@ -496,14 +516,14 @@ class AttributeAccessor {
* given domain, and converted to the given type, in that order. The result may be empty. * given domain, and converted to the given type, in that order. The result may be empty.
*/ */
GAttributeReader lookup(const AttributeIDRef &attribute_id, GAttributeReader lookup(const AttributeIDRef &attribute_id,
const std::optional<eAttrDomain> domain, const std::optional<AttrDomain> domain,
const std::optional<eCustomDataType> data_type) const; const std::optional<eCustomDataType> data_type) const;
/** /**
* Get read-only access to the attribute whereby the attribute is interpolated to the given * Get read-only access to the attribute whereby the attribute is interpolated to the given
* domain. The result may be empty. * domain. The result may be empty.
*/ */
GAttributeReader lookup(const AttributeIDRef &attribute_id, const eAttrDomain domain) const GAttributeReader lookup(const AttributeIDRef &attribute_id, const AttrDomain domain) const
{ {
return this->lookup(attribute_id, domain, std::nullopt); return this->lookup(attribute_id, domain, std::nullopt);
} }
@ -524,7 +544,7 @@ class AttributeAccessor {
*/ */
template<typename T> template<typename T>
AttributeReader<T> lookup(const AttributeIDRef &attribute_id, AttributeReader<T> lookup(const AttributeIDRef &attribute_id,
const std::optional<eAttrDomain> domain = std::nullopt) const const std::optional<AttrDomain> domain = std::nullopt) const
{ {
const CPPType &cpp_type = CPPType::get<T>(); const CPPType &cpp_type = CPPType::get<T>();
const eCustomDataType data_type = cpp_type_to_custom_data_type(cpp_type); const eCustomDataType data_type = cpp_type_to_custom_data_type(cpp_type);
@ -538,7 +558,7 @@ class AttributeAccessor {
* If the passed in default value is null, the default value of the type is used (generally 0). * If the passed in default value is null, the default value of the type is used (generally 0).
*/ */
GAttributeReader lookup_or_default(const AttributeIDRef &attribute_id, GAttributeReader lookup_or_default(const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const void *default_value = nullptr) const; const void *default_value = nullptr) const;
@ -547,7 +567,7 @@ class AttributeAccessor {
*/ */
template<typename T> template<typename T>
AttributeReader<T> lookup_or_default(const AttributeIDRef &attribute_id, AttributeReader<T> lookup_or_default(const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const T &default_value) const const T &default_value) const
{ {
if (AttributeReader<T> varray = this->lookup<T>(attribute_id, domain)) { if (AttributeReader<T> varray = this->lookup<T>(attribute_id, domain)) {
@ -568,8 +588,8 @@ class AttributeAccessor {
* Interpolate data from one domain to another. * Interpolate data from one domain to another.
*/ */
GVArray adapt_domain(const GVArray &varray, GVArray adapt_domain(const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) const const AttrDomain to_domain) const
{ {
return fn_->adapt_domain(owner_, varray, from_domain, to_domain); return fn_->adapt_domain(owner_, varray, from_domain, to_domain);
} }
@ -579,8 +599,8 @@ class AttributeAccessor {
*/ */
template<typename T> template<typename T>
VArray<T> adapt_domain(const VArray<T> &varray, VArray<T> adapt_domain(const VArray<T> &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) const const AttrDomain to_domain) const
{ {
return this->adapt_domain(GVArray(varray), from_domain, to_domain).typed<T>(); return this->adapt_domain(GVArray(varray), from_domain, to_domain).typed<T>();
} }
@ -665,7 +685,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
* this attribute or there is already an attribute with that id. * this attribute or there is already an attribute with that id.
*/ */
bool add(const AttributeIDRef &attribute_id, bool add(const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer) const AttributeInit &initializer)
{ {
@ -673,7 +693,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
} }
template<typename T> template<typename T>
bool add(const AttributeIDRef &attribute_id, bool add(const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const AttributeInit &initializer) const AttributeInit &initializer)
{ {
const CPPType &cpp_type = CPPType::get<T>(); const CPPType &cpp_type = CPPType::get<T>();
@ -688,7 +708,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
*/ */
GAttributeWriter lookup_or_add_for_write( GAttributeWriter lookup_or_add_for_write(
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer = AttributeInitDefaultValue()); const AttributeInit &initializer = AttributeInitDefaultValue());
@ -699,7 +719,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
*/ */
GSpanAttributeWriter lookup_or_add_for_write_span( GSpanAttributeWriter lookup_or_add_for_write_span(
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer = AttributeInitDefaultValue()); const AttributeInit &initializer = AttributeInitDefaultValue());
@ -709,7 +729,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
template<typename T> template<typename T>
AttributeWriter<T> lookup_or_add_for_write( AttributeWriter<T> lookup_or_add_for_write(
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const AttributeInit &initializer = AttributeInitDefaultValue()) const AttributeInit &initializer = AttributeInitDefaultValue())
{ {
const CPPType &cpp_type = CPPType::get<T>(); const CPPType &cpp_type = CPPType::get<T>();
@ -723,7 +743,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
template<typename T> template<typename T>
SpanAttributeWriter<T> lookup_or_add_for_write_span( SpanAttributeWriter<T> lookup_or_add_for_write_span(
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const AttributeInit &initializer = AttributeInitDefaultValue()) const AttributeInit &initializer = AttributeInitDefaultValue())
{ {
AttributeWriter<T> attribute = this->lookup_or_add_for_write<T>( AttributeWriter<T> attribute = this->lookup_or_add_for_write<T>(
@ -745,7 +765,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
* For trivial types, the values in a newly created attribute will not be initialized. * For trivial types, the values in a newly created attribute will not be initialized.
*/ */
GSpanAttributeWriter lookup_or_add_for_write_only_span(const AttributeIDRef &attribute_id, GSpanAttributeWriter lookup_or_add_for_write_only_span(const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type); const eCustomDataType data_type);
/** /**
@ -753,7 +773,7 @@ class MutableAttributeAccessor : public AttributeAccessor {
*/ */
template<typename T> template<typename T>
SpanAttributeWriter<T> lookup_or_add_for_write_only_span(const AttributeIDRef &attribute_id, SpanAttributeWriter<T> lookup_or_add_for_write_only_span(const AttributeIDRef &attribute_id,
const eAttrDomain domain) const AttrDomain domain)
{ {
AttributeWriter<T> attribute = this->lookup_or_add_for_write<T>( AttributeWriter<T> attribute = this->lookup_or_add_for_write<T>(
attribute_id, domain, AttributeInitConstruct()); attribute_id, domain, AttributeInitConstruct());
@ -793,7 +813,7 @@ struct AttributeTransferData {
Vector<AttributeTransferData> retrieve_attributes_for_transfer( Vector<AttributeTransferData> retrieve_attributes_for_transfer(
const AttributeAccessor src_attributes, const AttributeAccessor src_attributes,
MutableAttributeAccessor dst_attributes, MutableAttributeAccessor dst_attributes,
eAttrDomainMask domain_mask, AttrDomainMask domain_mask,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip = {}); const Set<std::string> &skip = {});
@ -805,7 +825,7 @@ eCustomDataType attribute_data_type_highest_complexity(Span<eCustomDataType> dat
* Domains with a higher "information density" have a higher priority, * Domains with a higher "information density" have a higher priority,
* in order to choose a domain that will not lose data through domain conversion. * in order to choose a domain that will not lose data through domain conversion.
*/ */
eAttrDomain attribute_domain_highest_priority(Span<eAttrDomain> domains); AttrDomain attribute_domain_highest_priority(Span<AttrDomain> domains);
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name #AttributeIDRef Inline Methods /** \name #AttributeIDRef Inline Methods
@ -861,7 +881,7 @@ inline const AnonymousAttributeID &AttributeIDRef::anonymous_id() const
} }
void gather_attributes(AttributeAccessor src_attributes, void gather_attributes(AttributeAccessor src_attributes,
eAttrDomain domain, AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
const IndexMask &selection, const IndexMask &selection,
@ -871,7 +891,7 @@ void gather_attributes(AttributeAccessor src_attributes,
* Fill the destination attribute by gathering indexed values from src attributes. * Fill the destination attribute by gathering indexed values from src attributes.
*/ */
void gather_attributes(AttributeAccessor src_attributes, void gather_attributes(AttributeAccessor src_attributes,
eAttrDomain domain, AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
Span<int> indices, Span<int> indices,
@ -883,7 +903,7 @@ void gather_attributes(AttributeAccessor src_attributes,
* source and result group must be the same. * source and result group must be the same.
*/ */
void gather_attributes_group_to_group(AttributeAccessor src_attributes, void gather_attributes_group_to_group(AttributeAccessor src_attributes,
eAttrDomain domain, AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
OffsetIndices<int> src_offsets, OffsetIndices<int> src_offsets,
@ -892,7 +912,7 @@ void gather_attributes_group_to_group(AttributeAccessor src_attributes,
MutableAttributeAccessor dst_attributes); MutableAttributeAccessor dst_attributes);
void gather_attributes_to_groups(AttributeAccessor src_attributes, void gather_attributes_to_groups(AttributeAccessor src_attributes,
eAttrDomain domain, AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
OffsetIndices<int> dst_offsets, OffsetIndices<int> dst_offsets,
@ -900,13 +920,13 @@ void gather_attributes_to_groups(AttributeAccessor src_attributes,
MutableAttributeAccessor dst_attributes); MutableAttributeAccessor dst_attributes);
void copy_attributes(const AttributeAccessor src_attributes, void copy_attributes(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
MutableAttributeAccessor dst_attributes); MutableAttributeAccessor dst_attributes);
void copy_attributes_group_to_group(AttributeAccessor src_attributes, void copy_attributes_group_to_group(AttributeAccessor src_attributes,
eAttrDomain domain, AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
OffsetIndices<int> src_offsets, OffsetIndices<int> src_offsets,
@ -915,7 +935,7 @@ void copy_attributes_group_to_group(AttributeAccessor src_attributes,
MutableAttributeAccessor dst_attributes); MutableAttributeAccessor dst_attributes);
void fill_attribute_range_default(MutableAttributeAccessor dst_attributes, void fill_attribute_range_default(MutableAttributeAccessor dst_attributes,
eAttrDomain domain, AttrDomain domain,
const Set<std::string> &skip, const Set<std::string> &skip,
IndexRange range); IndexRange range);

2
source/blender/blenkernel/BKE_bake_items_socket.hh
View File

@ -23,7 +23,7 @@ struct BakeSocketConfig {
* The domain on which an the attribute corresponding to the socket should be stored (only used * The domain on which an the attribute corresponding to the socket should be stored (only used
* for some socket types). * for some socket types).
*/ */
Vector<eAttrDomain> domains; Vector<AttrDomain> domains;
/** /**
* Determines which geometries a field socket should be evaluated on. This can be used to * Determines which geometries a field socket should be evaluated on. This can be used to
* implement rules like a field should only be evaluated on the preceding or on all geometries. * implement rules like a field should only be evaluated on the preceding or on all geometries.

4
source/blender/blenkernel/BKE_curves.hh
View File

@ -394,9 +394,9 @@ class CurvesGeometry : public ::CurvesGeometry {
* Attributes. * Attributes.
*/ */
GVArray adapt_domain(const GVArray &varray, eAttrDomain from, eAttrDomain to) const; GVArray adapt_domain(const GVArray &varray, AttrDomain from, AttrDomain to) const;
template<typename T> template<typename T>
VArray<T> adapt_domain(const VArray<T> &varray, eAttrDomain from, eAttrDomain to) const VArray<T> adapt_domain(const VArray<T> &varray, AttrDomain from, AttrDomain to) const
{ {
return this->adapt_domain(GVArray(varray), from, to).typed<T>(); return this->adapt_domain(GVArray(varray), from, to).typed<T>();
} }

66
source/blender/blenkernel/BKE_geometry_fields.hh
View File

@ -28,16 +28,16 @@ class Drawing;
class MeshFieldContext : public fn::FieldContext { class MeshFieldContext : public fn::FieldContext {
private: private:
const Mesh &mesh_; const Mesh &mesh_;
eAttrDomain domain_; AttrDomain domain_;
public: public:
MeshFieldContext(const Mesh &mesh, eAttrDomain domain); MeshFieldContext(const Mesh &mesh, AttrDomain domain);
const Mesh &mesh() const const Mesh &mesh() const
{ {
return mesh_; return mesh_;
} }
eAttrDomain domain() const AttrDomain domain() const
{ {
return domain_; return domain_;
} }
@ -46,17 +46,17 @@ class MeshFieldContext : public fn::FieldContext {
class CurvesFieldContext : public fn::FieldContext { class CurvesFieldContext : public fn::FieldContext {
private: private:
const CurvesGeometry &curves_; const CurvesGeometry &curves_;
eAttrDomain domain_; AttrDomain domain_;
public: public:
CurvesFieldContext(const CurvesGeometry &curves, eAttrDomain domain); CurvesFieldContext(const CurvesGeometry &curves, AttrDomain domain);
const CurvesGeometry &curves() const const CurvesGeometry &curves() const
{ {
return curves_; return curves_;
} }
eAttrDomain domain() const AttrDomain domain() const
{ {
return domain_; return domain_;
} }
@ -91,12 +91,12 @@ class GreasePencilFieldContext : public fn::FieldContext {
class GreasePencilLayerFieldContext : public fn::FieldContext { class GreasePencilLayerFieldContext : public fn::FieldContext {
private: private:
const GreasePencil &grease_pencil_; const GreasePencil &grease_pencil_;
eAttrDomain domain_; AttrDomain domain_;
int layer_index_; int layer_index_;
public: public:
GreasePencilLayerFieldContext(const GreasePencil &grease_pencil, GreasePencilLayerFieldContext(const GreasePencil &grease_pencil,
eAttrDomain domain, AttrDomain domain,
int layer_index) int layer_index)
: grease_pencil_(grease_pencil), domain_(domain), layer_index_(layer_index) : grease_pencil_(grease_pencil), domain_(domain), layer_index_(layer_index)
{ {
@ -107,7 +107,7 @@ class GreasePencilLayerFieldContext : public fn::FieldContext {
return grease_pencil_; return grease_pencil_;
} }
eAttrDomain domain() const AttrDomain domain() const
{ {
return domain_; return domain_;
} }
@ -148,7 +148,7 @@ class GeometryFieldContext : public fn::FieldContext {
*/ */
const void *geometry_; const void *geometry_;
const GeometryComponent::Type type_; const GeometryComponent::Type type_;
eAttrDomain domain_; AttrDomain domain_;
/** /**
* Only used when the type is grease pencil and the domain is either points or curves * Only used when the type is grease pencil and the domain is either points or curves
* (not layers). * (not layers).
@ -158,16 +158,16 @@ class GeometryFieldContext : public fn::FieldContext {
friend GeometryFieldInput; friend GeometryFieldInput;
public: public:
GeometryFieldContext(const GeometryFieldContext &other, eAttrDomain domain); GeometryFieldContext(const GeometryFieldContext &other, AttrDomain domain);
GeometryFieldContext(const GeometryComponent &component, eAttrDomain domain); GeometryFieldContext(const GeometryComponent &component, AttrDomain domain);
GeometryFieldContext(const void *geometry, GeometryFieldContext(const void *geometry,
GeometryComponent::Type type, GeometryComponent::Type type,
eAttrDomain domain, AttrDomain domain,
int grease_pencil_layer_index); int grease_pencil_layer_index);
GeometryFieldContext(const Mesh &mesh, eAttrDomain domain); GeometryFieldContext(const Mesh &mesh, AttrDomain domain);
GeometryFieldContext(const CurvesGeometry &curves, eAttrDomain domain); GeometryFieldContext(const CurvesGeometry &curves, AttrDomain domain);
GeometryFieldContext(const GreasePencil &grease_pencil); GeometryFieldContext(const GreasePencil &grease_pencil);
GeometryFieldContext(const GreasePencil &grease_pencil, eAttrDomain domain, int layer_index); GeometryFieldContext(const GreasePencil &grease_pencil, AttrDomain domain, int layer_index);
GeometryFieldContext(const PointCloud &points); GeometryFieldContext(const PointCloud &points);
GeometryFieldContext(const Instances &instances); GeometryFieldContext(const Instances &instances);
@ -181,7 +181,7 @@ class GeometryFieldContext : public fn::FieldContext {
return type_; return type_;
} }
eAttrDomain domain() const AttrDomain domain() const
{ {
return domain_; return domain_;
} }
@ -189,7 +189,7 @@ class GeometryFieldContext : public fn::FieldContext {
int grease_pencil_layer_index() const int grease_pencil_layer_index() const
{ {
BLI_assert(this->type_ == GeometryComponent::Type::GreasePencil); BLI_assert(this->type_ == GeometryComponent::Type::GreasePencil);
BLI_assert(ELEM(this->domain_, ATTR_DOMAIN_LAYER, ATTR_DOMAIN_CURVE, ATTR_DOMAIN_POINT)); BLI_assert(ELEM(this->domain_, AttrDomain::Layer, AttrDomain::Curve, AttrDomain::Point));
return grease_pencil_layer_index_; return grease_pencil_layer_index_;
} }
@ -211,7 +211,7 @@ class GeometryFieldInput : public fn::FieldInput {
ResourceScope &scope) const override; ResourceScope &scope) const override;
virtual GVArray get_varray_for_context(const GeometryFieldContext &context, virtual GVArray get_varray_for_context(const GeometryFieldContext &context,
const IndexMask &mask) const = 0; const IndexMask &mask) const = 0;
virtual std::optional<eAttrDomain> preferred_domain(const GeometryComponent &component) const; virtual std::optional<AttrDomain> preferred_domain(const GeometryComponent &component) const;
}; };
class MeshFieldInput : public fn::FieldInput { class MeshFieldInput : public fn::FieldInput {
@ -221,9 +221,9 @@ class MeshFieldInput : public fn::FieldInput {
const IndexMask &mask, const IndexMask &mask,
ResourceScope &scope) const override; ResourceScope &scope) const override;
virtual GVArray get_varray_for_context(const Mesh &mesh, virtual GVArray get_varray_for_context(const Mesh &mesh,
eAttrDomain domain, AttrDomain domain,
const IndexMask &mask) const = 0; const IndexMask &mask) const = 0;
virtual std::optional<eAttrDomain> preferred_domain(const Mesh &mesh) const; virtual std::optional<AttrDomain> preferred_domain(const Mesh &mesh) const;
}; };
class CurvesFieldInput : public fn::FieldInput { class CurvesFieldInput : public fn::FieldInput {
@ -233,9 +233,9 @@ class CurvesFieldInput : public fn::FieldInput {
const IndexMask &mask, const IndexMask &mask,
ResourceScope &scope) const override; ResourceScope &scope) const override;
virtual GVArray get_varray_for_context(const CurvesGeometry &curves, virtual GVArray get_varray_for_context(const CurvesGeometry &curves,
eAttrDomain domain, AttrDomain domain,
const IndexMask &mask) const = 0; const IndexMask &mask) const = 0;
virtual std::optional<eAttrDomain> preferred_domain(const CurvesGeometry &curves) const; virtual std::optional<AttrDomain> preferred_domain(const CurvesGeometry &curves) const;
}; };
class PointCloudFieldInput : public fn::FieldInput { class PointCloudFieldInput : public fn::FieldInput {
@ -291,7 +291,7 @@ class AttributeFieldInput : public GeometryFieldInput {
uint64_t hash() const override; uint64_t hash() const override;
bool is_equal_to(const fn::FieldNode &other) const override; bool is_equal_to(const fn::FieldNode &other) const override;
std::optional<eAttrDomain> preferred_domain(const GeometryComponent &component) const override; std::optional<AttrDomain> preferred_domain(const GeometryComponent &component) const override;
}; };
class AttributeExistsFieldInput final : public bke::GeometryFieldInput { class AttributeExistsFieldInput final : public bke::GeometryFieldInput {
@ -332,7 +332,7 @@ class NamedLayerSelectionFieldInput final : public bke::GeometryFieldInput {
const IndexMask &mask) const final; const IndexMask &mask) const final;
uint64_t hash() const override; uint64_t hash() const override;
bool is_equal_to(const fn::FieldNode &other) const override; bool is_equal_to(const fn::FieldNode &other) const override;
std::optional<eAttrDomain> preferred_domain(const GeometryComponent &component) const override; std::optional<AttrDomain> preferred_domain(const GeometryComponent &component) const override;
}; };
class IDAttributeFieldInput : public GeometryFieldInput { class IDAttributeFieldInput : public GeometryFieldInput {
@ -351,9 +351,9 @@ class IDAttributeFieldInput : public GeometryFieldInput {
bool is_equal_to(const fn::FieldNode &other) const override; bool is_equal_to(const fn::FieldNode &other) const override;
}; };
VArray<float3> curve_normals_varray(const CurvesGeometry &curves, eAttrDomain domain); VArray<float3> curve_normals_varray(const CurvesGeometry &curves, AttrDomain domain);
VArray<float3> mesh_normals_varray(const Mesh &mesh, const IndexMask &mask, eAttrDomain domain); VArray<float3> mesh_normals_varray(const Mesh &mesh, const IndexMask &mask, AttrDomain domain);
class NormalFieldInput : public GeometryFieldInput { class NormalFieldInput : public GeometryFieldInput {
public: public:
@ -408,28 +408,28 @@ class AnonymousAttributeFieldInput : public GeometryFieldInput {
uint64_t hash() const override; uint64_t hash() const override;
bool is_equal_to(const fn::FieldNode &other) const override; bool is_equal_to(const fn::FieldNode &other) const override;
std::optional<eAttrDomain> preferred_domain(const GeometryComponent &component) const override; std::optional<AttrDomain> preferred_domain(const GeometryComponent &component) const override;
}; };
class CurveLengthFieldInput final : public CurvesFieldInput { class CurveLengthFieldInput final : public CurvesFieldInput {
public: public:
CurveLengthFieldInput(); CurveLengthFieldInput();
GVArray get_varray_for_context(const CurvesGeometry &curves, GVArray get_varray_for_context(const CurvesGeometry &curves,
eAttrDomain domain, AttrDomain domain,
const IndexMask &mask) const final; const IndexMask &mask) const final;
uint64_t hash() const override; uint64_t hash() const override;
bool is_equal_to(const fn::FieldNode &other) const override; bool is_equal_to(const fn::FieldNode &other) const override;
std::optional<eAttrDomain> preferred_domain(const bke::CurvesGeometry &curves) const final; std::optional<AttrDomain> preferred_domain(const bke::CurvesGeometry &curves) const final;
}; };
bool try_capture_field_on_geometry(GeometryComponent &component, bool try_capture_field_on_geometry(GeometryComponent &component,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
eAttrDomain domain, AttrDomain domain,
const fn::GField &field); const fn::GField &field);
bool try_capture_field_on_geometry(GeometryComponent &component, bool try_capture_field_on_geometry(GeometryComponent &component,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
eAttrDomain domain, AttrDomain domain,
const fn::Field<bool> &selection, const fn::Field<bool> &selection,
const fn::GField &field); const fn::GField &field);
@ -437,7 +437,7 @@ bool try_capture_field_on_geometry(GeometryComponent &component,
* Try to find the geometry domain that the field should be evaluated on. If it is not obvious * Try to find the geometry domain that the field should be evaluated on. If it is not obvious
* which domain is correct, none is returned. * which domain is correct, none is returned.
*/ */
std::optional<eAttrDomain> try_detect_field_domain(const GeometryComponent &component, std::optional<AttrDomain> try_detect_field_domain(const GeometryComponent &component,
const fn::GField &field); const fn::GField &field);
} // namespace blender::bke } // namespace blender::bke

2
source/blender/blenkernel/BKE_geometry_set.hh
View File

@ -78,7 +78,7 @@ class GeometryComponent : public ImplicitSharingMixin {
virtual ~GeometryComponent() = default; virtual ~GeometryComponent() = default;
static GeometryComponentPtr create(Type component_type); static GeometryComponentPtr create(Type component_type);
int attribute_domain_size(eAttrDomain domain) const; int attribute_domain_size(AttrDomain domain) const;
/** /**
* Get access to the attributes in this geometry component. May return none if the geometry does * Get access to the attributes in this geometry component. May return none if the geometry does

2
source/blender/blenkernel/BKE_mesh_sample.hh
View File

@ -178,7 +178,7 @@ class BaryWeightSampleFn : public mf::MultiFunction {
std::optional<bke::MeshFieldContext> source_context_; std::optional<bke::MeshFieldContext> source_context_;
std::unique_ptr<fn::FieldEvaluator> source_evaluator_; std::unique_ptr<fn::FieldEvaluator> source_evaluator_;
const GVArray *source_data_; const GVArray *source_data_;
eAttrDomain domain_; AttrDomain domain_;
public: public:
BaryWeightSampleFn(GeometrySet geometry, fn::GField src_field); BaryWeightSampleFn(GeometrySet geometry, fn::GField src_field);

8
source/blender/blenkernel/BKE_paint.hh
View File

@ -493,7 +493,7 @@ struct SculptAttributeParams {
struct SculptAttribute { struct SculptAttribute {
/* Domain, data type and name */ /* Domain, data type and name */
eAttrDomain domain; blender::bke::AttrDomain domain;
eCustomDataType proptype; eCustomDataType proptype;
char name[MAX_CUSTOMDATA_LAYER_NAME]; char name[MAX_CUSTOMDATA_LAYER_NAME];
@ -580,7 +580,7 @@ struct SculptSession {
MPropCol *vcol; MPropCol *vcol;
MLoopCol *mcol; MLoopCol *mcol;
eAttrDomain vcol_domain; blender::bke::AttrDomain vcol_domain;
eCustomDataType vcol_type; eCustomDataType vcol_type;
/* Mesh connectivity maps. */ /* Mesh connectivity maps. */
@ -762,14 +762,14 @@ int BKE_sculptsession_vertex_count(const SculptSession *ss);
/* Ensure an attribute layer exists. */ /* Ensure an attribute layer exists. */
SculptAttribute *BKE_sculpt_attribute_ensure(Object *ob, SculptAttribute *BKE_sculpt_attribute_ensure(Object *ob,
eAttrDomain domain, blender::bke::AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name, const char *name,
const SculptAttributeParams *params); const SculptAttributeParams *params);
/* Returns nullptr if attribute does not exist. */ /* Returns nullptr if attribute does not exist. */
SculptAttribute *BKE_sculpt_attribute_get(Object *ob, SculptAttribute *BKE_sculpt_attribute_get(Object *ob,
eAttrDomain domain, blender::bke::AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name); const char *name);

4
source/blender/blenkernel/BKE_pbvh_api.hh
View File

@ -528,7 +528,9 @@ blender::Span<blender::float3> BKE_pbvh_get_vert_normals(const PBVH *pbvh);
PBVHColorBufferNode *BKE_pbvh_node_color_buffer_get(PBVHNode *node); PBVHColorBufferNode *BKE_pbvh_node_color_buffer_get(PBVHNode *node);
void BKE_pbvh_node_color_buffer_free(PBVH *pbvh); void BKE_pbvh_node_color_buffer_free(PBVH *pbvh);
bool BKE_pbvh_get_color_layer(Mesh *mesh, CustomDataLayer **r_layer, eAttrDomain *r_domain); bool BKE_pbvh_get_color_layer(Mesh *mesh,
CustomDataLayer **r_layer,
blender::bke::AttrDomain *r_domain);
/* Swaps colors at each element in indices (of domain pbvh->vcol_domain) /* Swaps colors at each element in indices (of domain pbvh->vcol_domain)
* with values in colors. */ * with values in colors. */

4
source/blender/blenkernel/intern/DerivedMesh.cc
View File

@ -537,13 +537,13 @@ static void set_rest_position(Mesh &mesh)
if (positions) { if (positions) {
if (positions.sharing_info && positions.varray.is_span()) { if (positions.sharing_info && positions.varray.is_span()) {
attributes.add<float3>("rest_position", attributes.add<float3>("rest_position",
ATTR_DOMAIN_POINT, AttrDomain::Point,
AttributeInitShared(positions.varray.get_internal_span().data(), AttributeInitShared(positions.varray.get_internal_span().data(),
*positions.sharing_info)); *positions.sharing_info));
} }
else { else {
attributes.add<float3>( attributes.add<float3>(
"rest_position", ATTR_DOMAIN_POINT, AttributeInitVArray(positions.varray)); "rest_position", AttrDomain::Point, AttributeInitVArray(positions.varray));
} }
} }
} }

87
source/blender/blenkernel/intern/attribute.cc
View File

@ -39,6 +39,7 @@
#include "RNA_access.hh" #include "RNA_access.hh"
using blender::IndexRange; using blender::IndexRange;
using blender::bke::AttrDomain;
struct DomainInfo { struct DomainInfo {
CustomData *customdata; CustomData *customdata;
@ -52,8 +53,8 @@ static void get_domains(const ID *id, DomainInfo info[ATTR_DOMAIN_NUM])
switch (GS(id->name)) { switch (GS(id->name)) {
case ID_PT: { case ID_PT: {
PointCloud *pointcloud = (PointCloud *)id; PointCloud *pointcloud = (PointCloud *)id;
info[ATTR_DOMAIN_POINT].customdata = &pointcloud->pdata; info[int(AttrDomain::Point)].customdata = &pointcloud->pdata;
info[ATTR_DOMAIN_POINT].length = pointcloud->totpoint; info[int(AttrDomain::Point)].length = pointcloud->totpoint;
break; break;
} }
case ID_ME: { case ID_ME: {
@ -61,39 +62,39 @@ static void get_domains(const ID *id, DomainInfo info[ATTR_DOMAIN_NUM])
BMEditMesh *em = mesh->edit_mesh; BMEditMesh *em = mesh->edit_mesh;
if (em != nullptr) { if (em != nullptr) {
BMesh *bm = em->bm; BMesh *bm = em->bm;
info[ATTR_DOMAIN_POINT].customdata = &bm->vdata; info[int(AttrDomain::Point)].customdata = &bm->vdata;
info[ATTR_DOMAIN_POINT].length = bm->totvert; info[int(AttrDomain::Point)].length = bm->totvert;
info[ATTR_DOMAIN_EDGE].customdata = &bm->edata; info[int(AttrDomain::Edge)].customdata = &bm->edata;
info[ATTR_DOMAIN_EDGE].length = bm->totedge; info[int(AttrDomain::Edge)].length = bm->totedge;
info[ATTR_DOMAIN_CORNER].customdata = &bm->ldata; info[int(AttrDomain::Corner)].customdata = &bm->ldata;
info[ATTR_DOMAIN_CORNER].length = bm->totloop; info[int(AttrDomain::Corner)].length = bm->totloop;
info[ATTR_DOMAIN_FACE].customdata = &bm->pdata; info[int(AttrDomain::Face)].customdata = &bm->pdata;
info[ATTR_DOMAIN_FACE].length = bm->totface; info[int(AttrDomain::Face)].length = bm->totface;
} }
else { else {
info[ATTR_DOMAIN_POINT].customdata = &mesh->vert_data; info[int(AttrDomain::Point)].customdata = &mesh->vert_data;
info[ATTR_DOMAIN_POINT].length = mesh->verts_num; info[int(AttrDomain::Point)].length = mesh->verts_num;
info[ATTR_DOMAIN_EDGE].customdata = &mesh->edge_data; info[int(AttrDomain::Edge)].customdata = &mesh->edge_data;
info[ATTR_DOMAIN_EDGE].length = mesh->edges_num; info[int(AttrDomain::Edge)].length = mesh->edges_num;
info[ATTR_DOMAIN_CORNER].customdata = &mesh->corner_data; info[int(AttrDomain::Corner)].customdata = &mesh->corner_data;
info[ATTR_DOMAIN_CORNER].length = mesh->corners_num; info[int(AttrDomain::Corner)].length = mesh->corners_num;
info[ATTR_DOMAIN_FACE].customdata = &mesh->face_data; info[int(AttrDomain::Face)].customdata = &mesh->face_data;
info[ATTR_DOMAIN_FACE].length = mesh->faces_num; info[int(AttrDomain::Face)].length = mesh->faces_num;
} }
break; break;
} }
case ID_CV: { case ID_CV: {
Curves *curves = (Curves *)id; Curves *curves = (Curves *)id;
info[ATTR_DOMAIN_POINT].customdata = &curves->geometry.point_data; info[int(AttrDomain::Point)].customdata = &curves->geometry.point_data;
info[ATTR_DOMAIN_POINT].length = curves->geometry.point_num; info[int(AttrDomain::Point)].length = curves->geometry.point_num;
info[ATTR_DOMAIN_CURVE].customdata = &curves->geometry.curve_data; info[int(AttrDomain::Curve)].customdata = &curves->geometry.curve_data;
info[ATTR_DOMAIN_CURVE].length = curves->geometry.curve_num; info[int(AttrDomain::Curve)].length = curves->geometry.curve_num;
break; break;
} }
case ID_GP: { case ID_GP: {
GreasePencil *grease_pencil = (GreasePencil *)id; GreasePencil *grease_pencil = (GreasePencil *)id;
info[ATTR_DOMAIN_LAYER].customdata = &grease_pencil->layers_data; info[int(AttrDomain::Layer)].customdata = &grease_pencil->layers_data;
info[ATTR_DOMAIN_LAYER].length = grease_pencil->layers().size(); info[int(AttrDomain::Layer)].length = grease_pencil->layers().size();
break; break;
} }
default: default:
@ -279,14 +280,14 @@ void BKE_id_attribute_calc_unique_name(ID *id, const char *name, char *outname)
CustomDataLayer *BKE_id_attribute_new(ID *id, CustomDataLayer *BKE_id_attribute_new(ID *id,
const char *name, const char *name,
const eCustomDataType type, const eCustomDataType type,
const eAttrDomain domain, const AttrDomain domain,
ReportList *reports) ReportList *reports)
{ {
using namespace blender::bke; using namespace blender::bke;
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
get_domains(id, info); get_domains(id, info);
CustomData *customdata = info[domain].customdata; CustomData *customdata = info[int(domain)].customdata;
if (customdata == nullptr) { if (customdata == nullptr) {
BKE_report(reports, RPT_ERROR, "Attribute domain not supported by this geometry type"); BKE_report(reports, RPT_ERROR, "Attribute domain not supported by this geometry type");
return nullptr; return nullptr;
@ -453,7 +454,7 @@ bool BKE_id_attribute_remove(ID *id, const char *name, ReportList *reports)
id, color_name_from_index(id, color_clamp_index(id, default_color_index))); id, color_name_from_index(id, color_clamp_index(id, default_color_index)));
} }
if (type == CD_PROP_FLOAT2 && domain == ATTR_DOMAIN_CORNER) { if (type == CD_PROP_FLOAT2 && domain == int(AttrDomain::Corner)) {
char buffer[MAX_CUSTOMDATA_LAYER_NAME]; char buffer[MAX_CUSTOMDATA_LAYER_NAME];
BM_data_layer_free_named( BM_data_layer_free_named(
em->bm, data, BKE_uv_map_vert_select_name_get(name_copy.c_str(), buffer)); em->bm, data, BKE_uv_map_vert_select_name_get(name_copy.c_str(), buffer));
@ -501,7 +502,7 @@ bool BKE_id_attribute_remove(ID *id, const char *name, ReportList *reports)
id, color_name_from_index(id, color_clamp_index(id, default_color_index))); id, color_name_from_index(id, color_clamp_index(id, default_color_index)));
} }
if (metadata->data_type == CD_PROP_FLOAT2 && metadata->domain == ATTR_DOMAIN_CORNER) { if (metadata->data_type == CD_PROP_FLOAT2 && metadata->domain == AttrDomain::Corner) {
char buffer[MAX_CUSTOMDATA_LAYER_NAME]; char buffer[MAX_CUSTOMDATA_LAYER_NAME];
attributes->remove(BKE_uv_map_vert_select_name_get(name_copy.c_str(), buffer)); attributes->remove(BKE_uv_map_vert_select_name_get(name_copy.c_str(), buffer));
attributes->remove(BKE_uv_map_edge_select_name_get(name_copy.c_str(), buffer)); attributes->remove(BKE_uv_map_edge_select_name_get(name_copy.c_str(), buffer));
@ -516,7 +517,7 @@ bool BKE_id_attribute_remove(ID *id, const char *name, ReportList *reports)
CustomDataLayer *BKE_id_attribute_find(const ID *id, CustomDataLayer *BKE_id_attribute_find(const ID *id,
const char *name, const char *name,
const eCustomDataType type, const eCustomDataType type,
const eAttrDomain domain) const AttrDomain domain)
{ {
if (!name) { if (!name) {
return nullptr; return nullptr;
@ -524,7 +525,7 @@ CustomDataLayer *BKE_id_attribute_find(const ID *id,
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
get_domains(id, info); get_domains(id, info);
CustomData *customdata = info[domain].customdata; CustomData *customdata = info[int(domain)].customdata;
if (customdata == nullptr) { if (customdata == nullptr) {
return nullptr; return nullptr;
} }
@ -542,7 +543,7 @@ CustomDataLayer *BKE_id_attribute_find(const ID *id,
const CustomDataLayer *BKE_id_attribute_search(const ID *id, const CustomDataLayer *BKE_id_attribute_search(const ID *id,
const char *name, const char *name,
const eCustomDataMask type_mask, const eCustomDataMask type_mask,
const eAttrDomainMask domain_mask) const AttrDomainMask domain_mask)
{ {
if (!name) { if (!name) {
return nullptr; return nullptr;
@ -550,14 +551,14 @@ const CustomDataLayer *BKE_id_attribute_search(const ID *id,
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
get_domains(id, info); get_domains(id, info);
for (eAttrDomain domain = ATTR_DOMAIN_POINT; domain < ATTR_DOMAIN_NUM; for (AttrDomain domain = AttrDomain::Point; int(domain) < ATTR_DOMAIN_NUM;
domain = static_cast<eAttrDomain>(int(domain) + 1)) domain = AttrDomain(int(domain) + 1))
{ {
if (!(domain_mask & ATTR_DOMAIN_AS_MASK(domain))) { if (!(domain_mask & ATTR_DOMAIN_AS_MASK(domain))) {
continue; continue;
} }
CustomData *customdata = info[domain].customdata; CustomData *customdata = info[int(domain)].customdata;
if (customdata == nullptr) { if (customdata == nullptr) {
continue; continue;
} }
@ -576,7 +577,7 @@ const CustomDataLayer *BKE_id_attribute_search(const ID *id,
CustomDataLayer *BKE_id_attribute_search_for_write(ID *id, CustomDataLayer *BKE_id_attribute_search_for_write(ID *id,
const char *name, const char *name,
const eCustomDataMask type_mask, const eCustomDataMask type_mask,
const eAttrDomainMask domain_mask) const AttrDomainMask domain_mask)
{ {
/* Reuse the implementation of the const version. /* Reuse the implementation of the const version.
* Implicit sharing for the layer's data is handled below. */ * Implicit sharing for the layer's data is handled below. */
@ -589,13 +590,13 @@ CustomDataLayer *BKE_id_attribute_search_for_write(ID *id,
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
get_domains(id, info); get_domains(id, info);
const eAttrDomain domain = BKE_id_attribute_domain(id, layer); const AttrDomain domain = BKE_id_attribute_domain(id, layer);
CustomData_ensure_data_is_mutable(layer, info[domain].length); CustomData_ensure_data_is_mutable(layer, info[int(domain)].length);
return layer; return layer;
} }
int BKE_id_attributes_length(const ID *id, eAttrDomainMask domain_mask, eCustomDataMask mask) int BKE_id_attributes_length(const ID *id, AttrDomainMask domain_mask, eCustomDataMask mask)
{ {
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
get_domains(id, info); get_domains(id, info);
@ -616,7 +617,7 @@ int BKE_id_attributes_length(const ID *id, eAttrDomainMask domain_mask, eCustomD
return length; return length;
} }
eAttrDomain BKE_id_attribute_domain(const ID *id, const CustomDataLayer *layer) AttrDomain BKE_id_attribute_domain(const ID *id, const CustomDataLayer *layer)
{ {
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
get_domains(id, info); get_domains(id, info);
@ -627,12 +628,12 @@ eAttrDomain BKE_id_attribute_domain(const ID *id, const CustomDataLayer *layer)
continue; continue;
} }
if (ARRAY_HAS_ITEM((CustomDataLayer *)layer, customdata->layers, customdata->totlayer)) { if (ARRAY_HAS_ITEM((CustomDataLayer *)layer, customdata->layers, customdata->totlayer)) {
return static_cast<eAttrDomain>(domain); return AttrDomain(domain);
} }
} }
BLI_assert_msg(0, "Custom data layer not found in geometry"); BLI_assert_msg(0, "Custom data layer not found in geometry");
return static_cast<eAttrDomain>(ATTR_DOMAIN_POINT); return AttrDomain(AttrDomain::Point);
} }
int BKE_id_attribute_data_length(ID *id, CustomDataLayer *layer) int BKE_id_attribute_data_length(ID *id, CustomDataLayer *layer)
@ -774,7 +775,7 @@ CustomData *BKE_id_attributes_iterator_next_domain(ID *id, CustomDataLayer *laye
CustomDataLayer *BKE_id_attribute_from_index(ID *id, CustomDataLayer *BKE_id_attribute_from_index(ID *id,
int lookup_index, int lookup_index,
eAttrDomainMask domain_mask, AttrDomainMask domain_mask,
eCustomDataMask layer_mask) eCustomDataMask layer_mask)
{ {
DomainInfo info[ATTR_DOMAIN_NUM]; DomainInfo info[ATTR_DOMAIN_NUM];
@ -808,7 +809,7 @@ CustomDataLayer *BKE_id_attribute_from_index(ID *id,
int BKE_id_attribute_to_index(const ID *id, int BKE_id_attribute_to_index(const ID *id,
const CustomDataLayer *layer, const CustomDataLayer *layer,
eAttrDomainMask domain_mask, AttrDomainMask domain_mask,
eCustomDataMask layer_mask) eCustomDataMask layer_mask)
{ {
if (!layer) { if (!layer) {

50
source/blender/blenkernel/intern/attribute_access.cc
View File

@ -132,22 +132,22 @@ eCustomDataType attribute_data_type_highest_complexity(Span<eCustomDataType> dat
* \note Generally the order should mirror the order of the domains * \note Generally the order should mirror the order of the domains
* established in each component's ComponentAttributeProviders. * established in each component's ComponentAttributeProviders.
*/ */
static int attribute_domain_priority(const eAttrDomain domain) static int attribute_domain_priority(const AttrDomain domain)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_INSTANCE: case AttrDomain::Instance:
return 0; return 0;
case ATTR_DOMAIN_LAYER: case AttrDomain::Layer:
return 1; return 1;
case ATTR_DOMAIN_CURVE: case AttrDomain::Curve:
return 2; return 2;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return 3; return 3;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
return 4; return 4;
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return 5; return 5;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
return 6; return 6;
default: default:
/* Domain not supported in nodes yet. */ /* Domain not supported in nodes yet. */
@ -156,12 +156,12 @@ static int attribute_domain_priority(const eAttrDomain domain)
} }
} }
eAttrDomain attribute_domain_highest_priority(Span<eAttrDomain> domains) AttrDomain attribute_domain_highest_priority(Span<AttrDomain> domains)
{ {
int highest_priority = INT_MIN; int highest_priority = INT_MIN;
eAttrDomain highest_priority_domain = ATTR_DOMAIN_CORNER; AttrDomain highest_priority_domain = AttrDomain::Corner;
for (const eAttrDomain domain : domains) { for (const AttrDomain domain : domains) {
const int priority = attribute_domain_priority(domain); const int priority = attribute_domain_priority(domain);
if (priority > highest_priority) { if (priority > highest_priority) {
highest_priority = priority; highest_priority = priority;
@ -539,7 +539,7 @@ bool CustomDataAttributeProvider::try_delete(void *owner, const AttributeIDRef &
bool CustomDataAttributeProvider::try_create(void *owner, bool CustomDataAttributeProvider::try_create(void *owner,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer) const const AttributeInit &initializer) const
{ {
@ -595,7 +595,7 @@ static GVArray try_adapt_data_type(GVArray varray, const CPPType &to_type)
} }
GAttributeReader AttributeAccessor::lookup(const AttributeIDRef &attribute_id, GAttributeReader AttributeAccessor::lookup(const AttributeIDRef &attribute_id,
const std::optional<eAttrDomain> domain, const std::optional<AttrDomain> domain,
const std::optional<eCustomDataType> data_type) const const std::optional<eCustomDataType> data_type) const
{ {
GAttributeReader attribute = this->lookup(attribute_id); GAttributeReader attribute = this->lookup(attribute_id);
@ -626,7 +626,7 @@ GAttributeReader AttributeAccessor::lookup(const AttributeIDRef &attribute_id,
} }
GAttributeReader AttributeAccessor::lookup_or_default(const AttributeIDRef &attribute_id, GAttributeReader AttributeAccessor::lookup_or_default(const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const void *default_value) const const void *default_value) const
{ {
@ -716,7 +716,7 @@ GSpanAttributeWriter MutableAttributeAccessor::lookup_for_write_span(
GAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write( GAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write(
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer) const AttributeInit &initializer)
{ {
@ -735,7 +735,7 @@ GAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write(
GSpanAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write_span( GSpanAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write_span(
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer) const AttributeInit &initializer)
{ {
@ -748,7 +748,7 @@ GSpanAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write_span(
} }
GSpanAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write_only_span( GSpanAttributeWriter MutableAttributeAccessor::lookup_or_add_for_write_only_span(
const AttributeIDRef &attribute_id, const eAttrDomain domain, const eCustomDataType data_type) const AttributeIDRef &attribute_id, const AttrDomain domain, const eCustomDataType data_type)
{ {
GAttributeWriter attribute = this->lookup_or_add_for_write( GAttributeWriter attribute = this->lookup_or_add_for_write(
attribute_id, domain, data_type, AttributeInitConstruct()); attribute_id, domain, data_type, AttributeInitConstruct());
@ -807,7 +807,7 @@ fn::GField AttributeValidator::validate_field_if_necessary(const fn::GField &fie
Vector<AttributeTransferData> retrieve_attributes_for_transfer( Vector<AttributeTransferData> retrieve_attributes_for_transfer(
const AttributeAccessor src_attributes, const AttributeAccessor src_attributes,
MutableAttributeAccessor dst_attributes, MutableAttributeAccessor dst_attributes,
const eAttrDomainMask domain_mask, const AttrDomainMask domain_mask,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip) const Set<std::string> &skip)
{ {
@ -836,7 +836,7 @@ Vector<AttributeTransferData> retrieve_attributes_for_transfer(
/** \} */ /** \} */
void gather_attributes(const AttributeAccessor src_attributes, void gather_attributes(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
const IndexMask &selection, const IndexMask &selection,
@ -895,7 +895,7 @@ static bool indices_are_range(const Span<int> indices, const IndexRange range)
} }
void gather_attributes(const AttributeAccessor src_attributes, void gather_attributes(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
const Span<int> indices, const Span<int> indices,
@ -929,7 +929,7 @@ void gather_attributes(const AttributeAccessor src_attributes,
} }
void gather_attributes_group_to_group(const AttributeAccessor src_attributes, void gather_attributes_group_to_group(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
const OffsetIndices<int> src_offsets, const OffsetIndices<int> src_offsets,
@ -960,7 +960,7 @@ void gather_attributes_group_to_group(const AttributeAccessor src_attributes,
} }
void gather_attributes_to_groups(const AttributeAccessor src_attributes, void gather_attributes_to_groups(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
const OffsetIndices<int> dst_offsets, const OffsetIndices<int> dst_offsets,
@ -990,7 +990,7 @@ void gather_attributes_to_groups(const AttributeAccessor src_attributes,
} }
void copy_attributes(const AttributeAccessor src_attributes, void copy_attributes(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
MutableAttributeAccessor dst_attributes) MutableAttributeAccessor dst_attributes)
@ -1005,7 +1005,7 @@ void copy_attributes(const AttributeAccessor src_attributes,
} }
void copy_attributes_group_to_group(const AttributeAccessor src_attributes, void copy_attributes_group_to_group(const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const AnonymousAttributePropagationInfo &propagation_info, const AnonymousAttributePropagationInfo &propagation_info,
const Set<std::string> &skip, const Set<std::string> &skip,
const OffsetIndices<int> src_offsets, const OffsetIndices<int> src_offsets,
@ -1039,7 +1039,7 @@ void copy_attributes_group_to_group(const AttributeAccessor src_attributes,
} }
void fill_attribute_range_default(MutableAttributeAccessor attributes, void fill_attribute_range_default(MutableAttributeAccessor attributes,
const eAttrDomain domain, const AttrDomain domain,
const Set<std::string> &skip, const Set<std::string> &skip,
const IndexRange range) const IndexRange range)
{ {

28
source/blender/blenkernel/intern/attribute_access_intern.hh
View File

@ -46,7 +46,7 @@ class BuiltinAttributeProvider {
protected: protected:
const std::string name_; const std::string name_;
const eAttrDomain domain_; const AttrDomain domain_;
const eCustomDataType data_type_; const eCustomDataType data_type_;
const CreatableEnum createable_; const CreatableEnum createable_;
const DeletableEnum deletable_; const DeletableEnum deletable_;
@ -54,7 +54,7 @@ class BuiltinAttributeProvider {
public: public:
BuiltinAttributeProvider(std::string name, BuiltinAttributeProvider(std::string name,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const CreatableEnum createable, const CreatableEnum createable,
const DeletableEnum deletable, const DeletableEnum deletable,
@ -79,7 +79,7 @@ class BuiltinAttributeProvider {
return name_; return name_;
} }
eAttrDomain domain() const AttrDomain domain() const
{ {
return domain_; return domain_;
} }
@ -108,7 +108,7 @@ class DynamicAttributesProvider {
virtual bool try_delete(void *owner, const AttributeIDRef &attribute_id) const = 0; virtual bool try_delete(void *owner, const AttributeIDRef &attribute_id) const = 0;
virtual bool try_create(void *owner, virtual bool try_create(void *owner,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer) const const AttributeInit &initializer) const
{ {
@ -119,7 +119,7 @@ class DynamicAttributesProvider {
virtual bool foreach_attribute(const void *owner, virtual bool foreach_attribute(const void *owner,
const AttributeForeachCallback callback) const = 0; const AttributeForeachCallback callback) const = 0;
virtual void foreach_domain(const FunctionRef<void(eAttrDomain)> callback) const = 0; virtual void foreach_domain(const FunctionRef<void(AttrDomain)> callback) const = 0;
}; };
/** /**
@ -128,11 +128,11 @@ class DynamicAttributesProvider {
class CustomDataAttributeProvider final : public DynamicAttributesProvider { class CustomDataAttributeProvider final : public DynamicAttributesProvider {
private: private:
static constexpr uint64_t supported_types_mask = CD_MASK_PROP_ALL; static constexpr uint64_t supported_types_mask = CD_MASK_PROP_ALL;
eAttrDomain domain_; AttrDomain domain_;
CustomDataAccessInfo custom_data_access_; CustomDataAccessInfo custom_data_access_;
public: public:
CustomDataAttributeProvider(const eAttrDomain domain, CustomDataAttributeProvider(const AttrDomain domain,
const CustomDataAccessInfo custom_data_access) const CustomDataAccessInfo custom_data_access)
: domain_(domain), custom_data_access_(custom_data_access) : domain_(domain), custom_data_access_(custom_data_access)
{ {
@ -147,13 +147,13 @@ class CustomDataAttributeProvider final : public DynamicAttributesProvider {
bool try_create(void *owner, bool try_create(void *owner,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
eAttrDomain domain, AttrDomain domain,
const eCustomDataType data_type, const eCustomDataType data_type,
const AttributeInit &initializer) const final; const AttributeInit &initializer) const final;
bool foreach_attribute(const void *owner, const AttributeForeachCallback callback) const final; bool foreach_attribute(const void *owner, const AttributeForeachCallback callback) const final;
void foreach_domain(const FunctionRef<void(eAttrDomain)> callback) const final void foreach_domain(const FunctionRef<void(AttrDomain)> callback) const final
{ {
callback(domain_); callback(domain_);
} }
@ -181,7 +181,7 @@ class BuiltinCustomDataLayerProvider final : public BuiltinAttributeProvider {
public: public:
BuiltinCustomDataLayerProvider(std::string attribute_name, BuiltinCustomDataLayerProvider(std::string attribute_name,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType attribute_type, const eCustomDataType attribute_type,
const eCustomDataType stored_type, const eCustomDataType stored_type,
const CreatableEnum creatable, const CreatableEnum creatable,
@ -229,7 +229,7 @@ class ComponentAttributeProviders {
/** /**
* All the domains that are supported by at least one of the providers above. * All the domains that are supported by at least one of the providers above.
*/ */
VectorSet<eAttrDomain> supported_domains_; VectorSet<AttrDomain> supported_domains_;
public: public:
ComponentAttributeProviders(Span<const BuiltinAttributeProvider *> builtin_attribute_providers, ComponentAttributeProviders(Span<const BuiltinAttributeProvider *> builtin_attribute_providers,
@ -242,7 +242,7 @@ class ComponentAttributeProviders {
supported_domains_.add(provider->domain()); supported_domains_.add(provider->domain());
} }
for (const DynamicAttributesProvider *provider : dynamic_attribute_providers) { for (const DynamicAttributesProvider *provider : dynamic_attribute_providers) {
provider->foreach_domain([&](eAttrDomain domain) { supported_domains_.add(domain); }); provider->foreach_domain([&](AttrDomain domain) { supported_domains_.add(domain); });
} }
} }
@ -256,7 +256,7 @@ class ComponentAttributeProviders {
return dynamic_attribute_providers_; return dynamic_attribute_providers_;
} }
Span<eAttrDomain> supported_domains() const Span<AttrDomain> supported_domains() const
{ {
return supported_domains_; return supported_domains_;
} }
@ -414,7 +414,7 @@ inline bool remove(void *owner, const AttributeIDRef &attribute_id)
template<const ComponentAttributeProviders &providers> template<const ComponentAttributeProviders &providers>
inline bool add(void *owner, inline bool add(void *owner,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
eAttrDomain domain, AttrDomain domain,
eCustomDataType data_type, eCustomDataType data_type,
const AttributeInit &initializer) const AttributeInit &initializer)
{ {

10
source/blender/blenkernel/intern/bake_items_serialize.cc
View File

@ -161,10 +161,10 @@ static StringRefNull get_endian_io_name(const int endian)
return "big"; return "big";
} }
static StringRefNull get_domain_io_name(const eAttrDomain domain) static StringRefNull get_domain_io_name(const AttrDomain domain)
{ {
const char *io_name = "unknown"; const char *io_name = "unknown";
RNA_enum_id_from_value(rna_enum_attribute_domain_items, domain, &io_name); RNA_enum_id_from_value(rna_enum_attribute_domain_items, int(domain), &io_name);
return io_name; return io_name;
} }
@ -175,13 +175,13 @@ static StringRefNull get_data_type_io_name(const eCustomDataType data_type)
return io_name; return io_name;
} }
static std::optional<eAttrDomain> get_domain_from_io_name(const StringRefNull io_name) static std::optional<AttrDomain> get_domain_from_io_name(const StringRefNull io_name)
{ {
int domain; int domain;
if (!RNA_enum_value_from_identifier(rna_enum_attribute_domain_items, io_name.c_str(), &domain)) { if (!RNA_enum_value_from_identifier(rna_enum_attribute_domain_items, io_name.c_str(), &domain)) {
return std::nullopt; return std::nullopt;
} }
return eAttrDomain(domain); return AttrDomain(domain);
} }
static std::optional<eCustomDataType> get_data_type_from_io_name(const StringRefNull io_name) static std::optional<eCustomDataType> get_data_type_from_io_name(const StringRefNull io_name)
@ -382,7 +382,7 @@ template<typename T>
return false; return false;
} }
const std::optional<eAttrDomain> domain = get_domain_from_io_name(*domain_str); const std::optional<AttrDomain> domain = get_domain_from_io_name(*domain_str);
const std::optional<eCustomDataType> data_type = get_data_type_from_io_name(*type_str); const std::optional<eCustomDataType> data_type = get_data_type_from_io_name(*type_str);
if (!domain || !data_type) { if (!domain || !data_type) {
return false; return false;

2
source/blender/blenkernel/intern/bake_items_socket.cc
View File

@ -61,7 +61,7 @@ Array<std::unique_ptr<BakeItem>> move_socket_values_to_bake_items(const Span<voi
auto &value_variant = *static_cast<SocketValueVariant *>(socket_value); auto &value_variant = *static_cast<SocketValueVariant *>(socket_value);
if (value_variant.is_context_dependent_field()) { if (value_variant.is_context_dependent_field()) {
const fn::GField &field = value_variant.get<fn::GField>(); const fn::GField &field = value_variant.get<fn::GField>();
const eAttrDomain domain = config.domains[i]; const AttrDomain domain = config.domains[i];
const std::string attribute_name = ".bake_" + std::to_string(i); const std::string attribute_name = ".bake_" + std::to_string(i);
const Span<int> geometry_indices = config.geometries_by_attribute[i]; const Span<int> geometry_indices = config.geometries_by_attribute[i];
for (const int geometry_i : geometry_indices) { for (const int geometry_i : geometry_indices) {

4
source/blender/blenkernel/intern/bvhutils.cc
View File

@ -1122,6 +1122,8 @@ BVHTree *BKE_bvhtree_from_mesh_get(BVHTreeFromMesh *data,
const BVHCacheType bvh_cache_type, const BVHCacheType bvh_cache_type,
const int tree_type) const int tree_type)
{ {
using namespace blender;
using namespace blender::bke;
BVHCache **bvh_cache_p = (BVHCache **)&mesh->runtime->bvh_cache; BVHCache **bvh_cache_p = (BVHCache **)&mesh->runtime->bvh_cache;
Span<int3> corner_tris; Span<int3> corner_tris;
@ -1196,7 +1198,7 @@ BVHTree *BKE_bvhtree_from_mesh_get(BVHTreeFromMesh *data,
int mask_bits_act_len = -1; int mask_bits_act_len = -1;
const BitVector<> mask = corner_tris_no_hidden_map_get( const BitVector<> mask = corner_tris_no_hidden_map_get(
mesh->faces(), mesh->faces(),
*attributes.lookup_or_default(".hide_poly", ATTR_DOMAIN_FACE, false), *attributes.lookup_or_default(".hide_poly", AttrDomain::Face, false),
corner_tris.size(), corner_tris.size(),
&mask_bits_act_len); &mask_bits_act_len);
data->tree = bvhtree_from_mesh_corner_tris_create_tree( data->tree = bvhtree_from_mesh_corner_tris_create_tree(

2
source/blender/blenkernel/intern/curve_legacy_convert.cc
View File

@ -116,7 +116,7 @@ Curves *curve_legacy_to_curves(const Curve &curve_legacy, const ListBase &nurbs_
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
MutableSpan<float3> positions = curves.positions_for_write(); MutableSpan<float3> positions = curves.positions_for_write();
SpanAttributeWriter<float> radius_attribute = SpanAttributeWriter<float> radius_attribute =
curves_attributes.lookup_or_add_for_write_only_span<float>("radius", ATTR_DOMAIN_POINT); curves_attributes.lookup_or_add_for_write_only_span<float>("radius", AttrDomain::Point);
MutableSpan<float> radii = radius_attribute.span; MutableSpan<float> radii = radius_attribute.span;
MutableSpan<float> tilts = curves.tilt_for_write(); MutableSpan<float> tilts = curves.tilt_for_write();

72
source/blender/blenkernel/intern/curve_to_mesh_convert.cc
View File

@ -334,17 +334,17 @@ static ResultOffsets calculate_result_offsets(const CurvesInfo &info, const bool
return result; return result;
} }
static eAttrDomain get_attribute_domain_for_mesh(const AttributeAccessor &mesh_attributes, static AttrDomain get_attribute_domain_for_mesh(const AttributeAccessor &mesh_attributes,
const AttributeIDRef &attribute_id) const AttributeIDRef &attribute_id)
{ {
/* Only use a different domain if it is builtin and must only exist on one domain. */ /* Only use a different domain if it is builtin and must only exist on one domain. */
if (!mesh_attributes.is_builtin(attribute_id)) { if (!mesh_attributes.is_builtin(attribute_id)) {
return ATTR_DOMAIN_POINT; return AttrDomain::Point;
} }
std::optional<AttributeMetaData> meta_data = mesh_attributes.lookup_meta_data(attribute_id); std::optional<AttributeMetaData> meta_data = mesh_attributes.lookup_meta_data(attribute_id);
if (!meta_data) { if (!meta_data) {
return ATTR_DOMAIN_POINT; return AttrDomain::Point;
} }
return meta_data->domain; return meta_data->domain;
@ -461,14 +461,14 @@ static void build_mesh_positions(const CurvesInfo &curves_info,
const GAttributeReader src = curves_info.main.attributes().lookup("position"); const GAttributeReader src = curves_info.main.attributes().lookup("position");
if (src.sharing_info && src.varray.is_span()) { if (src.sharing_info && src.varray.is_span()) {
const AttributeInitShared init(src.varray.get_internal_span().data(), *src.sharing_info); const AttributeInitShared init(src.varray.get_internal_span().data(), *src.sharing_info);
if (mesh.attributes_for_write().add<float3>("position", ATTR_DOMAIN_POINT, init)) { if (mesh.attributes_for_write().add<float3>("position", AttrDomain::Point, init)) {
return; return;
} }
} }
} }
} }
const Span<float3> main_positions = curves_info.main.evaluated_positions(); const Span<float3> main_positions = curves_info.main.evaluated_positions();
mesh.attributes_for_write().add<float3>("position", ATTR_DOMAIN_POINT, AttributeInitConstruct()); mesh.attributes_for_write().add<float3>("position", AttrDomain::Point, AttributeInitConstruct());
MutableSpan<float3> positions = mesh.vert_positions_for_write(); MutableSpan<float3> positions = mesh.vert_positions_for_write();
if (ignore_profile_position) { if (ignore_profile_position) {
array_utils::copy(main_positions, positions); array_utils::copy(main_positions, positions);
@ -477,7 +477,7 @@ static void build_mesh_positions(const CurvesInfo &curves_info,
const Span<float3> tangents = curves_info.main.evaluated_tangents(); const Span<float3> tangents = curves_info.main.evaluated_tangents();
const Span<float3> normals = curves_info.main.evaluated_normals(); const Span<float3> normals = curves_info.main.evaluated_normals();
Span<float> radii_eval = {}; Span<float> radii_eval = {};
if (const GVArray radii = *curves_info.main.attributes().lookup("radius", ATTR_DOMAIN_POINT)) { if (const GVArray radii = *curves_info.main.attributes().lookup("radius", AttrDomain::Point)) {
radii_eval = evaluate_attribute(radii, curves_info.main, eval_buffer).typed<float>(); radii_eval = evaluate_attribute(radii, curves_info.main, eval_buffer).typed<float>();
} }
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
@ -534,7 +534,7 @@ static bool try_sharing_point_data(const CurvesGeometry &main,
const GAttributeReader &src, const GAttributeReader &src,
MutableAttributeAccessor mesh_attributes) MutableAttributeAccessor mesh_attributes)
{ {
if (mesh_attributes.domain_size(ATTR_DOMAIN_POINT) != main.points_num()) { if (mesh_attributes.domain_size(AttrDomain::Point) != main.points_num()) {
return false; return false;
} }
if (!src.sharing_info || !src.varray.is_span()) { if (!src.sharing_info || !src.varray.is_span()) {
@ -542,7 +542,7 @@ static bool try_sharing_point_data(const CurvesGeometry &main,
} }
return mesh_attributes.add( return mesh_attributes.add(
id, id,
ATTR_DOMAIN_POINT, AttrDomain::Point,
bke::cpp_type_to_custom_data_type(src.varray.type()), bke::cpp_type_to_custom_data_type(src.varray.type()),
AttributeInitShared(src.varray.get_internal_span().data(), *src.sharing_info)); AttributeInitShared(src.varray.get_internal_span().data(), *src.sharing_info));
} }
@ -564,12 +564,12 @@ static bool try_direct_evaluate_point_data(const CurvesGeometry &main,
static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_info, static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_info,
const AttributeIDRef &id, const AttributeIDRef &id,
const ResultOffsets &offsets, const ResultOffsets &offsets,
const eAttrDomain dst_domain, const AttrDomain dst_domain,
const GAttributeReader &src_attribute, const GAttributeReader &src_attribute,
Vector<std::byte> &eval_buffer, Vector<std::byte> &eval_buffer,
MutableAttributeAccessor mesh_attributes) MutableAttributeAccessor mesh_attributes)
{ {
if (dst_domain == ATTR_DOMAIN_POINT) { if (dst_domain == AttrDomain::Point) {
if (try_sharing_point_data(curves_info.main, id, src_attribute, mesh_attributes)) { if (try_sharing_point_data(curves_info.main, id, src_attribute, mesh_attributes)) {
return; return;
} }
@ -579,7 +579,7 @@ static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_in
if (!dst_attribute) { if (!dst_attribute) {
return; return;
} }
if (dst_domain == ATTR_DOMAIN_POINT) { if (dst_domain == AttrDomain::Point) {
if (try_direct_evaluate_point_data(curves_info.main, src_attribute, dst_attribute.span)) { if (try_direct_evaluate_point_data(curves_info.main, src_attribute, dst_attribute.span)) {
dst_attribute.finish(); dst_attribute.finish();
return; return;
@ -591,13 +591,13 @@ static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_in
const Span<T> src = src_all.typed<T>(); const Span<T> src = src_all.typed<T>();
MutableSpan<T> dst = dst_attribute.span.typed<T>(); MutableSpan<T> dst = dst_attribute.span.typed<T>();
switch (dst_domain) { switch (dst_domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
copy_main_point_data_to_mesh_verts( copy_main_point_data_to_mesh_verts(
src.slice(info.main_points), info.profile_points.size(), dst.slice(info.vert_range)); src.slice(info.main_points), info.profile_points.size(), dst.slice(info.vert_range));
}); });
break; break;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
copy_main_point_data_to_mesh_edges(src.slice(info.main_points), copy_main_point_data_to_mesh_edges(src.slice(info.main_points),
info.profile_points.size(), info.profile_points.size(),
@ -606,7 +606,7 @@ static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_in
dst.slice(info.edge_range)); dst.slice(info.edge_range));
}); });
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
copy_main_point_data_to_mesh_faces(src.slice(info.main_points), copy_main_point_data_to_mesh_faces(src.slice(info.main_points),
info.main_segment_num, info.main_segment_num,
@ -614,7 +614,7 @@ static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_in
dst.slice(info.face_range)); dst.slice(info.face_range));
}); });
break; break;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
/* Unsupported for now, since there are no builtin attributes to convert into. */ /* Unsupported for now, since there are no builtin attributes to convert into. */
break; break;
default: default:
@ -665,7 +665,7 @@ static void copy_profile_point_data_to_mesh_faces(const Span<T> src,
static void copy_profile_point_domain_attribute_to_mesh(const CurvesInfo &curves_info, static void copy_profile_point_domain_attribute_to_mesh(const CurvesInfo &curves_info,
const ResultOffsets &offsets, const ResultOffsets &offsets,
const eAttrDomain dst_domain, const AttrDomain dst_domain,
const GSpan src_all, const GSpan src_all,
GMutableSpan dst_all) GMutableSpan dst_all)
{ {
@ -674,19 +674,19 @@ static void copy_profile_point_domain_attribute_to_mesh(const CurvesInfo &curves
const Span<T> src = src_all.typed<T>(); const Span<T> src = src_all.typed<T>();
MutableSpan<T> dst = dst_all.typed<T>(); MutableSpan<T> dst = dst_all.typed<T>();
switch (dst_domain) { switch (dst_domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
copy_profile_point_data_to_mesh_verts( copy_profile_point_data_to_mesh_verts(
src.slice(info.profile_points), info.main_points.size(), dst.slice(info.vert_range)); src.slice(info.profile_points), info.main_points.size(), dst.slice(info.vert_range));
}); });
break; break;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
copy_profile_point_data_to_mesh_edges( copy_profile_point_data_to_mesh_edges(
src.slice(info.profile_points), info.main_segment_num, dst.slice(info.edge_range)); src.slice(info.profile_points), info.main_segment_num, dst.slice(info.edge_range));
}); });
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
copy_profile_point_data_to_mesh_faces(src.slice(info.profile_points), copy_profile_point_data_to_mesh_faces(src.slice(info.profile_points),
info.main_segment_num, info.main_segment_num,
@ -694,7 +694,7 @@ static void copy_profile_point_domain_attribute_to_mesh(const CurvesInfo &curves
dst.slice(info.face_range)); dst.slice(info.face_range));
}); });
break; break;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
/* Unsupported for now, since there are no builtin attributes to convert into. */ /* Unsupported for now, since there are no builtin attributes to convert into. */
break; break;
default: default:
@ -724,22 +724,22 @@ static void copy_indices_to_offset_ranges(const VArray<T> &src,
static void copy_curve_domain_attribute_to_mesh(const ResultOffsets &mesh_offsets, static void copy_curve_domain_attribute_to_mesh(const ResultOffsets &mesh_offsets,
const Span<int> curve_indices, const Span<int> curve_indices,
const eAttrDomain dst_domain, const AttrDomain dst_domain,
const GVArray &src, const GVArray &src,
GMutableSpan dst) GMutableSpan dst)
{ {
Span<int> offsets; Span<int> offsets;
switch (dst_domain) { switch (dst_domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
offsets = mesh_offsets.vert; offsets = mesh_offsets.vert;
break; break;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
offsets = mesh_offsets.edge; offsets = mesh_offsets.edge;
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
offsets = mesh_offsets.face; offsets = mesh_offsets.face;
break; break;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
offsets = mesh_offsets.loop; offsets = mesh_offsets.loop;
break; break;
default: default:
@ -769,7 +769,7 @@ static void write_sharp_bezier_edges(const CurvesInfo &curves_info,
return; return;
} }
sharp_edges = mesh_attributes.lookup_or_add_for_write_span<bool>("sharp_edge", ATTR_DOMAIN_EDGE); sharp_edges = mesh_attributes.lookup_or_add_for_write_span<bool>("sharp_edge", AttrDomain::Edge);
const OffsetIndices profile_points_by_curve = profile.points_by_curve(); const OffsetIndices profile_points_by_curve = profile.points_by_curve();
const VArray<int8_t> types = profile.curve_types(); const VArray<int8_t> types = profile.curve_types();
@ -830,7 +830,7 @@ Mesh *curve_to_mesh_sweep(const CurvesGeometry &main,
/* TODO: This is used to keep the tests passing after refactoring mesh shade smooth flags. It /* TODO: This is used to keep the tests passing after refactoring mesh shade smooth flags. It
* can be removed if the tests are updated and the final shading results will be the same. */ * can be removed if the tests are updated and the final shading results will be the same. */
SpanAttributeWriter<bool> sharp_faces = mesh_attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> sharp_faces = mesh_attributes.lookup_or_add_for_write_span<bool>(
"sharp_face", ATTR_DOMAIN_FACE); "sharp_face", AttrDomain::Face);
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
const bool has_caps = fill_caps && !info.main_cyclic && info.profile_cyclic; const bool has_caps = fill_caps && !info.main_cyclic && info.profile_cyclic;
if (has_caps) { if (has_caps) {
@ -862,7 +862,7 @@ Mesh *curve_to_mesh_sweep(const CurvesGeometry &main,
if (fill_caps) { if (fill_caps) {
if (!sharp_edges) { if (!sharp_edges) {
sharp_edges = mesh_attributes.lookup_or_add_for_write_span<bool>("sharp_edge", sharp_edges = mesh_attributes.lookup_or_add_for_write_span<bool>("sharp_edge",
ATTR_DOMAIN_EDGE); AttrDomain::Edge);
} }
foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
if (info.main_cyclic || !info.profile_cyclic) { if (info.main_cyclic || !info.profile_cyclic) {
@ -889,16 +889,16 @@ Mesh *curve_to_mesh_sweep(const CurvesGeometry &main,
return true; return true;
} }
const eAttrDomain src_domain = meta_data.domain; const AttrDomain src_domain = meta_data.domain;
const eCustomDataType type = meta_data.data_type; const eCustomDataType type = meta_data.data_type;
const GAttributeReader src = main_attributes.lookup(id, src_domain, type); const GAttributeReader src = main_attributes.lookup(id, src_domain, type);
const eAttrDomain dst_domain = get_attribute_domain_for_mesh(mesh_attributes, id); const AttrDomain dst_domain = get_attribute_domain_for_mesh(mesh_attributes, id);
if (src_domain == ATTR_DOMAIN_POINT) { if (src_domain == AttrDomain::Point) {
copy_main_point_domain_attribute_to_mesh( copy_main_point_domain_attribute_to_mesh(
curves_info, id, offsets, dst_domain, src, eval_buffer, mesh_attributes); curves_info, id, offsets, dst_domain, src, eval_buffer, mesh_attributes);
} }
else if (src_domain == ATTR_DOMAIN_CURVE) { else if (src_domain == AttrDomain::Curve) {
GSpanAttributeWriter dst = mesh_attributes.lookup_or_add_for_write_only_span( GSpanAttributeWriter dst = mesh_attributes.lookup_or_add_for_write_only_span(
id, dst_domain, type); id, dst_domain, type);
if (dst) { if (dst) {
@ -921,25 +921,25 @@ Mesh *curve_to_mesh_sweep(const CurvesGeometry &main,
{ {
return true; return true;
} }
const eAttrDomain src_domain = meta_data.domain; const AttrDomain src_domain = meta_data.domain;
const eCustomDataType type = meta_data.data_type; const eCustomDataType type = meta_data.data_type;
const GVArray src = *profile_attributes.lookup(id, src_domain, type); const GVArray src = *profile_attributes.lookup(id, src_domain, type);
const eAttrDomain dst_domain = get_attribute_domain_for_mesh(mesh_attributes, id); const AttrDomain dst_domain = get_attribute_domain_for_mesh(mesh_attributes, id);
GSpanAttributeWriter dst = mesh_attributes.lookup_or_add_for_write_only_span( GSpanAttributeWriter dst = mesh_attributes.lookup_or_add_for_write_only_span(
id, dst_domain, type); id, dst_domain, type);
if (!dst) { if (!dst) {
return true; return true;
} }
if (src_domain == ATTR_DOMAIN_POINT) { if (src_domain == AttrDomain::Point) {
copy_profile_point_domain_attribute_to_mesh(curves_info, copy_profile_point_domain_attribute_to_mesh(curves_info,
offsets, offsets,
dst_domain, dst_domain,
evaluate_attribute(src, profile, eval_buffer), evaluate_attribute(src, profile, eval_buffer),
dst.span); dst.span);
} }
else if (src_domain == ATTR_DOMAIN_CURVE) { else if (src_domain == AttrDomain::Curve) {
copy_curve_domain_attribute_to_mesh( copy_curve_domain_attribute_to_mesh(
offsets, offsets.profile_indices, dst_domain, src, dst.span); offsets, offsets.profile_indices, dst_domain, src, dst.span);
} }

2
source/blender/blenkernel/intern/curves.cc
View File

@ -347,7 +347,7 @@ bool CurvesEditHints::is_valid() const
void curves_normals_point_domain_calc(const CurvesGeometry &curves, MutableSpan<float3> normals) void curves_normals_point_domain_calc(const CurvesGeometry &curves, MutableSpan<float3> normals)
{ {
const bke::CurvesFieldContext context(curves, ATTR_DOMAIN_POINT); const bke::CurvesFieldContext context(curves, AttrDomain::Point);
fn::FieldEvaluator evaluator(context, curves.points_num()); fn::FieldEvaluator evaluator(context, curves.points_num());
fn::Field<float3> field(std::make_shared<bke::NormalFieldInput>()); fn::Field<float3> field(std::make_shared<bke::NormalFieldInput>());
evaluator.add_with_destination(std::move(field), normals); evaluator.add_with_destination(std::move(field), normals);

94
source/blender/blenkernel/intern/curves_geometry.cc
View File

@ -63,7 +63,7 @@ CurvesGeometry::CurvesGeometry(const int point_num, const int curve_num)
BLI_listbase_clear(&this->vertex_group_names); BLI_listbase_clear(&this->vertex_group_names);
this->attributes_for_write().add<float3>( this->attributes_for_write().add<float3>(
"position", ATTR_DOMAIN_POINT, AttributeInitConstruct()); "position", AttrDomain::Point, AttributeInitConstruct());
this->runtime = MEM_new<CurvesGeometryRuntime>(__func__); this->runtime = MEM_new<CurvesGeometryRuntime>(__func__);
@ -185,24 +185,24 @@ CurvesGeometry::~CurvesGeometry()
/** \name Accessors /** \name Accessors
* \{ */ * \{ */
static int domain_num(const CurvesGeometry &curves, const eAttrDomain domain) static int domain_num(const CurvesGeometry &curves, const AttrDomain domain)
{ {
return domain == ATTR_DOMAIN_POINT ? curves.points_num() : curves.curves_num(); return domain == AttrDomain::Point ? curves.points_num() : curves.curves_num();
} }
static CustomData &domain_custom_data(CurvesGeometry &curves, const eAttrDomain domain) static CustomData &domain_custom_data(CurvesGeometry &curves, const AttrDomain domain)
{ {
return domain == ATTR_DOMAIN_POINT ? curves.point_data : curves.curve_data; return domain == AttrDomain::Point ? curves.point_data : curves.curve_data;
} }
static const CustomData &domain_custom_data(const CurvesGeometry &curves, const eAttrDomain domain) static const CustomData &domain_custom_data(const CurvesGeometry &curves, const AttrDomain domain)
{ {
return domain == ATTR_DOMAIN_POINT ? curves.point_data : curves.curve_data; return domain == AttrDomain::Point ? curves.point_data : curves.curve_data;
} }
template<typename T> template<typename T>
static VArray<T> get_varray_attribute(const CurvesGeometry &curves, static VArray<T> get_varray_attribute(const CurvesGeometry &curves,
const eAttrDomain domain, const AttrDomain domain,
const StringRefNull name, const StringRefNull name,
const T default_value) const T default_value)
{ {
@ -219,7 +219,7 @@ static VArray<T> get_varray_attribute(const CurvesGeometry &curves,
template<typename T> template<typename T>
static Span<T> get_span_attribute(const CurvesGeometry &curves, static Span<T> get_span_attribute(const CurvesGeometry &curves,
const eAttrDomain domain, const AttrDomain domain,
const StringRefNull name) const StringRefNull name)
{ {
const int num = domain_num(curves, domain); const int num = domain_num(curves, domain);
@ -235,7 +235,7 @@ static Span<T> get_span_attribute(const CurvesGeometry &curves,
template<typename T> template<typename T>
static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves, static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves,
const eAttrDomain domain, const AttrDomain domain,
const StringRefNull name, const StringRefNull name,
const T default_value = T()) const T default_value = T())
{ {
@ -258,12 +258,12 @@ static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves,
VArray<int8_t> CurvesGeometry::curve_types() const VArray<int8_t> CurvesGeometry::curve_types() const
{ {
return get_varray_attribute<int8_t>( return get_varray_attribute<int8_t>(
*this, ATTR_DOMAIN_CURVE, ATTR_CURVE_TYPE, CURVE_TYPE_CATMULL_ROM); *this, AttrDomain::Curve, ATTR_CURVE_TYPE, CURVE_TYPE_CATMULL_ROM);
} }
MutableSpan<int8_t> CurvesGeometry::curve_types_for_write() MutableSpan<int8_t> CurvesGeometry::curve_types_for_write()
{ {
return get_mutable_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_CURVE_TYPE); return get_mutable_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_CURVE_TYPE);
} }
void CurvesGeometry::fill_curve_types(const CurveType type) void CurvesGeometry::fill_curve_types(const CurveType type)
@ -338,11 +338,11 @@ void CurvesGeometry::update_curve_types()
Span<float3> CurvesGeometry::positions() const Span<float3> CurvesGeometry::positions() const
{ {
return get_span_attribute<float3>(*this, ATTR_DOMAIN_POINT, ATTR_POSITION); return get_span_attribute<float3>(*this, AttrDomain::Point, ATTR_POSITION);
} }
MutableSpan<float3> CurvesGeometry::positions_for_write() MutableSpan<float3> CurvesGeometry::positions_for_write()
{ {
return get_mutable_attribute<float3>(*this, ATTR_DOMAIN_POINT, ATTR_POSITION); return get_mutable_attribute<float3>(*this, AttrDomain::Point, ATTR_POSITION);
} }
Span<int> CurvesGeometry::offsets() const Span<int> CurvesGeometry::offsets() const
@ -361,111 +361,111 @@ MutableSpan<int> CurvesGeometry::offsets_for_write()
VArray<bool> CurvesGeometry::cyclic() const VArray<bool> CurvesGeometry::cyclic() const
{ {
return get_varray_attribute<bool>(*this, ATTR_DOMAIN_CURVE, ATTR_CYCLIC, false); return get_varray_attribute<bool>(*this, AttrDomain::Curve, ATTR_CYCLIC, false);
} }
MutableSpan<bool> CurvesGeometry::cyclic_for_write() MutableSpan<bool> CurvesGeometry::cyclic_for_write()
{ {
return get_mutable_attribute<bool>(*this, ATTR_DOMAIN_CURVE, ATTR_CYCLIC, false); return get_mutable_attribute<bool>(*this, AttrDomain::Curve, ATTR_CYCLIC, false);
} }
VArray<int> CurvesGeometry::resolution() const VArray<int> CurvesGeometry::resolution() const
{ {
return get_varray_attribute<int>(*this, ATTR_DOMAIN_CURVE, ATTR_RESOLUTION, 12); return get_varray_attribute<int>(*this, AttrDomain::Curve, ATTR_RESOLUTION, 12);
} }
MutableSpan<int> CurvesGeometry::resolution_for_write() MutableSpan<int> CurvesGeometry::resolution_for_write()
{ {
return get_mutable_attribute<int>(*this, ATTR_DOMAIN_CURVE, ATTR_RESOLUTION, 12); return get_mutable_attribute<int>(*this, AttrDomain::Curve, ATTR_RESOLUTION, 12);
} }
VArray<int8_t> CurvesGeometry::normal_mode() const VArray<int8_t> CurvesGeometry::normal_mode() const
{ {
return get_varray_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_NORMAL_MODE, 0); return get_varray_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_NORMAL_MODE, 0);
} }
MutableSpan<int8_t> CurvesGeometry::normal_mode_for_write() MutableSpan<int8_t> CurvesGeometry::normal_mode_for_write()
{ {
return get_mutable_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_NORMAL_MODE); return get_mutable_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_NORMAL_MODE);
} }
VArray<float> CurvesGeometry::tilt() const VArray<float> CurvesGeometry::tilt() const
{ {
return get_varray_attribute<float>(*this, ATTR_DOMAIN_POINT, ATTR_TILT, 0.0f); return get_varray_attribute<float>(*this, AttrDomain::Point, ATTR_TILT, 0.0f);
} }
MutableSpan<float> CurvesGeometry::tilt_for_write() MutableSpan<float> CurvesGeometry::tilt_for_write()
{ {
return get_mutable_attribute<float>(*this, ATTR_DOMAIN_POINT, ATTR_TILT); return get_mutable_attribute<float>(*this, AttrDomain::Point, ATTR_TILT);
} }
VArray<int8_t> CurvesGeometry::handle_types_left() const VArray<int8_t> CurvesGeometry::handle_types_left() const
{ {
return get_varray_attribute<int8_t>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_TYPE_LEFT, 0); return get_varray_attribute<int8_t>(*this, AttrDomain::Point, ATTR_HANDLE_TYPE_LEFT, 0);
} }
MutableSpan<int8_t> CurvesGeometry::handle_types_left_for_write() MutableSpan<int8_t> CurvesGeometry::handle_types_left_for_write()
{ {
return get_mutable_attribute<int8_t>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_TYPE_LEFT, 0); return get_mutable_attribute<int8_t>(*this, AttrDomain::Point, ATTR_HANDLE_TYPE_LEFT, 0);
} }
VArray<int8_t> CurvesGeometry::handle_types_right() const VArray<int8_t> CurvesGeometry::handle_types_right() const
{ {
return get_varray_attribute<int8_t>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_TYPE_RIGHT, 0); return get_varray_attribute<int8_t>(*this, AttrDomain::Point, ATTR_HANDLE_TYPE_RIGHT, 0);
} }
MutableSpan<int8_t> CurvesGeometry::handle_types_right_for_write() MutableSpan<int8_t> CurvesGeometry::handle_types_right_for_write()
{ {
return get_mutable_attribute<int8_t>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_TYPE_RIGHT, 0); return get_mutable_attribute<int8_t>(*this, AttrDomain::Point, ATTR_HANDLE_TYPE_RIGHT, 0);
} }
Span<float3> CurvesGeometry::handle_positions_left() const Span<float3> CurvesGeometry::handle_positions_left() const
{ {
return get_span_attribute<float3>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_POSITION_LEFT); return get_span_attribute<float3>(*this, AttrDomain::Point, ATTR_HANDLE_POSITION_LEFT);
} }
MutableSpan<float3> CurvesGeometry::handle_positions_left_for_write() MutableSpan<float3> CurvesGeometry::handle_positions_left_for_write()
{ {
return get_mutable_attribute<float3>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_POSITION_LEFT); return get_mutable_attribute<float3>(*this, AttrDomain::Point, ATTR_HANDLE_POSITION_LEFT);
} }
Span<float3> CurvesGeometry::handle_positions_right() const Span<float3> CurvesGeometry::handle_positions_right() const
{ {
return get_span_attribute<float3>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_POSITION_RIGHT); return get_span_attribute<float3>(*this, AttrDomain::Point, ATTR_HANDLE_POSITION_RIGHT);
} }
MutableSpan<float3> CurvesGeometry::handle_positions_right_for_write() MutableSpan<float3> CurvesGeometry::handle_positions_right_for_write()
{ {
return get_mutable_attribute<float3>(*this, ATTR_DOMAIN_POINT, ATTR_HANDLE_POSITION_RIGHT); return get_mutable_attribute<float3>(*this, AttrDomain::Point, ATTR_HANDLE_POSITION_RIGHT);
} }
VArray<int8_t> CurvesGeometry::nurbs_orders() const VArray<int8_t> CurvesGeometry::nurbs_orders() const
{ {
return get_varray_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_NURBS_ORDER, 4); return get_varray_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_NURBS_ORDER, 4);
} }
MutableSpan<int8_t> CurvesGeometry::nurbs_orders_for_write() MutableSpan<int8_t> CurvesGeometry::nurbs_orders_for_write()
{ {
return get_mutable_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_NURBS_ORDER, 4); return get_mutable_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_NURBS_ORDER, 4);
} }
Span<float> CurvesGeometry::nurbs_weights() const Span<float> CurvesGeometry::nurbs_weights() const
{ {
return get_span_attribute<float>(*this, ATTR_DOMAIN_POINT, ATTR_NURBS_WEIGHT); return get_span_attribute<float>(*this, AttrDomain::Point, ATTR_NURBS_WEIGHT);
} }
MutableSpan<float> CurvesGeometry::nurbs_weights_for_write() MutableSpan<float> CurvesGeometry::nurbs_weights_for_write()
{ {
return get_mutable_attribute<float>(*this, ATTR_DOMAIN_POINT, ATTR_NURBS_WEIGHT); return get_mutable_attribute<float>(*this, AttrDomain::Point, ATTR_NURBS_WEIGHT);
} }
VArray<int8_t> CurvesGeometry::nurbs_knots_modes() const VArray<int8_t> CurvesGeometry::nurbs_knots_modes() const
{ {
return get_varray_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_NURBS_KNOTS_MODE, 0); return get_varray_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_NURBS_KNOTS_MODE, 0);
} }
MutableSpan<int8_t> CurvesGeometry::nurbs_knots_modes_for_write() MutableSpan<int8_t> CurvesGeometry::nurbs_knots_modes_for_write()
{ {
return get_mutable_attribute<int8_t>(*this, ATTR_DOMAIN_CURVE, ATTR_NURBS_KNOTS_MODE, 0); return get_mutable_attribute<int8_t>(*this, AttrDomain::Curve, ATTR_NURBS_KNOTS_MODE, 0);
} }
Span<float2> CurvesGeometry::surface_uv_coords() const Span<float2> CurvesGeometry::surface_uv_coords() const
{ {
return get_span_attribute<float2>(*this, ATTR_DOMAIN_CURVE, ATTR_SURFACE_UV_COORDINATE); return get_span_attribute<float2>(*this, AttrDomain::Curve, ATTR_SURFACE_UV_COORDINATE);
} }
MutableSpan<float2> CurvesGeometry::surface_uv_coords_for_write() MutableSpan<float2> CurvesGeometry::surface_uv_coords_for_write()
{ {
return get_mutable_attribute<float2>(*this, ATTR_DOMAIN_CURVE, ATTR_SURFACE_UV_COORDINATE); return get_mutable_attribute<float2>(*this, AttrDomain::Curve, ATTR_SURFACE_UV_COORDINATE);
} }
Span<MDeformVert> CurvesGeometry::deform_verts() const Span<MDeformVert> CurvesGeometry::deform_verts() const
@ -1166,13 +1166,13 @@ CurvesGeometry curves_copy_point_selection(
}, },
[&]() { [&]() {
gather_attributes(curves.attributes(), gather_attributes(curves.attributes(),
ATTR_DOMAIN_POINT, AttrDomain::Point,
propagation_info, propagation_info,
{}, {},
points_to_copy, points_to_copy,
dst_curves.attributes_for_write()); dst_curves.attributes_for_write());
gather_attributes(curves.attributes(), gather_attributes(curves.attributes(),
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
propagation_info, propagation_info,
{}, {},
curves_to_copy, curves_to_copy,
@ -1219,7 +1219,7 @@ CurvesGeometry curves_copy_curve_selection(
MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write(); MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
gather_attributes_group_to_group(src_attributes, gather_attributes_group_to_group(src_attributes,
ATTR_DOMAIN_POINT, AttrDomain::Point,
propagation_info, propagation_info,
{}, {},
points_by_curve, points_by_curve,
@ -1228,7 +1228,7 @@ CurvesGeometry curves_copy_curve_selection(
dst_attributes); dst_attributes);
gather_attributes( gather_attributes(
src_attributes, ATTR_DOMAIN_CURVE, propagation_info, {}, curves_to_copy, dst_attributes); src_attributes, AttrDomain::Curve, propagation_info, {}, curves_to_copy, dst_attributes);
dst_curves.update_curve_types(); dst_curves.update_curve_types();
dst_curves.remove_attributes_based_on_types(); dst_curves.remove_attributes_based_on_types();
@ -1294,7 +1294,7 @@ void CurvesGeometry::reverse_curves(const IndexMask &curves_to_reverse)
MutableAttributeAccessor attributes = this->attributes_for_write(); MutableAttributeAccessor attributes = this->attributes_for_write();
attributes.for_all([&](const AttributeIDRef &id, AttributeMetaData meta_data) { attributes.for_all([&](const AttributeIDRef &id, AttributeMetaData meta_data) {
if (meta_data.domain != ATTR_DOMAIN_POINT) { if (meta_data.domain != AttrDomain::Point) {
return true; return true;
} }
if (meta_data.data_type == CD_PROP_STRING) { if (meta_data.data_type == CD_PROP_STRING) {
@ -1457,8 +1457,8 @@ static GVArray adapt_curve_domain_curve_to_point(const CurvesGeometry &curves,
} }
GVArray CurvesGeometry::adapt_domain(const GVArray &varray, GVArray CurvesGeometry::adapt_domain(const GVArray &varray,
const eAttrDomain from, const AttrDomain from,
const eAttrDomain to) const const AttrDomain to) const
{ {
if (!varray) { if (!varray) {
return {}; return {};
@ -1475,10 +1475,10 @@ GVArray CurvesGeometry::adapt_domain(const GVArray &varray,
return GVArray::ForSingle(varray.type(), this->attributes().domain_size(to), value); return GVArray::ForSingle(varray.type(), this->attributes().domain_size(to), value);
} }
if (from == ATTR_DOMAIN_POINT && to == ATTR_DOMAIN_CURVE) { if (from == AttrDomain::Point && to == AttrDomain::Curve) {
return adapt_curve_domain_point_to_curve(*this, varray); return adapt_curve_domain_point_to_curve(*this, varray);
} }
if (from == ATTR_DOMAIN_CURVE && to == ATTR_DOMAIN_POINT) { if (from == AttrDomain::Curve && to == AttrDomain::Point) {
return adapt_curve_domain_curve_to_point(*this, varray); return adapt_curve_domain_curve_to_point(*this, varray);
} }

8
source/blender/blenkernel/intern/data_transfer.cc
View File

@ -255,7 +255,7 @@ int BKE_object_data_transfer_dttype_to_srcdst_index(const int dtdata_type)
* is set). * is set).
*/ */
static void data_transfer_mesh_attributes_transfer_active_color_string( static void data_transfer_mesh_attributes_transfer_active_color_string(
Mesh *mesh_dst, const Mesh *mesh_src, const eAttrDomainMask mask_domain, const int data_type) Mesh *mesh_dst, const Mesh *mesh_src, const AttrDomainMask mask_domain, const int data_type)
{ {
if (mesh_dst->active_color_attribute) { if (mesh_dst->active_color_attribute) {
return; return;
@ -306,7 +306,7 @@ static void data_transfer_mesh_attributes_transfer_active_color_string(
* is set). * is set).
*/ */
static void data_transfer_mesh_attributes_transfer_default_color_string( static void data_transfer_mesh_attributes_transfer_default_color_string(
Mesh *mesh_dst, const Mesh *mesh_src, const eAttrDomainMask mask_domain, const int data_type) Mesh *mesh_dst, const Mesh *mesh_src, const AttrDomainMask mask_domain, const int data_type)
{ {
if (mesh_dst->default_color_attribute) { if (mesh_dst->default_color_attribute) {
return; return;
@ -377,8 +377,8 @@ static void data_transfer_dtdata_type_postprocess(Mesh *me_dst,
bke::MutableAttributeAccessor attributes = me_dst->attributes_for_write(); bke::MutableAttributeAccessor attributes = me_dst->attributes_for_write();
bke::SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>(
"sharp_edge", ATTR_DOMAIN_EDGE); "sharp_edge", bke::AttrDomain::Edge);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
/* Note loop_nors_dst contains our custom normals as transferred from source... */ /* Note loop_nors_dst contains our custom normals as transferred from source... */
blender::bke::mesh::normals_loop_custom_set(me_dst->vert_positions(), blender::bke::mesh::normals_loop_custom_set(me_dst->vert_positions(),
me_dst->edges(), me_dst->edges(),

13
source/blender/blenkernel/intern/fluid.cc
View File

@ -3220,15 +3220,16 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
Object *ob) Object *ob)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
Mesh *mesh; Mesh *mesh;
float min[3]; float min[3];
float max[3]; float max[3];
float size[3]; float size[3];
float cell_size_scaled[3]; float cell_size_scaled[3];
const bke::AttributeAccessor orig_attributes = orgmesh->attributes(); const AttributeAccessor orig_attributes = orgmesh->attributes();
const VArraySpan orig_material_indices = *orig_attributes.lookup<int>("material_index", const VArraySpan orig_material_indices = *orig_attributes.lookup<int>("material_index",
ATTR_DOMAIN_FACE); AttrDomain::Face);
const short mp_mat_nr = orig_material_indices.is_empty() ? 0 : orig_material_indices[0]; const short mp_mat_nr = orig_material_indices.is_empty() ? 0 : orig_material_indices[0];
int i; int i;
@ -3259,9 +3260,9 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
blender::MutableSpan<int> corner_verts = mesh->corner_verts_for_write(); blender::MutableSpan<int> corner_verts = mesh->corner_verts_for_write();
const bool is_sharp = orgmesh->attributes() const bool is_sharp = orgmesh->attributes()
.lookup_or_default<bool>("sharp_face", ATTR_DOMAIN_FACE, false) .lookup_or_default<bool>("sharp_face", AttrDomain::Face, false)
.varray[0]; .varray[0];
bke::mesh_smooth_set(*mesh, !is_sharp); mesh_smooth_set(*mesh, !is_sharp);
/* Get size (dimension) but considering scaling. */ /* Get size (dimension) but considering scaling. */
copy_v3_v3(cell_size_scaled, fds->cell_size); copy_v3_v3(cell_size_scaled, fds->cell_size);
@ -3291,7 +3292,7 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
if (use_speedvectors) { if (use_speedvectors) {
CustomDataLayer *velocity_layer = BKE_id_attribute_new( CustomDataLayer *velocity_layer = BKE_id_attribute_new(
&mesh->id, "velocity", CD_PROP_FLOAT3, ATTR_DOMAIN_POINT, nullptr); &mesh->id, "velocity", CD_PROP_FLOAT3, AttrDomain::Point, nullptr);
velarray = static_cast<float(*)[3]>(velocity_layer->data); velarray = static_cast<float(*)[3]>(velocity_layer->data);
} }
@ -3346,7 +3347,7 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter material_indices = attributes.lookup_or_add_for_write_span<int>( bke::SpanAttributeWriter material_indices = attributes.lookup_or_add_for_write_span<int>(
"material_index", ATTR_DOMAIN_FACE); "material_index", AttrDomain::Face);
/* Loop for triangles. */ /* Loop for triangles. */
for (const int i : face_offsets.index_range().drop_back(1)) { for (const int i : face_offsets.index_range().drop_back(1)) {

84
source/blender/blenkernel/intern/geometry_component_curves.cc
View File

@ -211,23 +211,23 @@ static Array<float3> curve_normal_point_domain(const bke::CurvesGeometry &curves
return results; return results;
} }
VArray<float3> curve_normals_varray(const CurvesGeometry &curves, const eAttrDomain domain) VArray<float3> curve_normals_varray(const CurvesGeometry &curves, const AttrDomain domain)
{ {
const VArray<int8_t> types = curves.curve_types(); const VArray<int8_t> types = curves.curve_types();
if (curves.is_single_type(CURVE_TYPE_POLY)) { if (curves.is_single_type(CURVE_TYPE_POLY)) {
return curves.adapt_domain<float3>( return curves.adapt_domain<float3>(
VArray<float3>::ForSpan(curves.evaluated_normals()), ATTR_DOMAIN_POINT, domain); VArray<float3>::ForSpan(curves.evaluated_normals()), AttrDomain::Point, domain);
} }
Array<float3> normals = curve_normal_point_domain(curves); Array<float3> normals = curve_normal_point_domain(curves);
if (domain == ATTR_DOMAIN_POINT) { if (domain == AttrDomain::Point) {
return VArray<float3>::ForContainer(std::move(normals)); return VArray<float3>::ForContainer(std::move(normals));
} }
if (domain == ATTR_DOMAIN_CURVE) { if (domain == AttrDomain::Curve) {
return curves.adapt_domain<float3>( return curves.adapt_domain<float3>(
VArray<float3>::ForContainer(std::move(normals)), ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE); VArray<float3>::ForContainer(std::move(normals)), AttrDomain::Point, AttrDomain::Curve);
} }
return nullptr; return nullptr;
@ -240,7 +240,7 @@ VArray<float3> curve_normals_varray(const CurvesGeometry &curves, const eAttrDom
* \{ */ * \{ */
static VArray<float> construct_curve_length_gvarray(const CurvesGeometry &curves, static VArray<float> construct_curve_length_gvarray(const CurvesGeometry &curves,
const eAttrDomain domain) const AttrDomain domain)
{ {
curves.ensure_evaluated_lengths(); curves.ensure_evaluated_lengths();
@ -250,12 +250,12 @@ static VArray<float> construct_curve_length_gvarray(const CurvesGeometry &curves
return curves.evaluated_length_total_for_curve(index, cyclic[index]); return curves.evaluated_length_total_for_curve(index, cyclic[index]);
}); });
if (domain == ATTR_DOMAIN_CURVE) { if (domain == AttrDomain::Curve) {
return lengths; return lengths;
} }
if (domain == ATTR_DOMAIN_POINT) { if (domain == AttrDomain::Point) {
return curves.adapt_domain<float>(std::move(lengths), ATTR_DOMAIN_CURVE, ATTR_DOMAIN_POINT); return curves.adapt_domain<float>(std::move(lengths), AttrDomain::Curve, AttrDomain::Point);
} }
return {}; return {};
@ -268,7 +268,7 @@ CurveLengthFieldInput::CurveLengthFieldInput()
} }
GVArray CurveLengthFieldInput::get_varray_for_context(const CurvesGeometry &curves, GVArray CurveLengthFieldInput::get_varray_for_context(const CurvesGeometry &curves,
const eAttrDomain domain, const AttrDomain domain,
const IndexMask & /*mask*/) const const IndexMask & /*mask*/) const
{ {
return construct_curve_length_gvarray(curves, domain); return construct_curve_length_gvarray(curves, domain);
@ -285,10 +285,10 @@ bool CurveLengthFieldInput::is_equal_to(const fn::FieldNode &other) const
return dynamic_cast<const CurveLengthFieldInput *>(&other) != nullptr; return dynamic_cast<const CurveLengthFieldInput *>(&other) != nullptr;
} }
std::optional<eAttrDomain> CurveLengthFieldInput::preferred_domain( std::optional<AttrDomain> CurveLengthFieldInput::preferred_domain(
const bke::CurvesGeometry & /*curves*/) const const bke::CurvesGeometry & /*curves*/) const
{ {
return ATTR_DOMAIN_CURVE; return AttrDomain::Curve;
} }
/** \} */ /** \} */
@ -358,9 +358,9 @@ class CurvesVertexGroupsAttributeProvider final : public DynamicAttributesProvid
const Span<MDeformVert> dverts = curves->deform_verts(); const Span<MDeformVert> dverts = curves->deform_verts();
if (dverts.is_empty()) { if (dverts.is_empty()) {
static const float default_value = 0.0f; static const float default_value = 0.0f;
return {VArray<float>::ForSingle(default_value, curves->points_num()), ATTR_DOMAIN_POINT}; return {VArray<float>::ForSingle(default_value, curves->points_num()), AttrDomain::Point};
} }
return {bke::varray_for_deform_verts(dverts, vertex_group_index), ATTR_DOMAIN_POINT}; return {bke::varray_for_deform_verts(dverts, vertex_group_index), AttrDomain::Point};
} }
GAttributeWriter try_get_for_write(void *owner, const AttributeIDRef &attribute_id) const final GAttributeWriter try_get_for_write(void *owner, const AttributeIDRef &attribute_id) const final
@ -379,7 +379,7 @@ class CurvesVertexGroupsAttributeProvider final : public DynamicAttributesProvid
return {}; return {};
} }
MutableSpan<MDeformVert> dverts = curves->deform_verts_for_write(); MutableSpan<MDeformVert> dverts = curves->deform_verts_for_write();
return {bke::varray_for_mutable_deform_verts(dverts, vertex_group_index), ATTR_DOMAIN_POINT}; return {bke::varray_for_mutable_deform_verts(dverts, vertex_group_index), AttrDomain::Point};
} }
bool try_delete(void *owner, const AttributeIDRef &attribute_id) const final bool try_delete(void *owner, const AttributeIDRef &attribute_id) const final
@ -417,16 +417,16 @@ class CurvesVertexGroupsAttributeProvider final : public DynamicAttributesProvid
return true; return true;
} }
LISTBASE_FOREACH (const bDeformGroup *, group, &curves->vertex_group_names) { LISTBASE_FOREACH (const bDeformGroup *, group, &curves->vertex_group_names) {
if (!callback(group->name, {ATTR_DOMAIN_POINT, CD_PROP_FLOAT})) { if (!callback(group->name, {AttrDomain::Point, CD_PROP_FLOAT})) {
return false; return false;
} }
} }
return true; return true;
} }
void foreach_domain(const FunctionRef<void(eAttrDomain)> callback) const final void foreach_domain(const FunctionRef<void(AttrDomain)> callback) const final
{ {
callback(ATTR_DOMAIN_POINT); callback(AttrDomain::Point);
} }
}; };
@ -464,7 +464,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
}}; }};
static BuiltinCustomDataLayerProvider position("position", static BuiltinCustomDataLayerProvider position("position",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -473,7 +473,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
tag_component_positions_changed); tag_component_positions_changed);
static BuiltinCustomDataLayerProvider radius("radius", static BuiltinCustomDataLayerProvider radius("radius",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT, CD_PROP_FLOAT,
CD_PROP_FLOAT, CD_PROP_FLOAT,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -482,7 +482,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
tag_component_radii_changed); tag_component_radii_changed);
static BuiltinCustomDataLayerProvider id("id", static BuiltinCustomDataLayerProvider id("id",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -491,7 +491,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
nullptr); nullptr);
static BuiltinCustomDataLayerProvider tilt("tilt", static BuiltinCustomDataLayerProvider tilt("tilt",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT, CD_PROP_FLOAT,
CD_PROP_FLOAT, CD_PROP_FLOAT,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -500,7 +500,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
tag_component_normals_changed); tag_component_normals_changed);
static BuiltinCustomDataLayerProvider handle_right("handle_right", static BuiltinCustomDataLayerProvider handle_right("handle_right",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -509,7 +509,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
tag_component_positions_changed); tag_component_positions_changed);
static BuiltinCustomDataLayerProvider handle_left("handle_left", static BuiltinCustomDataLayerProvider handle_left("handle_left",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -524,7 +524,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
}, },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider handle_type_right("handle_type_right", static BuiltinCustomDataLayerProvider handle_type_right("handle_type_right",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_INT8, CD_PROP_INT8,
CD_PROP_INT8, CD_PROP_INT8,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -534,7 +534,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
AttributeValidator{&handle_type_clamp}); AttributeValidator{&handle_type_clamp});
static BuiltinCustomDataLayerProvider handle_type_left("handle_type_left", static BuiltinCustomDataLayerProvider handle_type_left("handle_type_left",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_INT8, CD_PROP_INT8,
CD_PROP_INT8, CD_PROP_INT8,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -544,7 +544,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
AttributeValidator{&handle_type_clamp}); AttributeValidator{&handle_type_clamp});
static BuiltinCustomDataLayerProvider nurbs_weight("nurbs_weight", static BuiltinCustomDataLayerProvider nurbs_weight("nurbs_weight",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT, CD_PROP_FLOAT,
CD_PROP_FLOAT, CD_PROP_FLOAT,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -557,7 +557,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
[](int8_t value) { return std::max<int8_t>(value, 0); }, [](int8_t value) { return std::max<int8_t>(value, 0); },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider nurbs_order("nurbs_order", static BuiltinCustomDataLayerProvider nurbs_order("nurbs_order",
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
CD_PROP_INT8, CD_PROP_INT8,
CD_PROP_INT8, CD_PROP_INT8,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -573,7 +573,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
}, },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider normal_mode("normal_mode", static BuiltinCustomDataLayerProvider normal_mode("normal_mode",
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
CD_PROP_INT8, CD_PROP_INT8,
CD_PROP_INT8, CD_PROP_INT8,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -589,7 +589,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
}, },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider nurbs_knots_mode("knots_mode", static BuiltinCustomDataLayerProvider nurbs_knots_mode("knots_mode",
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
CD_PROP_INT8, CD_PROP_INT8,
CD_PROP_INT8, CD_PROP_INT8,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -605,7 +605,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
}, },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider curve_type("curve_type", static BuiltinCustomDataLayerProvider curve_type("curve_type",
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
CD_PROP_INT8, CD_PROP_INT8,
CD_PROP_INT8, CD_PROP_INT8,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -619,7 +619,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
[](int value) { return std::max<int>(value, 1); }, [](int value) { return std::max<int>(value, 1); },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider resolution("resolution", static BuiltinCustomDataLayerProvider resolution("resolution",
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -629,7 +629,7 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
AttributeValidator{&resolution_clamp}); AttributeValidator{&resolution_clamp});
static BuiltinCustomDataLayerProvider cyclic("cyclic", static BuiltinCustomDataLayerProvider cyclic("cyclic",
ATTR_DOMAIN_CURVE, AttrDomain::Curve,
CD_PROP_BOOL, CD_PROP_BOOL,
CD_PROP_BOOL, CD_PROP_BOOL,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -638,8 +638,8 @@ static ComponentAttributeProviders create_attribute_providers_for_curve()
tag_component_topology_changed); tag_component_topology_changed);
static CurvesVertexGroupsAttributeProvider vertex_groups; static CurvesVertexGroupsAttributeProvider vertex_groups;
static CustomDataAttributeProvider curve_custom_data(ATTR_DOMAIN_CURVE, curve_access); static CustomDataAttributeProvider curve_custom_data(AttrDomain::Curve, curve_access);
static CustomDataAttributeProvider point_custom_data(ATTR_DOMAIN_POINT, point_access); static CustomDataAttributeProvider point_custom_data(AttrDomain::Point, point_access);
return ComponentAttributeProviders({&position, return ComponentAttributeProviders({&position,
&radius, &radius,
@ -666,27 +666,27 @@ static AttributeAccessorFunctions get_curves_accessor_functions()
static const ComponentAttributeProviders providers = create_attribute_providers_for_curve(); static const ComponentAttributeProviders providers = create_attribute_providers_for_curve();
AttributeAccessorFunctions fn = AttributeAccessorFunctions fn =
attribute_accessor_functions::accessor_functions_for_providers<providers>(); attribute_accessor_functions::accessor_functions_for_providers<providers>();
fn.domain_size = [](const void *owner, const eAttrDomain domain) { fn.domain_size = [](const void *owner, const AttrDomain domain) {
if (owner == nullptr) { if (owner == nullptr) {
return 0; return 0;
} }
const CurvesGeometry &curves = *static_cast<const CurvesGeometry *>(owner); const CurvesGeometry &curves = *static_cast<const CurvesGeometry *>(owner);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return curves.points_num(); return curves.points_num();
case ATTR_DOMAIN_CURVE: case AttrDomain::Curve:
return curves.curves_num(); return curves.curves_num();
default: default:
return 0; return 0;
} }
}; };
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) { fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
return ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE); return ELEM(domain, AttrDomain::Point, AttrDomain::Curve);
}; };
fn.adapt_domain = [](const void *owner, fn.adapt_domain = [](const void *owner,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) -> GVArray { const AttrDomain to_domain) -> GVArray {
if (owner == nullptr) { if (owner == nullptr) {
return {}; return {};
} }

18
source/blender/blenkernel/intern/geometry_component_grease_pencil.cc
View File

@ -117,15 +117,15 @@ static ComponentAttributeProviders create_attribute_providers_for_grease_pencil(
return grease_pencil.layers().size(); return grease_pencil.layers().size();
}}; }};
static CustomDataAttributeProvider layer_custom_data(ATTR_DOMAIN_LAYER, layers_access); static CustomDataAttributeProvider layer_custom_data(AttrDomain::Layer, layers_access);
return ComponentAttributeProviders({}, {&layer_custom_data}); return ComponentAttributeProviders({}, {&layer_custom_data});
} }
static GVArray adapt_grease_pencil_attribute_domain(const GreasePencil & /*grease_pencil*/, static GVArray adapt_grease_pencil_attribute_domain(const GreasePencil & /*grease_pencil*/,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from, const AttrDomain from,
const eAttrDomain to) const AttrDomain to)
{ {
if (from == to) { if (from == to) {
return varray; return varray;
@ -139,25 +139,25 @@ static AttributeAccessorFunctions get_grease_pencil_accessor_functions()
create_attribute_providers_for_grease_pencil(); create_attribute_providers_for_grease_pencil();
AttributeAccessorFunctions fn = AttributeAccessorFunctions fn =
attribute_accessor_functions::accessor_functions_for_providers<providers>(); attribute_accessor_functions::accessor_functions_for_providers<providers>();
fn.domain_size = [](const void *owner, const eAttrDomain domain) { fn.domain_size = [](const void *owner, const AttrDomain domain) {
if (owner == nullptr) { if (owner == nullptr) {
return 0; return 0;
} }
const GreasePencil &grease_pencil = *static_cast<const GreasePencil *>(owner); const GreasePencil &grease_pencil = *static_cast<const GreasePencil *>(owner);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_LAYER: case AttrDomain::Layer:
return int(grease_pencil.layers().size()); return int(grease_pencil.layers().size());
default: default:
return 0; return 0;
} }
}; };
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) { fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
return domain == ATTR_DOMAIN_LAYER; return domain == AttrDomain::Layer;
}; };
fn.adapt_domain = [](const void *owner, fn.adapt_domain = [](const void *owner,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) -> GVArray { const AttrDomain to_domain) -> GVArray {
if (owner == nullptr) { if (owner == nullptr) {
return {}; return {};
} }

20
source/blender/blenkernel/intern/geometry_component_instances.cc
View File

@ -118,7 +118,7 @@ class InstancePositionAttributeProvider final : public BuiltinAttributeProvider
public: public:
InstancePositionAttributeProvider() InstancePositionAttributeProvider()
: BuiltinAttributeProvider( : BuiltinAttributeProvider(
"position", ATTR_DOMAIN_INSTANCE, CD_PROP_FLOAT3, NonCreatable, NonDeletable) "position", AttrDomain::Instance, CD_PROP_FLOAT3, NonCreatable, NonDeletable)
{ {
} }
@ -187,7 +187,7 @@ static ComponentAttributeProviders create_attribute_providers_for_instances()
* instance will be used for the final ID. * instance will be used for the final ID.
*/ */
static BuiltinCustomDataLayerProvider id("id", static BuiltinCustomDataLayerProvider id("id",
ATTR_DOMAIN_INSTANCE, AttrDomain::Instance,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -195,7 +195,7 @@ static ComponentAttributeProviders create_attribute_providers_for_instances()
instance_custom_data_access, instance_custom_data_access,
nullptr); nullptr);
static CustomDataAttributeProvider instance_custom_data(ATTR_DOMAIN_INSTANCE, static CustomDataAttributeProvider instance_custom_data(AttrDomain::Instance,
instance_custom_data_access); instance_custom_data_access);
return ComponentAttributeProviders({&position, &id}, {&instance_custom_data}); return ComponentAttributeProviders({&position, &id}, {&instance_custom_data});
@ -206,26 +206,26 @@ static AttributeAccessorFunctions get_instances_accessor_functions()
static const ComponentAttributeProviders providers = create_attribute_providers_for_instances(); static const ComponentAttributeProviders providers = create_attribute_providers_for_instances();
AttributeAccessorFunctions fn = AttributeAccessorFunctions fn =
attribute_accessor_functions::accessor_functions_for_providers<providers>(); attribute_accessor_functions::accessor_functions_for_providers<providers>();
fn.domain_size = [](const void *owner, const eAttrDomain domain) { fn.domain_size = [](const void *owner, const AttrDomain domain) {
if (owner == nullptr) { if (owner == nullptr) {
return 0; return 0;
} }
const Instances *instances = static_cast<const Instances *>(owner); const Instances *instances = static_cast<const Instances *>(owner);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_INSTANCE: case AttrDomain::Instance:
return instances->instances_num(); return instances->instances_num();
default: default:
return 0; return 0;
} }
}; };
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) { fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
return domain == ATTR_DOMAIN_INSTANCE; return domain == AttrDomain::Instance;
}; };
fn.adapt_domain = [](const void * /*owner*/, fn.adapt_domain = [](const void * /*owner*/,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) { const AttrDomain to_domain) {
if (from_domain == to_domain && from_domain == ATTR_DOMAIN_INSTANCE) { if (from_domain == to_domain && from_domain == AttrDomain::Instance) {
return varray; return varray;
} }
return GVArray{}; return GVArray{};

124
source/blender/blenkernel/intern/geometry_component_mesh.cc
View File

@ -120,16 +120,16 @@ void MeshComponent::ensure_owns_direct_data()
VArray<float3> mesh_normals_varray(const Mesh &mesh, VArray<float3> mesh_normals_varray(const Mesh &mesh,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain domain) const AttrDomain domain)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_FACE: { case AttrDomain::Face: {
return VArray<float3>::ForSpan(mesh.face_normals()); return VArray<float3>::ForSpan(mesh.face_normals());
} }
case ATTR_DOMAIN_POINT: { case AttrDomain::Point: {
return VArray<float3>::ForSpan(mesh.vert_normals()); return VArray<float3>::ForSpan(mesh.vert_normals());
} }
case ATTR_DOMAIN_EDGE: { case AttrDomain::Edge: {
/* In this case, start with vertex normals and convert to the edge domain, since the /* In this case, start with vertex normals and convert to the edge domain, since the
* conversion from edges to vertices is very simple. Use "manual" domain interpolation * conversion from edges to vertices is very simple. Use "manual" domain interpolation
* instead of the GeometryComponent API to avoid calculating unnecessary values and to * instead of the GeometryComponent API to avoid calculating unnecessary values and to
@ -145,13 +145,13 @@ VArray<float3> mesh_normals_varray(const Mesh &mesh,
return VArray<float3>::ForContainer(std::move(edge_normals)); return VArray<float3>::ForContainer(std::move(edge_normals));
} }
case ATTR_DOMAIN_CORNER: { case AttrDomain::Corner: {
/* The normals on corners are just the mesh's face normals, so start with the face normal /* The normals on corners are just the mesh's face normals, so start with the face normal
* array and copy the face normal for each of its corners. In this case using the mesh * array and copy the face normal for each of its corners. In this case using the mesh
* component's generic domain interpolation is fine, the data will still be normalized, * component's generic domain interpolation is fine, the data will still be normalized,
* since the face normal is just copied to every corner. */ * since the face normal is just copied to every corner. */
return mesh.attributes().adapt_domain( return mesh.attributes().adapt_domain(
VArray<float3>::ForSpan(mesh.face_normals()), ATTR_DOMAIN_FACE, ATTR_DOMAIN_CORNER); VArray<float3>::ForSpan(mesh.face_normals()), AttrDomain::Face, AttrDomain::Corner);
} }
default: default:
return {}; return {};
@ -733,34 +733,34 @@ static GVArray adapt_mesh_domain_edge_to_face(const Mesh &mesh, const GVArray &v
} }
static bool can_simple_adapt_for_single(const Mesh &mesh, static bool can_simple_adapt_for_single(const Mesh &mesh,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) const AttrDomain to_domain)
{ {
/* For some domain combinations, a single value will always map directly. For others, there may /* For some domain combinations, a single value will always map directly. For others, there may
* be loose elements on the result domain that should have the default value rather than the * be loose elements on the result domain that should have the default value rather than the
* single value from the source. */ * single value from the source. */
switch (from_domain) { switch (from_domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
/* All other domains are always connected to points. */ /* All other domains are always connected to points. */
return true; return true;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
if (to_domain == ATTR_DOMAIN_POINT) { if (to_domain == AttrDomain::Point) {
return mesh.loose_verts().count == 0; return mesh.loose_verts().count == 0;
} }
return true; return true;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
if (to_domain == ATTR_DOMAIN_POINT) { if (to_domain == AttrDomain::Point) {
return mesh.verts_no_face().count == 0; return mesh.verts_no_face().count == 0;
} }
if (to_domain == ATTR_DOMAIN_EDGE) { if (to_domain == AttrDomain::Edge) {
return mesh.loose_edges().count == 0; return mesh.loose_edges().count == 0;
} }
return true; return true;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
if (to_domain == ATTR_DOMAIN_POINT) { if (to_domain == AttrDomain::Point) {
return mesh.verts_no_face().count == 0; return mesh.verts_no_face().count == 0;
} }
if (to_domain == ATTR_DOMAIN_EDGE) { if (to_domain == AttrDomain::Edge) {
return mesh.loose_edges().count == 0; return mesh.loose_edges().count == 0;
} }
return true; return true;
@ -772,8 +772,8 @@ static bool can_simple_adapt_for_single(const Mesh &mesh,
static GVArray adapt_mesh_attribute_domain(const Mesh &mesh, static GVArray adapt_mesh_attribute_domain(const Mesh &mesh,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) const AttrDomain to_domain)
{ {
if (!varray) { if (!varray) {
return {}; return {};
@ -793,52 +793,52 @@ static GVArray adapt_mesh_attribute_domain(const Mesh &mesh,
} }
switch (from_domain) { switch (from_domain) {
case ATTR_DOMAIN_CORNER: { case AttrDomain::Corner: {
switch (to_domain) { switch (to_domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return adapt_mesh_domain_corner_to_point(mesh, varray); return adapt_mesh_domain_corner_to_point(mesh, varray);
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return adapt_mesh_domain_corner_to_face(mesh, varray); return adapt_mesh_domain_corner_to_face(mesh, varray);
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
return adapt_mesh_domain_corner_to_edge(mesh, varray); return adapt_mesh_domain_corner_to_edge(mesh, varray);
default: default:
break; break;
} }
break; break;
} }
case ATTR_DOMAIN_POINT: { case AttrDomain::Point: {
switch (to_domain) { switch (to_domain) {
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
return adapt_mesh_domain_point_to_corner(mesh, varray); return adapt_mesh_domain_point_to_corner(mesh, varray);
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return adapt_mesh_domain_point_to_face(mesh, varray); return adapt_mesh_domain_point_to_face(mesh, varray);
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
return adapt_mesh_domain_point_to_edge(mesh, varray); return adapt_mesh_domain_point_to_edge(mesh, varray);
default: default:
break; break;
} }
break; break;
} }
case ATTR_DOMAIN_FACE: { case AttrDomain::Face: {
switch (to_domain) { switch (to_domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return adapt_mesh_domain_face_to_point(mesh, varray); return adapt_mesh_domain_face_to_point(mesh, varray);
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
return adapt_mesh_domain_face_to_corner(mesh, varray); return adapt_mesh_domain_face_to_corner(mesh, varray);
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
return adapt_mesh_domain_face_to_edge(mesh, varray); return adapt_mesh_domain_face_to_edge(mesh, varray);
default: default:
break; break;
} }
break; break;
} }
case ATTR_DOMAIN_EDGE: { case AttrDomain::Edge: {
switch (to_domain) { switch (to_domain) {
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
return adapt_mesh_domain_edge_to_corner(mesh, varray); return adapt_mesh_domain_edge_to_corner(mesh, varray);
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return adapt_mesh_domain_edge_to_point(mesh, varray); return adapt_mesh_domain_edge_to_point(mesh, varray);
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return adapt_mesh_domain_edge_to_face(mesh, varray); return adapt_mesh_domain_edge_to_face(mesh, varray);
default: default:
break; break;
@ -891,9 +891,9 @@ class MeshVertexGroupsAttributeProvider final : public DynamicAttributesProvider
const Span<MDeformVert> dverts = mesh->deform_verts(); const Span<MDeformVert> dverts = mesh->deform_verts();
if (dverts.is_empty()) { if (dverts.is_empty()) {
static const float default_value = 0.0f; static const float default_value = 0.0f;
return {VArray<float>::ForSingle(default_value, mesh->verts_num), ATTR_DOMAIN_POINT}; return {VArray<float>::ForSingle(default_value, mesh->verts_num), AttrDomain::Point};
} }
return {bke::varray_for_deform_verts(dverts, vertex_group_index), ATTR_DOMAIN_POINT}; return {bke::varray_for_deform_verts(dverts, vertex_group_index), AttrDomain::Point};
} }
GAttributeWriter try_get_for_write(void *owner, const AttributeIDRef &attribute_id) const final GAttributeWriter try_get_for_write(void *owner, const AttributeIDRef &attribute_id) const final
@ -913,7 +913,7 @@ class MeshVertexGroupsAttributeProvider final : public DynamicAttributesProvider
return {}; return {};
} }
MutableSpan<MDeformVert> dverts = mesh->deform_verts_for_write(); MutableSpan<MDeformVert> dverts = mesh->deform_verts_for_write();
return {bke::varray_for_mutable_deform_verts(dverts, vertex_group_index), ATTR_DOMAIN_POINT}; return {bke::varray_for_mutable_deform_verts(dverts, vertex_group_index), AttrDomain::Point};
} }
bool try_delete(void *owner, const AttributeIDRef &attribute_id) const final bool try_delete(void *owner, const AttributeIDRef &attribute_id) const final
@ -952,16 +952,16 @@ class MeshVertexGroupsAttributeProvider final : public DynamicAttributesProvider
} }
LISTBASE_FOREACH (const bDeformGroup *, group, &mesh->vertex_group_names) { LISTBASE_FOREACH (const bDeformGroup *, group, &mesh->vertex_group_names) {
if (!callback(group->name, {ATTR_DOMAIN_POINT, CD_PROP_FLOAT})) { if (!callback(group->name, {AttrDomain::Point, CD_PROP_FLOAT})) {
return false; return false;
} }
} }
return true; return true;
} }
void foreach_domain(const FunctionRef<void(eAttrDomain)> callback) const final void foreach_domain(const FunctionRef<void(AttrDomain)> callback) const final
{ {
callback(ATTR_DOMAIN_POINT); callback(AttrDomain::Point);
} }
}; };
@ -1004,7 +1004,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
#undef MAKE_MUTABLE_CUSTOM_DATA_GETTER #undef MAKE_MUTABLE_CUSTOM_DATA_GETTER
static BuiltinCustomDataLayerProvider position("position", static BuiltinCustomDataLayerProvider position("position",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1013,7 +1013,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
tag_component_positions_changed); tag_component_positions_changed);
static BuiltinCustomDataLayerProvider id("id", static BuiltinCustomDataLayerProvider id("id",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1029,7 +1029,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
}, },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider material_index("material_index", static BuiltinCustomDataLayerProvider material_index("material_index",
ATTR_DOMAIN_FACE, AttrDomain::Face,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1043,7 +1043,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
[](int2 value) { return math::max(value, int2(0)); }, [](int2 value) { return math::max(value, int2(0)); },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider edge_verts(".edge_verts", static BuiltinCustomDataLayerProvider edge_verts(".edge_verts",
ATTR_DOMAIN_EDGE, AttrDomain::Edge,
CD_PROP_INT32_2D, CD_PROP_INT32_2D,
CD_PROP_INT32_2D, CD_PROP_INT32_2D,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1059,7 +1059,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
[](int value) { return std::max(value, 0); }, [](int value) { return std::max(value, 0); },
mf::build::exec_presets::AllSpanOrSingle()); mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider corner_vert(".corner_vert", static BuiltinCustomDataLayerProvider corner_vert(".corner_vert",
ATTR_DOMAIN_CORNER, AttrDomain::Corner,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1068,7 +1068,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
nullptr, nullptr,
AttributeValidator{&int_index_clamp}); AttributeValidator{&int_index_clamp});
static BuiltinCustomDataLayerProvider corner_edge(".corner_edge", static BuiltinCustomDataLayerProvider corner_edge(".corner_edge",
ATTR_DOMAIN_CORNER, AttrDomain::Corner,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1078,7 +1078,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
AttributeValidator{&int_index_clamp}); AttributeValidator{&int_index_clamp});
static BuiltinCustomDataLayerProvider sharp_face("sharp_face", static BuiltinCustomDataLayerProvider sharp_face("sharp_face",
ATTR_DOMAIN_FACE, AttrDomain::Face,
CD_PROP_BOOL, CD_PROP_BOOL,
CD_PROP_BOOL, CD_PROP_BOOL,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1087,7 +1087,7 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
tag_component_sharpness_changed); tag_component_sharpness_changed);
static BuiltinCustomDataLayerProvider sharp_edge("sharp_edge", static BuiltinCustomDataLayerProvider sharp_edge("sharp_edge",
ATTR_DOMAIN_EDGE, AttrDomain::Edge,
CD_PROP_BOOL, CD_PROP_BOOL,
CD_PROP_BOOL, CD_PROP_BOOL,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -1096,10 +1096,10 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
tag_component_sharpness_changed); tag_component_sharpness_changed);
static MeshVertexGroupsAttributeProvider vertex_groups; static MeshVertexGroupsAttributeProvider vertex_groups;
static CustomDataAttributeProvider corner_custom_data(ATTR_DOMAIN_CORNER, corner_access); static CustomDataAttributeProvider corner_custom_data(AttrDomain::Corner, corner_access);
static CustomDataAttributeProvider point_custom_data(ATTR_DOMAIN_POINT, point_access); static CustomDataAttributeProvider point_custom_data(AttrDomain::Point, point_access);
static CustomDataAttributeProvider edge_custom_data(ATTR_DOMAIN_EDGE, edge_access); static CustomDataAttributeProvider edge_custom_data(AttrDomain::Edge, edge_access);
static CustomDataAttributeProvider face_custom_data(ATTR_DOMAIN_FACE, face_access); static CustomDataAttributeProvider face_custom_data(AttrDomain::Face, face_access);
return ComponentAttributeProviders({&position, return ComponentAttributeProviders({&position,
&edge_verts, &edge_verts,
@ -1121,31 +1121,31 @@ static AttributeAccessorFunctions get_mesh_accessor_functions()
static const ComponentAttributeProviders providers = create_attribute_providers_for_mesh(); static const ComponentAttributeProviders providers = create_attribute_providers_for_mesh();
AttributeAccessorFunctions fn = AttributeAccessorFunctions fn =
attribute_accessor_functions::accessor_functions_for_providers<providers>(); attribute_accessor_functions::accessor_functions_for_providers<providers>();
fn.domain_size = [](const void *owner, const eAttrDomain domain) { fn.domain_size = [](const void *owner, const AttrDomain domain) {
if (owner == nullptr) { if (owner == nullptr) {
return 0; return 0;
} }
const Mesh &mesh = *static_cast<const Mesh *>(owner); const Mesh &mesh = *static_cast<const Mesh *>(owner);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return mesh.verts_num; return mesh.verts_num;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
return mesh.edges_num; return mesh.edges_num;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return mesh.faces_num; return mesh.faces_num;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
return mesh.corners_num; return mesh.corners_num;
default: default:
return 0; return 0;
} }
}; };
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) { fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
return ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_EDGE, ATTR_DOMAIN_FACE, ATTR_DOMAIN_CORNER); return ELEM(domain, AttrDomain::Point, AttrDomain::Edge, AttrDomain::Face, AttrDomain::Corner);
}; };
fn.adapt_domain = [](const void *owner, fn.adapt_domain = [](const void *owner,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) -> GVArray { const AttrDomain to_domain) -> GVArray {
if (owner == nullptr) { if (owner == nullptr) {
return {}; return {};
} }

22
source/blender/blenkernel/intern/geometry_component_pointcloud.cc
View File

@ -140,7 +140,7 @@ static ComponentAttributeProviders create_attribute_providers_for_point_cloud()
}}; }};
static BuiltinCustomDataLayerProvider position("position", static BuiltinCustomDataLayerProvider position("position",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
CD_PROP_FLOAT3, CD_PROP_FLOAT3,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -148,7 +148,7 @@ static ComponentAttributeProviders create_attribute_providers_for_point_cloud()
point_access, point_access,
tag_component_positions_changed); tag_component_positions_changed);
static BuiltinCustomDataLayerProvider radius("radius", static BuiltinCustomDataLayerProvider radius("radius",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_FLOAT, CD_PROP_FLOAT,
CD_PROP_FLOAT, CD_PROP_FLOAT,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
@ -156,14 +156,14 @@ static ComponentAttributeProviders create_attribute_providers_for_point_cloud()
point_access, point_access,
tag_component_radius_changed); tag_component_radius_changed);
static BuiltinCustomDataLayerProvider id("id", static BuiltinCustomDataLayerProvider id("id",
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_INT32, CD_PROP_INT32,
CD_PROP_INT32, CD_PROP_INT32,
BuiltinAttributeProvider::Creatable, BuiltinAttributeProvider::Creatable,
BuiltinAttributeProvider::Deletable, BuiltinAttributeProvider::Deletable,
point_access, point_access,
nullptr); nullptr);
static CustomDataAttributeProvider point_custom_data(ATTR_DOMAIN_POINT, point_access); static CustomDataAttributeProvider point_custom_data(AttrDomain::Point, point_access);
return ComponentAttributeProviders({&position, &radius, &id}, {&point_custom_data}); return ComponentAttributeProviders({&position, &radius, &id}, {&point_custom_data});
} }
@ -173,26 +173,26 @@ static AttributeAccessorFunctions get_pointcloud_accessor_functions()
create_attribute_providers_for_point_cloud(); create_attribute_providers_for_point_cloud();
AttributeAccessorFunctions fn = AttributeAccessorFunctions fn =
attribute_accessor_functions::accessor_functions_for_providers<providers>(); attribute_accessor_functions::accessor_functions_for_providers<providers>();
fn.domain_size = [](const void *owner, const eAttrDomain domain) { fn.domain_size = [](const void *owner, const AttrDomain domain) {
if (owner == nullptr) { if (owner == nullptr) {
return 0; return 0;
} }
const PointCloud &pointcloud = *static_cast<const PointCloud *>(owner); const PointCloud &pointcloud = *static_cast<const PointCloud *>(owner);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return pointcloud.totpoint; return pointcloud.totpoint;
default: default:
return 0; return 0;
} }
}; };
fn.domain_supported = [](const void * /*owner*/, const eAttrDomain domain) { fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
return domain == ATTR_DOMAIN_POINT; return domain == AttrDomain::Point;
}; };
fn.adapt_domain = [](const void * /*owner*/, fn.adapt_domain = [](const void * /*owner*/,
const GVArray &varray, const GVArray &varray,
const eAttrDomain from_domain, const AttrDomain from_domain,
const eAttrDomain to_domain) { const AttrDomain to_domain) {
if (from_domain == to_domain && from_domain == ATTR_DOMAIN_POINT) { if (from_domain == to_domain && from_domain == AttrDomain::Point) {
return varray; return varray;
} }
return GVArray{}; return GVArray{};

84
source/blender/blenkernel/intern/geometry_fields.cc
View File

@ -23,13 +23,13 @@
namespace blender::bke { namespace blender::bke {
MeshFieldContext::MeshFieldContext(const Mesh &mesh, const eAttrDomain domain) MeshFieldContext::MeshFieldContext(const Mesh &mesh, const AttrDomain domain)
: mesh_(mesh), domain_(domain) : mesh_(mesh), domain_(domain)
{ {
BLI_assert(mesh.attributes().domain_supported(domain_)); BLI_assert(mesh.attributes().domain_supported(domain_));
} }
CurvesFieldContext::CurvesFieldContext(const CurvesGeometry &curves, const eAttrDomain domain) CurvesFieldContext::CurvesFieldContext(const CurvesGeometry &curves, const AttrDomain domain)
: curves_(curves), domain_(domain) : curves_(curves), domain_(domain)
{ {
BLI_assert(curves.attributes().domain_supported(domain)); BLI_assert(curves.attributes().domain_supported(domain));
@ -57,7 +57,7 @@ GVArray GreasePencilLayerFieldContext::get_varray_for_input(const fn::FieldInput
} }
GeometryFieldContext::GeometryFieldContext(const GeometryFieldContext &other, GeometryFieldContext::GeometryFieldContext(const GeometryFieldContext &other,
const eAttrDomain domain) const AttrDomain domain)
: geometry_(other.geometry_), : geometry_(other.geometry_),
type_(other.type_), type_(other.type_),
domain_(domain), domain_(domain),
@ -67,7 +67,7 @@ GeometryFieldContext::GeometryFieldContext(const GeometryFieldContext &other,
GeometryFieldContext::GeometryFieldContext(const void *geometry, GeometryFieldContext::GeometryFieldContext(const void *geometry,
const GeometryComponent::Type type, const GeometryComponent::Type type,
const eAttrDomain domain, const AttrDomain domain,
const int grease_pencil_layer_index) const int grease_pencil_layer_index)
: geometry_(geometry), : geometry_(geometry),
type_(type), type_(type),
@ -83,7 +83,7 @@ GeometryFieldContext::GeometryFieldContext(const void *geometry,
} }
GeometryFieldContext::GeometryFieldContext(const GeometryComponent &component, GeometryFieldContext::GeometryFieldContext(const GeometryComponent &component,
const eAttrDomain domain) const AttrDomain domain)
: type_(component.type()), domain_(domain) : type_(component.type()), domain_(domain)
{ {
switch (component.type()) { switch (component.type()) {
@ -109,7 +109,7 @@ GeometryFieldContext::GeometryFieldContext(const GeometryComponent &component,
static_cast<const GreasePencilComponent &>(component); static_cast<const GreasePencilComponent &>(component);
geometry_ = grease_pencil_component.get(); geometry_ = grease_pencil_component.get();
/* Need to use another constructor for other domains. */ /* Need to use another constructor for other domains. */
BLI_assert(domain == ATTR_DOMAIN_LAYER); BLI_assert(domain == AttrDomain::Layer);
break; break;
} }
case GeometryComponent::Type::Instance: { case GeometryComponent::Type::Instance: {
@ -125,26 +125,26 @@ GeometryFieldContext::GeometryFieldContext(const GeometryComponent &component,
} }
} }
GeometryFieldContext::GeometryFieldContext(const Mesh &mesh, eAttrDomain domain) GeometryFieldContext::GeometryFieldContext(const Mesh &mesh, AttrDomain domain)
: geometry_(&mesh), type_(GeometryComponent::Type::Mesh), domain_(domain) : geometry_(&mesh), type_(GeometryComponent::Type::Mesh), domain_(domain)
{ {
} }
GeometryFieldContext::GeometryFieldContext(const CurvesGeometry &curves, eAttrDomain domain) GeometryFieldContext::GeometryFieldContext(const CurvesGeometry &curves, AttrDomain domain)
: geometry_(&curves), type_(GeometryComponent::Type::Curve), domain_(domain) : geometry_(&curves), type_(GeometryComponent::Type::Curve), domain_(domain)
{ {
} }
GeometryFieldContext::GeometryFieldContext(const PointCloud &points) GeometryFieldContext::GeometryFieldContext(const PointCloud &points)
: geometry_(&points), type_(GeometryComponent::Type::PointCloud), domain_(ATTR_DOMAIN_POINT) : geometry_(&points), type_(GeometryComponent::Type::PointCloud), domain_(AttrDomain::Point)
{ {
} }
GeometryFieldContext::GeometryFieldContext(const GreasePencil &grease_pencil) GeometryFieldContext::GeometryFieldContext(const GreasePencil &grease_pencil)
: geometry_(&grease_pencil), : geometry_(&grease_pencil),
type_(GeometryComponent::Type::GreasePencil), type_(GeometryComponent::Type::GreasePencil),
domain_(ATTR_DOMAIN_LAYER) domain_(AttrDomain::Layer)
{ {
} }
GeometryFieldContext::GeometryFieldContext(const GreasePencil &grease_pencil, GeometryFieldContext::GeometryFieldContext(const GreasePencil &grease_pencil,
const eAttrDomain domain, const AttrDomain domain,
const int layer_index) const int layer_index)
: geometry_(&grease_pencil), : geometry_(&grease_pencil),
type_(GeometryComponent::Type::GreasePencil), type_(GeometryComponent::Type::GreasePencil),
@ -155,7 +155,7 @@ GeometryFieldContext::GeometryFieldContext(const GreasePencil &grease_pencil,
GeometryFieldContext::GeometryFieldContext(const Instances &instances) GeometryFieldContext::GeometryFieldContext(const Instances &instances)
: geometry_(&instances), : geometry_(&instances),
type_(GeometryComponent::Type::Instance), type_(GeometryComponent::Type::Instance),
domain_(ATTR_DOMAIN_INSTANCE) domain_(AttrDomain::Instance)
{ {
} }
@ -171,7 +171,7 @@ std::optional<AttributeAccessor> GeometryFieldContext::attributes() const
return pointcloud->attributes(); return pointcloud->attributes();
} }
if (const GreasePencil *grease_pencil = this->grease_pencil()) { if (const GreasePencil *grease_pencil = this->grease_pencil()) {
if (domain_ == ATTR_DOMAIN_LAYER) { if (domain_ == AttrDomain::Layer) {
return grease_pencil->attributes(); return grease_pencil->attributes();
} }
else if (const greasepencil::Drawing *drawing = else if (const greasepencil::Drawing *drawing =
@ -213,7 +213,7 @@ const GreasePencil *GeometryFieldContext::grease_pencil() const
const greasepencil::Drawing *GeometryFieldContext::grease_pencil_layer_drawing() const const greasepencil::Drawing *GeometryFieldContext::grease_pencil_layer_drawing() const
{ {
if (!(this->type() == GeometryComponent::Type::GreasePencil) || if (!(this->type() == GeometryComponent::Type::GreasePencil) ||
!ELEM(domain_, ATTR_DOMAIN_CURVE, ATTR_DOMAIN_POINT)) !ELEM(domain_, AttrDomain::Curve, AttrDomain::Point))
{ {
return nullptr; return nullptr;
} }
@ -279,7 +279,7 @@ GVArray GeometryFieldInput::get_varray_for_context(const fn::FieldContext &conte
return {}; return {};
} }
std::optional<eAttrDomain> GeometryFieldInput::preferred_domain( std::optional<AttrDomain> GeometryFieldInput::preferred_domain(
const GeometryComponent & /*component*/) const const GeometryComponent & /*component*/) const
{ {
return std::nullopt; return std::nullopt;
@ -302,7 +302,7 @@ GVArray MeshFieldInput::get_varray_for_context(const fn::FieldContext &context,
return {}; return {};
} }
std::optional<eAttrDomain> MeshFieldInput::preferred_domain(const Mesh & /*mesh*/) const std::optional<AttrDomain> MeshFieldInput::preferred_domain(const Mesh & /*mesh*/) const
{ {
return std::nullopt; return std::nullopt;
} }
@ -325,7 +325,7 @@ GVArray CurvesFieldInput::get_varray_for_context(const fn::FieldContext &context
return {}; return {};
} }
std::optional<eAttrDomain> CurvesFieldInput::preferred_domain( std::optional<AttrDomain> CurvesFieldInput::preferred_domain(
const CurvesGeometry & /*curves*/) const const CurvesGeometry & /*curves*/) const
{ {
return std::nullopt; return std::nullopt;
@ -373,13 +373,13 @@ GVArray AttributeFieldInput::get_varray_for_context(const GeometryFieldContext &
const IndexMask & /*mask*/) const const IndexMask & /*mask*/) const
{ {
const eCustomDataType data_type = cpp_type_to_custom_data_type(*type_); const eCustomDataType data_type = cpp_type_to_custom_data_type(*type_);
const eAttrDomain domain = context.domain(); const AttrDomain domain = context.domain();
if (const GreasePencil *grease_pencil = context.grease_pencil()) { if (const GreasePencil *grease_pencil = context.grease_pencil()) {
const AttributeAccessor layer_attributes = grease_pencil->attributes(); const AttributeAccessor layer_attributes = grease_pencil->attributes();
if (domain == ATTR_DOMAIN_LAYER) { if (domain == AttrDomain::Layer) {
return *layer_attributes.lookup(name_, data_type); return *layer_attributes.lookup(name_, data_type);
} }
else if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE)) { else if (ELEM(domain, AttrDomain::Point, AttrDomain::Curve)) {
const int layer_index = context.grease_pencil_layer_index(); const int layer_index = context.grease_pencil_layer_index();
const AttributeAccessor curves_attributes = *context.attributes(); const AttributeAccessor curves_attributes = *context.attributes();
if (const GAttributeReader reader = curves_attributes.lookup(name_, domain, data_type)) { if (const GAttributeReader reader = curves_attributes.lookup(name_, domain, data_type)) {
@ -428,7 +428,7 @@ bool AttributeFieldInput::is_equal_to(const fn::FieldNode &other) const
return false; return false;
} }
std::optional<eAttrDomain> AttributeFieldInput::preferred_domain( std::optional<AttrDomain> AttributeFieldInput::preferred_domain(
const GeometryComponent &component) const const GeometryComponent &component) const
{ {
const std::optional<AttributeAccessor> attributes = component.attributes(); const std::optional<AttributeAccessor> attributes = component.attributes();
@ -442,11 +442,11 @@ std::optional<eAttrDomain> AttributeFieldInput::preferred_domain(
return meta_data->domain; return meta_data->domain;
} }
static StringRef get_random_id_attribute_name(const eAttrDomain domain) static StringRef get_random_id_attribute_name(const AttrDomain domain)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
case ATTR_DOMAIN_INSTANCE: case AttrDomain::Instance:
return "id"; return "id";
default: default:
return ""; return "";
@ -512,7 +512,7 @@ bool AnonymousAttributeFieldInput::is_equal_to(const fn::FieldNode &other) const
return false; return false;
} }
std::optional<eAttrDomain> AnonymousAttributeFieldInput::preferred_domain( std::optional<AttrDomain> AnonymousAttributeFieldInput::preferred_domain(
const GeometryComponent &component) const const GeometryComponent &component) const
{ {
const std::optional<AttributeAccessor> attributes = component.attributes(); const std::optional<AttributeAccessor> attributes = component.attributes();
@ -530,8 +530,8 @@ GVArray NamedLayerSelectionFieldInput::get_varray_for_context(
const bke::GeometryFieldContext &context, const IndexMask &mask) const const bke::GeometryFieldContext &context, const IndexMask &mask) const
{ {
using namespace bke::greasepencil; using namespace bke::greasepencil;
const eAttrDomain domain = context.domain(); const AttrDomain domain = context.domain();
if (!ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE, ATTR_DOMAIN_LAYER)) { if (!ELEM(domain, AttrDomain::Point, AttrDomain::Curve, AttrDomain::Layer)) {
return {}; return {};
} }
@ -546,7 +546,7 @@ GVArray NamedLayerSelectionFieldInput::get_varray_for_context(
return {}; return {};
} }
if (domain == ATTR_DOMAIN_LAYER) { if (domain == AttrDomain::Layer) {
Array<bool> selection(mask.min_array_size()); Array<bool> selection(mask.min_array_size());
layer_indices.to_bools(selection); layer_indices.to_bools(selection);
return VArray<bool>::ForContainer(std::move(selection)); return VArray<bool>::ForContainer(std::move(selection));
@ -574,10 +574,10 @@ bool NamedLayerSelectionFieldInput::is_equal_to(const fn::FieldNode &other) cons
return false; return false;
} }
std::optional<eAttrDomain> NamedLayerSelectionFieldInput::preferred_domain( std::optional<AttrDomain> NamedLayerSelectionFieldInput::preferred_domain(
const bke::GeometryComponent & /*component*/) const const bke::GeometryComponent & /*component*/) const
{ {
return ATTR_DOMAIN_LAYER; return AttrDomain::Layer;
} }
} // namespace blender::bke } // namespace blender::bke
@ -627,7 +627,7 @@ static std::optional<AttributeIDRef> try_get_field_direct_attribute_id(const fn:
} }
static bool attribute_kind_matches(const AttributeMetaData meta_data, static bool attribute_kind_matches(const AttributeMetaData meta_data,
const eAttrDomain domain, const AttrDomain domain,
const eCustomDataType data_type) const eCustomDataType data_type)
{ {
return meta_data.domain == domain && meta_data.data_type == data_type; return meta_data.domain == domain && meta_data.data_type == data_type;
@ -639,7 +639,7 @@ static bool attribute_kind_matches(const AttributeMetaData meta_data,
*/ */
static bool try_add_shared_field_attribute(MutableAttributeAccessor attributes, static bool try_add_shared_field_attribute(MutableAttributeAccessor attributes,
const AttributeIDRef &id_to_create, const AttributeIDRef &id_to_create,
const eAttrDomain domain, const AttrDomain domain,
const fn::GField &field) const fn::GField &field)
{ {
const std::optional<AttributeIDRef> field_id = try_get_field_direct_attribute_id(field); const std::optional<AttributeIDRef> field_id = try_get_field_direct_attribute_id(field);
@ -667,7 +667,7 @@ static bool try_add_shared_field_attribute(MutableAttributeAccessor attributes,
static bool try_capture_field_on_geometry(MutableAttributeAccessor attributes, static bool try_capture_field_on_geometry(MutableAttributeAccessor attributes,
const GeometryFieldContext &field_context, const GeometryFieldContext &field_context,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const fn::Field<bool> &selection, const fn::Field<bool> &selection,
const fn::GField &field) const fn::GField &field)
{ {
@ -747,12 +747,12 @@ static bool try_capture_field_on_geometry(MutableAttributeAccessor attributes,
bool try_capture_field_on_geometry(GeometryComponent &component, bool try_capture_field_on_geometry(GeometryComponent &component,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const fn::Field<bool> &selection, const fn::Field<bool> &selection,
const fn::GField &field) const fn::GField &field)
{ {
if (component.type() == GeometryComponent::Type::GreasePencil && if (component.type() == GeometryComponent::Type::GreasePencil &&
ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE)) ELEM(domain, AttrDomain::Point, AttrDomain::Curve))
{ {
/* Capture the field on every layer individually. */ /* Capture the field on every layer individually. */
auto &grease_pencil_component = static_cast<GreasePencilComponent &>(component); auto &grease_pencil_component = static_cast<GreasePencilComponent &>(component);
@ -792,32 +792,32 @@ bool try_capture_field_on_geometry(GeometryComponent &component,
bool try_capture_field_on_geometry(GeometryComponent &component, bool try_capture_field_on_geometry(GeometryComponent &component,
const AttributeIDRef &attribute_id, const AttributeIDRef &attribute_id,
const eAttrDomain domain, const AttrDomain domain,
const fn::GField &field) const fn::GField &field)
{ {
const fn::Field<bool> selection = fn::make_constant_field<bool>(true); const fn::Field<bool> selection = fn::make_constant_field<bool>(true);
return try_capture_field_on_geometry(component, attribute_id, domain, selection, field); return try_capture_field_on_geometry(component, attribute_id, domain, selection, field);
} }
std::optional<eAttrDomain> try_detect_field_domain(const GeometryComponent &component, std::optional<AttrDomain> try_detect_field_domain(const GeometryComponent &component,
const fn::GField &field) const fn::GField &field)
{ {
const GeometryComponent::Type component_type = component.type(); const GeometryComponent::Type component_type = component.type();
if (component_type == GeometryComponent::Type::PointCloud) { if (component_type == GeometryComponent::Type::PointCloud) {
return ATTR_DOMAIN_POINT; return AttrDomain::Point;
} }
if (component_type == GeometryComponent::Type::GreasePencil) { if (component_type == GeometryComponent::Type::GreasePencil) {
return ATTR_DOMAIN_LAYER; return AttrDomain::Layer;
} }
if (component_type == GeometryComponent::Type::Instance) { if (component_type == GeometryComponent::Type::Instance) {
return ATTR_DOMAIN_INSTANCE; return AttrDomain::Instance;
} }
const std::shared_ptr<const fn::FieldInputs> &field_inputs = field.node().field_inputs(); const std::shared_ptr<const fn::FieldInputs> &field_inputs = field.node().field_inputs();
if (!field_inputs) { if (!field_inputs) {
return std::nullopt; return std::nullopt;
} }
std::optional<eAttrDomain> output_domain; std::optional<AttrDomain> output_domain;
auto handle_domain = [&](const std::optional<eAttrDomain> domain) { auto handle_domain = [&](const std::optional<AttrDomain> domain) {
if (!domain.has_value()) { if (!domain.has_value()) {
return false; return false;
} }

14
source/blender/blenkernel/intern/geometry_set.cc
View File

@ -60,7 +60,7 @@ GeometryComponentPtr GeometryComponent::create(Type component_type)
return {}; return {};
} }
int GeometryComponent::attribute_domain_size(const eAttrDomain domain) const int GeometryComponent::attribute_domain_size(const AttrDomain domain) const
{ {
if (this->is_empty()) { if (this->is_empty()) {
return 0; return 0;
@ -608,15 +608,15 @@ void GeometrySet::propagate_attributes_from_layer_to_instances(
if (id.is_anonymous() && !propagation_info.propagate(id.anonymous_id())) { if (id.is_anonymous() && !propagation_info.propagate(id.anonymous_id())) {
return true; return true;
} }
const GAttributeReader src = src_attributes.lookup(id, ATTR_DOMAIN_LAYER); const GAttributeReader src = src_attributes.lookup(id, AttrDomain::Layer);
if (src.sharing_info && src.varray.is_span()) { if (src.sharing_info && src.varray.is_span()) {
const AttributeInitShared init(src.varray.get_internal_span().data(), *src.sharing_info); const AttributeInitShared init(src.varray.get_internal_span().data(), *src.sharing_info);
if (dst_attributes.add(id, ATTR_DOMAIN_INSTANCE, meta_data.data_type, init)) { if (dst_attributes.add(id, AttrDomain::Instance, meta_data.data_type, init)) {
return true; return true;
} }
} }
GSpanAttributeWriter dst = dst_attributes.lookup_or_add_for_write_only_span( GSpanAttributeWriter dst = dst_attributes.lookup_or_add_for_write_only_span(
id, ATTR_DOMAIN_INSTANCE, meta_data.data_type); id, AttrDomain::Instance, meta_data.data_type);
if (!dst) { if (!dst) {
return true; return true;
} }
@ -658,10 +658,10 @@ void GeometrySet::gather_attributes_for_propagation(
return; return;
} }
eAttrDomain domain = meta_data.domain; AttrDomain domain = meta_data.domain;
if (dst_component_type != GeometryComponent::Type::Instance && if (dst_component_type != GeometryComponent::Type::Instance &&
domain == ATTR_DOMAIN_INSTANCE) { domain == AttrDomain::Instance) {
domain = ATTR_DOMAIN_POINT; domain = AttrDomain::Point;
} }
auto add_info = [&](AttributeKind *attribute_kind) { auto add_info = [&](AttributeKind *attribute_kind) {

5
source/blender/blenkernel/intern/gpencil_geom_legacy.cc
View File

@ -2448,6 +2448,7 @@ static void gpencil_generate_edgeloops(Object *ob,
const bool use_vgroups) const bool use_vgroups)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
Mesh *mesh = (Mesh *)ob->data; Mesh *mesh = (Mesh *)ob->data;
if (mesh->edges_num == 0) { if (mesh->edges_num == 0) {
return; return;
@ -2458,7 +2459,7 @@ static void gpencil_generate_edgeloops(Object *ob,
const blender::Span<blender::float3> vert_normals = mesh->vert_normals(); const blender::Span<blender::float3> vert_normals = mesh->vert_normals();
const bke::AttributeAccessor attributes = mesh->attributes(); const bke::AttributeAccessor attributes = mesh->attributes();
const VArray<bool> uv_seams = *attributes.lookup_or_default<bool>( const VArray<bool> uv_seams = *attributes.lookup_or_default<bool>(
".uv_seam", ATTR_DOMAIN_EDGE, false); ".uv_seam", AttrDomain::Edge, false);
/* Arrays for all edge vertices (forward and backward) that form a edge loop. /* Arrays for all edge vertices (forward and backward) that form a edge loop.
* This is reused for each edge-loop to create gpencil stroke. */ * This is reused for each edge-loop to create gpencil stroke. */
@ -2707,7 +2708,7 @@ bool BKE_gpencil_convert_mesh(Main *bmain,
int i; int i;
const VArray<int> mesh_material_indices = *me_eval->attributes().lookup_or_default<int>( const VArray<int> mesh_material_indices = *me_eval->attributes().lookup_or_default<int>(
"material_index", ATTR_DOMAIN_FACE, 0); "material_index", AttrDomain::Face, 0);
for (i = 0; i < faces_len; i++) { for (i = 0; i < faces_len; i++) {
const IndexRange face = faces[i]; const IndexRange face = faces[i];

26
source/blender/blenkernel/intern/grease_pencil.cc
View File

@ -243,17 +243,17 @@ static const std::string ATTR_OPACITY = "opacity";
static const std::string ATTR_VERTEX_COLOR = "vertex_color"; static const std::string ATTR_VERTEX_COLOR = "vertex_color";
/* Curves attributes getters */ /* Curves attributes getters */
static int domain_num(const CurvesGeometry &curves, const eAttrDomain domain) static int domain_num(const CurvesGeometry &curves, const AttrDomain domain)
{ {
return domain == ATTR_DOMAIN_POINT ? curves.points_num() : curves.curves_num(); return domain == AttrDomain::Point ? curves.points_num() : curves.curves_num();
} }
static CustomData &domain_custom_data(CurvesGeometry &curves, const eAttrDomain domain) static CustomData &domain_custom_data(CurvesGeometry &curves, const AttrDomain domain)
{ {
return domain == ATTR_DOMAIN_POINT ? curves.point_data : curves.curve_data; return domain == AttrDomain::Point ? curves.point_data : curves.curve_data;
} }
template<typename T> template<typename T>
static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves, static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves,
const eAttrDomain domain, const AttrDomain domain,
const StringRefNull name, const StringRefNull name,
const T default_value = T()) const T default_value = T())
{ {
@ -370,37 +370,37 @@ bke::CurvesGeometry &Drawing::strokes_for_write()
VArray<float> Drawing::radii() const VArray<float> Drawing::radii() const
{ {
return *this->strokes().attributes().lookup_or_default<float>( return *this->strokes().attributes().lookup_or_default<float>(
ATTR_RADIUS, ATTR_DOMAIN_POINT, 0.01f); ATTR_RADIUS, AttrDomain::Point, 0.01f);
} }
MutableSpan<float> Drawing::radii_for_write() MutableSpan<float> Drawing::radii_for_write()
{ {
return get_mutable_attribute<float>( return get_mutable_attribute<float>(
this->strokes_for_write(), ATTR_DOMAIN_POINT, ATTR_RADIUS, 0.01f); this->strokes_for_write(), AttrDomain::Point, ATTR_RADIUS, 0.01f);
} }
VArray<float> Drawing::opacities() const VArray<float> Drawing::opacities() const
{ {
return *this->strokes().attributes().lookup_or_default<float>( return *this->strokes().attributes().lookup_or_default<float>(
ATTR_OPACITY, ATTR_DOMAIN_POINT, 1.0f); ATTR_OPACITY, AttrDomain::Point, 1.0f);
} }
MutableSpan<float> Drawing::opacities_for_write() MutableSpan<float> Drawing::opacities_for_write()
{ {
return get_mutable_attribute<float>( return get_mutable_attribute<float>(
this->strokes_for_write(), ATTR_DOMAIN_POINT, ATTR_OPACITY, 1.0f); this->strokes_for_write(), AttrDomain::Point, ATTR_OPACITY, 1.0f);
} }
VArray<ColorGeometry4f> Drawing::vertex_colors() const VArray<ColorGeometry4f> Drawing::vertex_colors() const
{ {
return *this->strokes().attributes().lookup_or_default<ColorGeometry4f>( return *this->strokes().attributes().lookup_or_default<ColorGeometry4f>(
ATTR_VERTEX_COLOR, ATTR_DOMAIN_POINT, ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f)); ATTR_VERTEX_COLOR, AttrDomain::Point, ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f));
} }
MutableSpan<ColorGeometry4f> Drawing::vertex_colors_for_write() MutableSpan<ColorGeometry4f> Drawing::vertex_colors_for_write()
{ {
return get_mutable_attribute<ColorGeometry4f>(this->strokes_for_write(), return get_mutable_attribute<ColorGeometry4f>(this->strokes_for_write(),
ATTR_DOMAIN_POINT, AttrDomain::Point,
ATTR_VERTEX_COLOR, ATTR_VERTEX_COLOR,
ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f)); ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f));
} }
@ -1363,7 +1363,7 @@ void BKE_grease_pencil_material_remap(GreasePencil *grease_pencil, const uint *r
greasepencil::Drawing &drawing = reinterpret_cast<GreasePencilDrawing *>(base)->wrap(); greasepencil::Drawing &drawing = reinterpret_cast<GreasePencilDrawing *>(base)->wrap();
MutableAttributeAccessor attributes = drawing.strokes_for_write().attributes_for_write(); MutableAttributeAccessor attributes = drawing.strokes_for_write().attributes_for_write();
SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_span<int>( SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_span<int>(
"material_index", ATTR_DOMAIN_CURVE); "material_index", AttrDomain::Curve);
if (!material_indices) { if (!material_indices) {
return; return;
} }
@ -1416,7 +1416,7 @@ bool BKE_grease_pencil_material_index_used(GreasePencil *grease_pencil, int inde
greasepencil::Drawing &drawing = reinterpret_cast<GreasePencilDrawing *>(base)->wrap(); greasepencil::Drawing &drawing = reinterpret_cast<GreasePencilDrawing *>(base)->wrap();
AttributeAccessor attributes = drawing.strokes().attributes(); AttributeAccessor attributes = drawing.strokes().attributes();
const VArraySpan<int> material_indices = *attributes.lookup_or_default<int>( const VArraySpan<int> material_indices = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_CURVE, 0); "material_index", AttrDomain::Curve, 0);
if (material_indices.contains(index)) { if (material_indices.contains(index)) {
return true; return true;

30
source/blender/blenkernel/intern/grease_pencil_convert_legacy.cc
View File

@ -58,38 +58,38 @@ void legacy_gpencil_frame_to_grease_pencil_drawing(const bGPDframe &gpf,
MutableSpan<float> radii = drawing.radii_for_write(); MutableSpan<float> radii = drawing.radii_for_write();
MutableSpan<float> opacities = drawing.opacities_for_write(); MutableSpan<float> opacities = drawing.opacities_for_write();
SpanAttributeWriter<float> delta_times = attributes.lookup_or_add_for_write_span<float>( SpanAttributeWriter<float> delta_times = attributes.lookup_or_add_for_write_span<float>(
"delta_time", ATTR_DOMAIN_POINT); "delta_time", AttrDomain::Point);
SpanAttributeWriter<float> rotations = attributes.lookup_or_add_for_write_span<float>( SpanAttributeWriter<float> rotations = attributes.lookup_or_add_for_write_span<float>(
"rotation", ATTR_DOMAIN_POINT); "rotation", AttrDomain::Point);
SpanAttributeWriter<ColorGeometry4f> vertex_colors = SpanAttributeWriter<ColorGeometry4f> vertex_colors =
attributes.lookup_or_add_for_write_span<ColorGeometry4f>("vertex_color", ATTR_DOMAIN_POINT); attributes.lookup_or_add_for_write_span<ColorGeometry4f>("vertex_color", AttrDomain::Point);
SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>(
".selection", ATTR_DOMAIN_POINT); ".selection", AttrDomain::Point);
/* Curve Attributes. */ /* Curve Attributes. */
SpanAttributeWriter<bool> stroke_cyclic = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> stroke_cyclic = attributes.lookup_or_add_for_write_span<bool>(
"cyclic", ATTR_DOMAIN_CURVE); "cyclic", AttrDomain::Curve);
/* TODO: This should be a `double` attribute. */ /* TODO: This should be a `double` attribute. */
SpanAttributeWriter<float> stroke_init_times = attributes.lookup_or_add_for_write_span<float>( SpanAttributeWriter<float> stroke_init_times = attributes.lookup_or_add_for_write_span<float>(
"init_time", ATTR_DOMAIN_CURVE); "init_time", AttrDomain::Curve);
SpanAttributeWriter<int8_t> stroke_start_caps = attributes.lookup_or_add_for_write_span<int8_t>( SpanAttributeWriter<int8_t> stroke_start_caps = attributes.lookup_or_add_for_write_span<int8_t>(
"start_cap", ATTR_DOMAIN_CURVE); "start_cap", AttrDomain::Curve);
SpanAttributeWriter<int8_t> stroke_end_caps = attributes.lookup_or_add_for_write_span<int8_t>( SpanAttributeWriter<int8_t> stroke_end_caps = attributes.lookup_or_add_for_write_span<int8_t>(
"end_cap", ATTR_DOMAIN_CURVE); "end_cap", AttrDomain::Curve);
SpanAttributeWriter<float> stroke_hardnesses = attributes.lookup_or_add_for_write_span<float>( SpanAttributeWriter<float> stroke_hardnesses = attributes.lookup_or_add_for_write_span<float>(
"hardness", ATTR_DOMAIN_CURVE); "hardness", AttrDomain::Curve);
SpanAttributeWriter<float> stroke_point_aspect_ratios = SpanAttributeWriter<float> stroke_point_aspect_ratios =
attributes.lookup_or_add_for_write_span<float>("point_aspect_ratio", ATTR_DOMAIN_CURVE); attributes.lookup_or_add_for_write_span<float>("point_aspect_ratio", AttrDomain::Curve);
SpanAttributeWriter<float2> stroke_fill_translations = SpanAttributeWriter<float2> stroke_fill_translations =
attributes.lookup_or_add_for_write_span<float2>("fill_translation", ATTR_DOMAIN_CURVE); attributes.lookup_or_add_for_write_span<float2>("fill_translation", AttrDomain::Curve);
SpanAttributeWriter<float> stroke_fill_rotations = SpanAttributeWriter<float> stroke_fill_rotations =
attributes.lookup_or_add_for_write_span<float>("fill_rotation", ATTR_DOMAIN_CURVE); attributes.lookup_or_add_for_write_span<float>("fill_rotation", AttrDomain::Curve);
SpanAttributeWriter<float2> stroke_fill_scales = attributes.lookup_or_add_for_write_span<float2>( SpanAttributeWriter<float2> stroke_fill_scales = attributes.lookup_or_add_for_write_span<float2>(
"fill_scale", ATTR_DOMAIN_CURVE); "fill_scale", AttrDomain::Curve);
SpanAttributeWriter<ColorGeometry4f> stroke_fill_colors = SpanAttributeWriter<ColorGeometry4f> stroke_fill_colors =
attributes.lookup_or_add_for_write_span<ColorGeometry4f>("fill_color", ATTR_DOMAIN_CURVE); attributes.lookup_or_add_for_write_span<ColorGeometry4f>("fill_color", AttrDomain::Curve);
SpanAttributeWriter<int> stroke_materials = attributes.lookup_or_add_for_write_span<int>( SpanAttributeWriter<int> stroke_materials = attributes.lookup_or_add_for_write_span<int>(
"material_index", ATTR_DOMAIN_CURVE); "material_index", AttrDomain::Curve);
int stroke_i = 0; int stroke_i = 0;
LISTBASE_FOREACH_INDEX (bGPDstroke *, gps, &gpf.strokes, stroke_i) { LISTBASE_FOREACH_INDEX (bGPDstroke *, gps, &gpf.strokes, stroke_i) {

2
source/blender/blenkernel/intern/instances.cc
View File

@ -184,7 +184,7 @@ void Instances::remove(const IndexMask &mask,
array_utils::gather(transforms_.as_span(), mask, new_instances.transforms_.as_mutable_span()); array_utils::gather(transforms_.as_span(), mask, new_instances.transforms_.as_mutable_span());
gather_attributes(this->attributes(), gather_attributes(this->attributes(),
ATTR_DOMAIN_INSTANCE, AttrDomain::Instance,
propagation_info, propagation_info,
{"position"}, {"position"},
mask, mask,

5
source/blender/blenkernel/intern/key.cc
View File

@ -2226,6 +2226,7 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
float (*r_loop_normals)[3]) float (*r_loop_normals)[3])
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
if (r_vert_normals == nullptr && r_face_normals == nullptr && r_loop_normals == nullptr) { if (r_vert_normals == nullptr && r_face_normals == nullptr && r_loop_normals == nullptr) {
return; return;
} }
@ -2278,8 +2279,8 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
const blender::short2 *clnors = static_cast<const blender::short2 *>( const blender::short2 *clnors = static_cast<const blender::short2 *>(
CustomData_get_layer(&mesh->corner_data, CD_CUSTOMLOOPNORMAL)); CustomData_get_layer(&mesh->corner_data, CD_CUSTOMLOOPNORMAL));
const bke::AttributeAccessor attributes = mesh->attributes(); const bke::AttributeAccessor attributes = mesh->attributes();
const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", ATTR_DOMAIN_EDGE); const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", AttrDomain::Edge);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
blender::bke::mesh::normals_calc_loop( blender::bke::mesh::normals_calc_loop(
positions, positions,
edges, edges,

38
source/blender/blenkernel/intern/mesh.cc
View File

@ -642,18 +642,22 @@ MutableSpan<MDeformVert> Mesh::deform_verts_for_write()
this->verts_num}; this->verts_num};
} }
namespace blender::bke {
static void mesh_ensure_cdlayers_primary(Mesh &mesh) static void mesh_ensure_cdlayers_primary(Mesh &mesh)
{ {
blender::bke::MutableAttributeAccessor attributes = mesh.attributes_for_write(); MutableAttributeAccessor attributes = mesh.attributes_for_write();
blender::bke::AttributeInitConstruct attribute_init; AttributeInitConstruct attribute_init;
/* Try to create attributes if they do not exist. */ /* Try to create attributes if they do not exist. */
attributes.add("position", ATTR_DOMAIN_POINT, CD_PROP_FLOAT3, attribute_init); attributes.add("position", AttrDomain::Point, CD_PROP_FLOAT3, attribute_init);
attributes.add(".edge_verts", ATTR_DOMAIN_EDGE, CD_PROP_INT32_2D, attribute_init); attributes.add(".edge_verts", AttrDomain::Edge, CD_PROP_INT32_2D, attribute_init);
attributes.add(".corner_vert", ATTR_DOMAIN_CORNER, CD_PROP_INT32, attribute_init); attributes.add(".corner_vert", AttrDomain::Corner, CD_PROP_INT32, attribute_init);
attributes.add(".corner_edge", ATTR_DOMAIN_CORNER, CD_PROP_INT32, attribute_init); attributes.add(".corner_edge", AttrDomain::Corner, CD_PROP_INT32, attribute_init);
} }
} // namespace blender::bke
Mesh *BKE_mesh_new_nomain(const int verts_num, Mesh *BKE_mesh_new_nomain(const int verts_num,
const int edges_num, const int edges_num,
const int faces_num, const int faces_num,
@ -668,7 +672,7 @@ Mesh *BKE_mesh_new_nomain(const int verts_num,
mesh->faces_num = faces_num; mesh->faces_num = faces_num;
mesh->corners_num = corners_num; mesh->corners_num = corners_num;
mesh_ensure_cdlayers_primary(*mesh); blender::bke::mesh_ensure_cdlayers_primary(*mesh);
BKE_mesh_face_offsets_ensure_alloc(mesh); BKE_mesh_face_offsets_ensure_alloc(mesh);
return mesh; return mesh;
@ -770,7 +774,7 @@ Mesh *BKE_mesh_new_nomain_from_template_ex(const Mesh *me_src,
/* The destination mesh should at least have valid primary CD layers, /* The destination mesh should at least have valid primary CD layers,
* even in cases where the source mesh does not. */ * even in cases where the source mesh does not. */
mesh_ensure_cdlayers_primary(*me_dst); blender::bke::mesh_ensure_cdlayers_primary(*me_dst);
BKE_mesh_face_offsets_ensure_alloc(me_dst); BKE_mesh_face_offsets_ensure_alloc(me_dst);
if (do_tessface && !CustomData_get_layer(&me_dst->fdata_legacy, CD_MFACE)) { if (do_tessface && !CustomData_get_layer(&me_dst->fdata_legacy, CD_MFACE)) {
CustomData_add_layer(&me_dst->fdata_legacy, CD_MFACE, CD_SET_DEFAULT, me_dst->totface_legacy); CustomData_add_layer(&me_dst->fdata_legacy, CD_MFACE, CD_SET_DEFAULT, me_dst->totface_legacy);
@ -1043,7 +1047,7 @@ void BKE_mesh_material_index_remove(Mesh *mesh, short index)
if (!material_indices) { if (!material_indices) {
return; return;
} }
if (material_indices.domain != ATTR_DOMAIN_FACE) { if (material_indices.domain != AttrDomain::Face) {
BLI_assert_unreachable(); BLI_assert_unreachable();
return; return;
} }
@ -1065,7 +1069,7 @@ bool BKE_mesh_material_index_used(Mesh *mesh, short index)
using namespace blender::bke; using namespace blender::bke;
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArray<int> material_indices = *attributes.lookup_or_default<int>( const VArray<int> material_indices = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_FACE, 0); "material_index", AttrDomain::Face, 0);
if (material_indices.is_single()) { if (material_indices.is_single()) {
return material_indices.get_internal_single() == index; return material_indices.get_internal_single() == index;
} }
@ -1108,7 +1112,7 @@ void BKE_mesh_material_remap(Mesh *mesh, const uint *remap, uint remap_len)
else { else {
MutableAttributeAccessor attributes = mesh->attributes_for_write(); MutableAttributeAccessor attributes = mesh->attributes_for_write();
SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_span<int>( SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_span<int>(
"material_index", ATTR_DOMAIN_FACE); "material_index", AttrDomain::Face);
if (!material_indices) { if (!material_indices) {
return; return;
} }
@ -1134,7 +1138,7 @@ void mesh_smooth_set(Mesh &mesh, const bool use_smooth)
else { else {
attributes.remove("sharp_edge"); attributes.remove("sharp_edge");
SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_only_span<bool>(
"sharp_face", ATTR_DOMAIN_FACE); "sharp_face", AttrDomain::Face);
sharp_faces.span.fill(true); sharp_faces.span.fill(true);
sharp_faces.finish(); sharp_faces.finish();
} }
@ -1153,8 +1157,8 @@ void mesh_sharp_edges_set_from_angle(Mesh &mesh, const float angle)
return; return;
} }
SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>(
"sharp_edge", ATTR_DOMAIN_EDGE); "sharp_edge", AttrDomain::Edge);
const VArraySpan<bool> sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan<bool> sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
mesh::edges_sharp_from_angle_set(mesh.faces(), mesh::edges_sharp_from_angle_set(mesh.faces(),
mesh.corner_verts(), mesh.corner_verts(),
mesh.corner_edges(), mesh.corner_edges(),
@ -1283,11 +1287,11 @@ void BKE_mesh_mselect_validate(Mesh *mesh)
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArray<bool> select_vert = *attributes.lookup_or_default<bool>( const VArray<bool> select_vert = *attributes.lookup_or_default<bool>(
".select_vert", ATTR_DOMAIN_POINT, false); ".select_vert", AttrDomain::Point, false);
const VArray<bool> select_edge = *attributes.lookup_or_default<bool>( const VArray<bool> select_edge = *attributes.lookup_or_default<bool>(
".select_edge", ATTR_DOMAIN_EDGE, false); ".select_edge", AttrDomain::Edge, false);
const VArray<bool> select_poly = *attributes.lookup_or_default<bool>( const VArray<bool> select_poly = *attributes.lookup_or_default<bool>(
".select_poly", ATTR_DOMAIN_FACE, false); ".select_poly", AttrDomain::Face, false);
for (i_src = 0, i_dst = 0; i_src < mesh->totselect; i_src++) { for (i_src = 0, i_dst = 0; i_src < mesh->totselect; i_src++) {
int index = mselect_src[i_src].index; int index = mselect_src[i_src].index;

4
source/blender/blenkernel/intern/mesh_boolean_convert.cc
View File

@ -418,7 +418,7 @@ static void copy_face_attributes(Mesh *dest_mesh,
/* Fix material indices after they have been transferred as a generic attribute. */ /* Fix material indices after they have been transferred as a generic attribute. */
const VArray<int> src_material_indices = *orig_me->attributes().lookup_or_default<int>( const VArray<int> src_material_indices = *orig_me->attributes().lookup_or_default<int>(
"material_index", ATTR_DOMAIN_FACE, 0); "material_index", bke::AttrDomain::Face, 0);
const int src_index = src_material_indices[index_in_orig_me]; const int src_index = src_material_indices[index_in_orig_me];
if (material_remap.index_range().contains(src_index)) { if (material_remap.index_range().contains(src_index)) {
const int remapped_index = material_remap[src_index]; const int remapped_index = material_remap[src_index];
@ -738,7 +738,7 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim)
* and set the vertices in the appropriate loops. */ * and set the vertices in the appropriate loops. */
bke::SpanAttributeWriter<int> dst_material_indices = bke::SpanAttributeWriter<int> dst_material_indices =
result->attributes_for_write().lookup_or_add_for_write_only_span<int>("material_index", result->attributes_for_write().lookup_or_add_for_write_only_span<int>("material_index",
ATTR_DOMAIN_FACE); bke::AttrDomain::Face);
int cur_loop_index = 0; int cur_loop_index = 0;
MutableSpan<int> dst_corner_verts = result->corner_verts_for_write(); MutableSpan<int> dst_corner_verts = result->corner_verts_for_write();
MutableSpan<int> dst_face_offsets = result->face_offsets_for_write(); MutableSpan<int> dst_face_offsets = result->face_offsets_for_write();

6
source/blender/blenkernel/intern/mesh_calc_edges.cc
View File

@ -207,7 +207,7 @@ void BKE_mesh_calc_edges(Mesh *mesh, bool keep_existing_edges, const bool select
/* Create new edges. */ /* Create new edges. */
MutableAttributeAccessor attributes = mesh->attributes_for_write(); MutableAttributeAccessor attributes = mesh->attributes_for_write();
attributes.add<int>(".corner_edge", ATTR_DOMAIN_CORNER, AttributeInitConstruct()); attributes.add<int>(".corner_edge", AttrDomain::Corner, AttributeInitConstruct());
MutableSpan<int2> new_edges{ MutableSpan<int2> new_edges{
static_cast<int2 *>(MEM_calloc_arrayN(new_totedge, sizeof(int2), __func__)), new_totedge}; static_cast<int2 *>(MEM_calloc_arrayN(new_totedge, sizeof(int2), __func__)), new_totedge};
calc_edges::serialize_and_initialize_deduplicated_edges(edge_maps, new_edges); calc_edges::serialize_and_initialize_deduplicated_edges(edge_maps, new_edges);
@ -221,12 +221,12 @@ void BKE_mesh_calc_edges(Mesh *mesh, bool keep_existing_edges, const bool select
CustomData_free(&mesh->edge_data, mesh->edges_num); CustomData_free(&mesh->edge_data, mesh->edges_num);
CustomData_reset(&mesh->edge_data); CustomData_reset(&mesh->edge_data);
mesh->edges_num = new_totedge; mesh->edges_num = new_totedge;
attributes.add<int2>(".edge_verts", ATTR_DOMAIN_EDGE, AttributeInitMoveArray(new_edges.data())); attributes.add<int2>(".edge_verts", AttrDomain::Edge, AttributeInitMoveArray(new_edges.data()));
if (select_new_edges) { if (select_new_edges) {
MutableAttributeAccessor attributes = mesh->attributes_for_write(); MutableAttributeAccessor attributes = mesh->attributes_for_write();
SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_span<bool>(
".select_edge", ATTR_DOMAIN_EDGE); ".select_edge", AttrDomain::Edge);
if (select_edge) { if (select_edge) {
int new_edge_index = 0; int new_edge_index = 0;
for (const EdgeMap &edge_map : edge_maps) { for (const EdgeMap &edge_map : edge_maps) {

18
source/blender/blenkernel/intern/mesh_compare.cc
View File

@ -530,7 +530,7 @@ static std::optional<MeshMismatch> verify_attributes_compatible(
static std::optional<MeshMismatch> sort_domain_using_attributes( static std::optional<MeshMismatch> sort_domain_using_attributes(
const AttributeAccessor &mesh1_attributes, const AttributeAccessor &mesh1_attributes,
const AttributeAccessor &mesh2_attributes, const AttributeAccessor &mesh2_attributes,
const eAttrDomain domain, const AttrDomain domain,
const Span<StringRef> excluded_attributes, const Span<StringRef> excluded_attributes,
IndexMapping &maps, IndexMapping &maps,
const float threshold) const float threshold)
@ -587,16 +587,16 @@ static std::optional<MeshMismatch> sort_domain_using_attributes(
component_i); component_i);
if (!attributes_line_up) { if (!attributes_line_up) {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
mismatch = MeshMismatch::VertexAttributes; mismatch = MeshMismatch::VertexAttributes;
return; return;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
mismatch = MeshMismatch::EdgeAttributes; mismatch = MeshMismatch::EdgeAttributes;
return; return;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
mismatch = MeshMismatch::CornerAttributes; mismatch = MeshMismatch::CornerAttributes;
return; return;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
mismatch = MeshMismatch::FaceAttributes; mismatch = MeshMismatch::FaceAttributes;
return; return;
default: default:
@ -792,7 +792,7 @@ std::optional<MeshMismatch> compare_meshes(const Mesh &mesh1,
IndexMapping verts(mesh1.verts_num); IndexMapping verts(mesh1.verts_num);
mismatch = sort_domain_using_attributes( mismatch = sort_domain_using_attributes(
mesh1_attributes, mesh2_attributes, ATTR_DOMAIN_POINT, {}, verts, threshold); mesh1_attributes, mesh2_attributes, AttrDomain::Point, {}, verts, threshold);
if (mismatch) { if (mismatch) {
return mismatch; return mismatch;
}; };
@ -806,7 +806,7 @@ std::optional<MeshMismatch> compare_meshes(const Mesh &mesh1,
} }
mismatch = sort_domain_using_attributes( mismatch = sort_domain_using_attributes(
mesh1_attributes, mesh2_attributes, ATTR_DOMAIN_EDGE, {".edge_verts"}, edges, threshold); mesh1_attributes, mesh2_attributes, AttrDomain::Edge, {".edge_verts"}, edges, threshold);
if (mismatch) { if (mismatch) {
return mismatch; return mismatch;
}; };
@ -825,7 +825,7 @@ std::optional<MeshMismatch> compare_meshes(const Mesh &mesh1,
mismatch = sort_domain_using_attributes(mesh1_attributes, mismatch = sort_domain_using_attributes(mesh1_attributes,
mesh2_attributes, mesh2_attributes,
ATTR_DOMAIN_CORNER, AttrDomain::Corner,
{".corner_vert", ".corner_edge"}, {".corner_vert", ".corner_edge"},
corners, corners,
threshold); threshold);
@ -842,7 +842,7 @@ std::optional<MeshMismatch> compare_meshes(const Mesh &mesh1,
} }
mismatch = sort_domain_using_attributes( mismatch = sort_domain_using_attributes(
mesh1_attributes, mesh2_attributes, ATTR_DOMAIN_FACE, {}, faces, threshold); mesh1_attributes, mesh2_attributes, AttrDomain::Face, {}, faces, threshold);
if (mismatch) { if (mismatch) {
return mismatch; return mismatch;
}; };

6
source/blender/blenkernel/intern/mesh_convert.cc
View File

@ -124,11 +124,11 @@ static Mesh *mesh_nurbs_displist_to_mesh(const Curve *cu, const ListBase *dispba
MutableAttributeAccessor attributes = mesh->attributes_for_write(); MutableAttributeAccessor attributes = mesh->attributes_for_write();
SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_only_span<int>( SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_only_span<int>(
"material_index", ATTR_DOMAIN_FACE); "material_index", AttrDomain::Face);
SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_span<bool>(
"sharp_face", ATTR_DOMAIN_FACE); "sharp_face", AttrDomain::Face);
SpanAttributeWriter<float2> uv_attribute = attributes.lookup_or_add_for_write_span<float2>( SpanAttributeWriter<float2> uv_attribute = attributes.lookup_or_add_for_write_span<float2>(
DATA_("UVMap"), ATTR_DOMAIN_CORNER); DATA_("UVMap"), AttrDomain::Corner);
MutableSpan<float2> uv_map = uv_attribute.span; MutableSpan<float2> uv_map = uv_attribute.span;
int dst_vert = 0; int dst_vert = 0;

50
source/blender/blenkernel/intern/mesh_evaluate.cc
View File

@ -544,7 +544,7 @@ void mesh_hide_vert_flush(Mesh &mesh)
MutableAttributeAccessor attributes = mesh.attributes_for_write(); MutableAttributeAccessor attributes = mesh.attributes_for_write();
const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>( const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>(
".hide_vert", ATTR_DOMAIN_POINT, false); ".hide_vert", AttrDomain::Point, false);
if (hide_vert.is_single() && !hide_vert.get_internal_single()) { if (hide_vert.is_single() && !hide_vert.get_internal_single()) {
attributes.remove(".hide_edge"); attributes.remove(".hide_edge");
attributes.remove(".hide_poly"); attributes.remove(".hide_poly");
@ -553,9 +553,9 @@ void mesh_hide_vert_flush(Mesh &mesh)
const VArraySpan<bool> hide_vert_span{hide_vert}; const VArraySpan<bool> hide_vert_span{hide_vert};
SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_edge", ATTR_DOMAIN_EDGE); ".hide_edge", AttrDomain::Edge);
SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_poly", ATTR_DOMAIN_FACE); ".hide_poly", AttrDomain::Face);
edge_hide_from_vert(mesh.edges(), hide_vert_span, hide_edge.span); edge_hide_from_vert(mesh.edges(), hide_vert_span, hide_edge.span);
face_hide_from_vert(mesh.faces(), mesh.corner_verts(), hide_vert_span, hide_poly.span); face_hide_from_vert(mesh.faces(), mesh.corner_verts(), hide_vert_span, hide_poly.span);
@ -569,7 +569,7 @@ void mesh_hide_face_flush(Mesh &mesh)
MutableAttributeAccessor attributes = mesh.attributes_for_write(); MutableAttributeAccessor attributes = mesh.attributes_for_write();
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", AttrDomain::Face, false);
if (hide_poly.is_single() && !hide_poly.get_internal_single()) { if (hide_poly.is_single() && !hide_poly.get_internal_single()) {
attributes.remove(".hide_vert"); attributes.remove(".hide_vert");
attributes.remove(".hide_edge"); attributes.remove(".hide_edge");
@ -580,9 +580,9 @@ void mesh_hide_face_flush(Mesh &mesh)
const Span<int> corner_verts = mesh.corner_verts(); const Span<int> corner_verts = mesh.corner_verts();
const Span<int> corner_edges = mesh.corner_edges(); const Span<int> corner_edges = mesh.corner_edges();
SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_vert", ATTR_DOMAIN_POINT); ".hide_vert", AttrDomain::Point);
SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_edge", ATTR_DOMAIN_EDGE); ".hide_edge", AttrDomain::Edge);
/* Hide all edges or vertices connected to hidden polygons. */ /* Hide all edges or vertices connected to hidden polygons. */
threading::parallel_for(faces.index_range(), 1024, [&](const IndexRange range) { threading::parallel_for(faces.index_range(), 1024, [&](const IndexRange range) {
@ -617,22 +617,22 @@ void mesh_select_face_flush(Mesh &mesh)
{ {
MutableAttributeAccessor attributes = mesh.attributes_for_write(); MutableAttributeAccessor attributes = mesh.attributes_for_write();
const VArray<bool> select_poly = *attributes.lookup_or_default<bool>( const VArray<bool> select_poly = *attributes.lookup_or_default<bool>(
".select_poly", ATTR_DOMAIN_FACE, false); ".select_poly", AttrDomain::Face, false);
if (select_poly.is_single() && !select_poly.get_internal_single()) { if (select_poly.is_single() && !select_poly.get_internal_single()) {
attributes.remove(".select_vert"); attributes.remove(".select_vert");
attributes.remove(".select_edge"); attributes.remove(".select_edge");
return; return;
} }
SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", AttrDomain::Point);
SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>(
".select_edge", ATTR_DOMAIN_EDGE); ".select_edge", AttrDomain::Edge);
/* Use generic domain interpolation to read the face attribute on the other domains. /* Use generic domain interpolation to read the face attribute on the other domains.
* Assume selected faces are not hidden and none of their vertices/edges are hidden. */ * Assume selected faces are not hidden and none of their vertices/edges are hidden. */
array_utils::copy(*attributes.lookup_or_default<bool>(".select_poly", ATTR_DOMAIN_POINT, false), array_utils::copy(*attributes.lookup_or_default<bool>(".select_poly", AttrDomain::Point, false),
select_vert.span); select_vert.span);
array_utils::copy(*attributes.lookup_or_default<bool>(".select_poly", ATTR_DOMAIN_EDGE, false), array_utils::copy(*attributes.lookup_or_default<bool>(".select_poly", AttrDomain::Edge, false),
select_edge.span); select_edge.span);
select_vert.finish(); select_vert.finish();
@ -643,31 +643,31 @@ void mesh_select_vert_flush(Mesh &mesh)
{ {
MutableAttributeAccessor attributes = mesh.attributes_for_write(); MutableAttributeAccessor attributes = mesh.attributes_for_write();
const VArray<bool> select_vert = *attributes.lookup_or_default<bool>( const VArray<bool> select_vert = *attributes.lookup_or_default<bool>(
".select_vert", ATTR_DOMAIN_POINT, false); ".select_vert", AttrDomain::Point, false);
if (select_vert.is_single() && !select_vert.get_internal_single()) { if (select_vert.is_single() && !select_vert.get_internal_single()) {
attributes.remove(".select_edge"); attributes.remove(".select_edge");
attributes.remove(".select_poly"); attributes.remove(".select_poly");
return; return;
} }
SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>(
".select_edge", ATTR_DOMAIN_EDGE); ".select_edge", AttrDomain::Edge);
SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", AttrDomain::Face);
{ {
IndexMaskMemory memory; IndexMaskMemory memory;
const VArray<bool> hide_edge = *attributes.lookup_or_default<bool>( const VArray<bool> hide_edge = *attributes.lookup_or_default<bool>(
".hide_edge", ATTR_DOMAIN_EDGE, false); ".hide_edge", AttrDomain::Edge, false);
array_utils::copy( array_utils::copy(
*attributes.lookup_or_default<bool>(".select_vert", ATTR_DOMAIN_EDGE, false), *attributes.lookup_or_default<bool>(".select_vert", AttrDomain::Edge, false),
IndexMask::from_bools(hide_edge, memory).complement(hide_edge.index_range(), memory), IndexMask::from_bools(hide_edge, memory).complement(hide_edge.index_range(), memory),
select_edge.span); select_edge.span);
} }
{ {
IndexMaskMemory memory; IndexMaskMemory memory;
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", AttrDomain::Face, false);
array_utils::copy( array_utils::copy(
*attributes.lookup_or_default<bool>(".select_vert", ATTR_DOMAIN_FACE, false), *attributes.lookup_or_default<bool>(".select_vert", AttrDomain::Face, false),
IndexMask::from_bools(hide_poly, memory).complement(hide_poly.index_range(), memory), IndexMask::from_bools(hide_poly, memory).complement(hide_poly.index_range(), memory),
select_poly.span); select_poly.span);
} }
@ -679,31 +679,31 @@ void mesh_select_edge_flush(Mesh &mesh)
{ {
MutableAttributeAccessor attributes = mesh.attributes_for_write(); MutableAttributeAccessor attributes = mesh.attributes_for_write();
const VArray<bool> select_edge = *attributes.lookup_or_default<bool>( const VArray<bool> select_edge = *attributes.lookup_or_default<bool>(
".select_edge", ATTR_DOMAIN_POINT, false); ".select_edge", AttrDomain::Point, false);
if (select_edge.is_single() && !select_edge.get_internal_single()) { if (select_edge.is_single() && !select_edge.get_internal_single()) {
attributes.remove(".select_vert"); attributes.remove(".select_vert");
attributes.remove(".select_poly"); attributes.remove(".select_poly");
return; return;
} }
SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", AttrDomain::Point);
SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", AttrDomain::Face);
{ {
IndexMaskMemory memory; IndexMaskMemory memory;
const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>( const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>(
".hide_vert", ATTR_DOMAIN_POINT, false); ".hide_vert", AttrDomain::Point, false);
array_utils::copy( array_utils::copy(
*attributes.lookup_or_default<bool>(".select_vert", ATTR_DOMAIN_POINT, false), *attributes.lookup_or_default<bool>(".select_vert", AttrDomain::Point, false),
IndexMask::from_bools(hide_vert, memory).complement(hide_vert.index_range(), memory), IndexMask::from_bools(hide_vert, memory).complement(hide_vert.index_range(), memory),
select_vert.span); select_vert.span);
} }
{ {
IndexMaskMemory memory; IndexMaskMemory memory;
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", AttrDomain::Face, false);
array_utils::copy( array_utils::copy(
*attributes.lookup_or_default<bool>(".select_vert", ATTR_DOMAIN_FACE, false), *attributes.lookup_or_default<bool>(".select_vert", AttrDomain::Face, false),
IndexMask::from_bools(hide_poly, memory).complement(hide_poly.index_range(), memory), IndexMask::from_bools(hide_poly, memory).complement(hide_poly.index_range(), memory),
select_poly.span); select_poly.span);
} }

2
source/blender/blenkernel/intern/mesh_flip_faces.cc
View File

@ -78,7 +78,7 @@ void mesh_flip_faces(Mesh &mesh, const IndexMask &selection)
if (meta_data.data_type == CD_PROP_STRING) { if (meta_data.data_type == CD_PROP_STRING) {
return true; return true;
} }
if (meta_data.domain != ATTR_DOMAIN_CORNER) { if (meta_data.domain != AttrDomain::Corner) {
return true; return true;
} }
if (ELEM(attribute_id.name(), ".corner_vert", ".corner_edge")) { if (ELEM(attribute_id.name(), ".corner_vert", ".corner_edge")) {

27
source/blender/blenkernel/intern/mesh_legacy_convert.cc
View File

@ -1286,7 +1286,7 @@ void BKE_mesh_legacy_sharp_faces_from_flags(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> sharp_faces = attributes.lookup_or_add_for_write_only_span<bool>(
"sharp_face", ATTR_DOMAIN_FACE); "sharp_face", AttrDomain::Face);
threading::parallel_for(polys.index_range(), 4096, [&](const IndexRange range) { threading::parallel_for(polys.index_range(), 4096, [&](const IndexRange range) {
for (const int i : range) { for (const int i : range) {
sharp_faces.span[i] = !(polys[i].flag_legacy & ME_SMOOTH); sharp_faces.span[i] = !(polys[i].flag_legacy & ME_SMOOTH);
@ -1384,7 +1384,7 @@ static void move_face_map_data_to_attributes(Mesh *mesh)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
for (const auto item : groups.items()) { for (const auto item : groups.items()) {
bke::SpanAttributeWriter<bool> attribute = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> attribute = attributes.lookup_or_add_for_write_span<bool>(
".temp_face_map_" + std::to_string(item.key), ATTR_DOMAIN_FACE); ".temp_face_map_" + std::to_string(item.key), bke::AttrDomain::Face);
if (attribute) { if (attribute) {
attribute.span.fill_indices(item.value.as_span(), true); attribute.span.fill_indices(item.value.as_span(), true);
attribute.finish(); attribute.finish();
@ -1544,7 +1544,7 @@ void BKE_mesh_legacy_sharp_edges_from_flags(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_only_span<bool>(
"sharp_edge", ATTR_DOMAIN_EDGE); "sharp_edge", AttrDomain::Edge);
threading::parallel_for(edges.index_range(), 4096, [&](const IndexRange range) { threading::parallel_for(edges.index_range(), 4096, [&](const IndexRange range) {
for (const int i : range) { for (const int i : range) {
sharp_edges.span[i] = edges[i].flag_legacy & ME_SHARP; sharp_edges.span[i] = edges[i].flag_legacy & ME_SHARP;
@ -1577,7 +1577,7 @@ void BKE_mesh_legacy_uv_seam_from_flags(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> uv_seams = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> uv_seams = attributes.lookup_or_add_for_write_only_span<bool>(
".uv_seam", ATTR_DOMAIN_EDGE); ".uv_seam", AttrDomain::Edge);
threading::parallel_for(edges.index_range(), 4096, [&](const IndexRange range) { threading::parallel_for(edges.index_range(), 4096, [&](const IndexRange range) {
for (const int i : range) { for (const int i : range) {
uv_seams.span[i] = edges[i].flag_legacy & ME_SEAM; uv_seams.span[i] = edges[i].flag_legacy & ME_SEAM;
@ -1609,7 +1609,7 @@ void BKE_mesh_legacy_convert_flags_to_hide_layers(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_vert", ATTR_DOMAIN_POINT); ".hide_vert", AttrDomain::Point);
threading::parallel_for(verts.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(verts.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
hide_vert.span[i] = verts[i].flag_legacy & ME_HIDE; hide_vert.span[i] = verts[i].flag_legacy & ME_HIDE;
@ -1625,7 +1625,7 @@ void BKE_mesh_legacy_convert_flags_to_hide_layers(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_edge", ATTR_DOMAIN_EDGE); ".hide_edge", AttrDomain::Edge);
threading::parallel_for(edges.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(edges.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
hide_edge.span[i] = edges[i].flag_legacy & ME_HIDE; hide_edge.span[i] = edges[i].flag_legacy & ME_HIDE;
@ -1643,7 +1643,7 @@ void BKE_mesh_legacy_convert_flags_to_hide_layers(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_only_span<bool>(
".hide_poly", ATTR_DOMAIN_FACE); ".hide_poly", AttrDomain::Face);
threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
hide_poly.span[i] = polys[i].flag_legacy & ME_HIDE; hide_poly.span[i] = polys[i].flag_legacy & ME_HIDE;
@ -1674,7 +1674,7 @@ void BKE_mesh_legacy_convert_mpoly_to_material_indices(Mesh *mesh)
polys.begin(), polys.end(), [](const MPoly &poly) { return poly.mat_nr_legacy != 0; })) polys.begin(), polys.end(), [](const MPoly &poly) { return poly.mat_nr_legacy != 0; }))
{ {
SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_only_span<int>( SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_only_span<int>(
"material_index", ATTR_DOMAIN_FACE); "material_index", AttrDomain::Face);
threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
material_indices.span[i] = polys[i].mat_nr_legacy; material_indices.span[i] = polys[i].mat_nr_legacy;
@ -1835,7 +1835,7 @@ void BKE_mesh_legacy_convert_flags_to_selection_layers(Mesh *mesh)
verts.begin(), verts.end(), [](const MVert &vert) { return vert.flag_legacy & SELECT; })) verts.begin(), verts.end(), [](const MVert &vert) { return vert.flag_legacy & SELECT; }))
{ {
SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_only_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", AttrDomain::Point);
threading::parallel_for(verts.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(verts.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
select_vert.span[i] = verts[i].flag_legacy & SELECT; select_vert.span[i] = verts[i].flag_legacy & SELECT;
@ -1851,7 +1851,7 @@ void BKE_mesh_legacy_convert_flags_to_selection_layers(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_only_span<bool>(
".select_edge", ATTR_DOMAIN_EDGE); ".select_edge", AttrDomain::Edge);
threading::parallel_for(edges.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(edges.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
select_edge.span[i] = edges[i].flag_legacy & SELECT; select_edge.span[i] = edges[i].flag_legacy & SELECT;
@ -1869,7 +1869,7 @@ void BKE_mesh_legacy_convert_flags_to_selection_layers(Mesh *mesh)
})) }))
{ {
SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>( SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_only_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", AttrDomain::Face);
threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) { threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
select_poly.span[i] = polys[i].flag_legacy & ME_FACE_SEL; select_poly.span[i] = polys[i].flag_legacy & ME_FACE_SEL;
@ -2118,6 +2118,7 @@ void BKE_mesh_legacy_convert_polys_to_offsets(Mesh *mesh)
static bNodeTree *add_auto_smooth_node_tree(Main &bmain) static bNodeTree *add_auto_smooth_node_tree(Main &bmain)
{ {
using namespace blender;
bNodeTree *group = ntreeAddTree(&bmain, DATA_("Auto Smooth"), "GeometryNodeTree"); bNodeTree *group = ntreeAddTree(&bmain, DATA_("Auto Smooth"), "GeometryNodeTree");
if (!group->geometry_node_asset_traits) { if (!group->geometry_node_asset_traits) {
group->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(__func__); group->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(__func__);
@ -2156,11 +2157,11 @@ static bNodeTree *add_auto_smooth_node_tree(Main &bmain)
} }
} }
bNode *shade_smooth_edge = nodeAddNode(nullptr, group, "GeometryNodeSetShadeSmooth"); bNode *shade_smooth_edge = nodeAddNode(nullptr, group, "GeometryNodeSetShadeSmooth");
shade_smooth_edge->custom1 = ATTR_DOMAIN_EDGE; shade_smooth_edge->custom1 = int16_t(bke::AttrDomain::Edge);
shade_smooth_edge->locx = 120.0f; shade_smooth_edge->locx = 120.0f;
shade_smooth_edge->locy = -100.0f; shade_smooth_edge->locy = -100.0f;
bNode *shade_smooth_face = nodeAddNode(nullptr, group, "GeometryNodeSetShadeSmooth"); bNode *shade_smooth_face = nodeAddNode(nullptr, group, "GeometryNodeSetShadeSmooth");
shade_smooth_face->custom1 = ATTR_DOMAIN_FACE; shade_smooth_face->custom1 = int16_t(bke::AttrDomain::Face);
shade_smooth_face->locx = 300.0f; shade_smooth_face->locx = 300.0f;
shade_smooth_face->locy = -100.0f; shade_smooth_face->locy = -100.0f;
bNode *edge_angle = nodeAddNode(nullptr, group, "GeometryNodeInputMeshEdgeAngle"); bNode *edge_angle = nodeAddNode(nullptr, group, "GeometryNodeInputMeshEdgeAngle");

5
source/blender/blenkernel/intern/mesh_mirror.cc
View File

@ -125,6 +125,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
int *r_vert_merge_map_len) int *r_vert_merge_map_len)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
const float tolerance_sq = mmd->tolerance * mmd->tolerance; const float tolerance_sq = mmd->tolerance * mmd->tolerance;
const bool do_vtargetmap = (mmd->flag & MOD_MIR_NO_MERGE) == 0 && r_vert_merge_map != nullptr; const bool do_vtargetmap = (mmd->flag & MOD_MIR_NO_MERGE) == 0 && r_vert_merge_map != nullptr;
@ -407,8 +408,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
/* calculate custom normals into loop_normals, then mirror first half into second half */ /* calculate custom normals into loop_normals, then mirror first half into second half */
const bke::AttributeAccessor attributes = result->attributes(); const bke::AttributeAccessor attributes = result->attributes();
const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", ATTR_DOMAIN_EDGE); const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", AttrDomain::Edge);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
blender::bke::mesh::normals_calc_loop(result->vert_positions(), blender::bke::mesh::normals_calc_loop(result->vert_positions(),
result_edges, result_edges,
result_faces, result_faces,

12
source/blender/blenkernel/intern/mesh_normals.cc
View File

@ -215,7 +215,7 @@ blender::bke::MeshNormalDomain Mesh::normals_domain() const
const AttributeAccessor attributes = this->attributes(); const AttributeAccessor attributes = this->attributes();
const VArray<bool> sharp_faces = *attributes.lookup_or_default<bool>( const VArray<bool> sharp_faces = *attributes.lookup_or_default<bool>(
"sharp_face", ATTR_DOMAIN_FACE, false); "sharp_face", AttrDomain::Face, false);
const array_utils::BooleanMix face_mix = array_utils::booleans_mix_calc(sharp_faces); const array_utils::BooleanMix face_mix = array_utils::booleans_mix_calc(sharp_faces);
if (face_mix == array_utils::BooleanMix::AllTrue) { if (face_mix == array_utils::BooleanMix::AllTrue) {
@ -223,7 +223,7 @@ blender::bke::MeshNormalDomain Mesh::normals_domain() const
} }
const VArray<bool> sharp_edges = *attributes.lookup_or_default<bool>( const VArray<bool> sharp_edges = *attributes.lookup_or_default<bool>(
"sharp_edge", ATTR_DOMAIN_EDGE, false); "sharp_edge", AttrDomain::Edge, false);
const array_utils::BooleanMix edge_mix = array_utils::booleans_mix_calc(sharp_edges); const array_utils::BooleanMix edge_mix = array_utils::booleans_mix_calc(sharp_edges);
if (edge_mix == array_utils::BooleanMix::AllTrue) { if (edge_mix == array_utils::BooleanMix::AllTrue) {
return MeshNormalDomain::Face; return MeshNormalDomain::Face;
@ -292,8 +292,8 @@ blender::Span<blender::float3> Mesh::corner_normals() const
} }
case MeshNormalDomain::Corner: { case MeshNormalDomain::Corner: {
const AttributeAccessor attributes = this->attributes(); const AttributeAccessor attributes = this->attributes();
const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", ATTR_DOMAIN_EDGE); const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", AttrDomain::Edge);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
const short2 *custom_normals = static_cast<const short2 *>( const short2 *custom_normals = static_cast<const short2 *>(
CustomData_get_layer(&this->corner_data, CD_CUSTOMLOOPNORMAL)); CustomData_get_layer(&this->corner_data, CD_CUSTOMLOOPNORMAL));
mesh::normals_calc_loop(this->vert_positions(), mesh::normals_calc_loop(this->vert_positions(),
@ -1558,8 +1558,8 @@ static void mesh_set_custom_normals(Mesh *mesh, float (*r_custom_nors)[3], const
} }
MutableAttributeAccessor attributes = mesh->attributes_for_write(); MutableAttributeAccessor attributes = mesh->attributes_for_write();
SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>(
"sharp_edge", ATTR_DOMAIN_EDGE); "sharp_edge", AttrDomain::Edge);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
mesh_normals_loop_custom_set(mesh->vert_positions(), mesh_normals_loop_custom_set(mesh->vert_positions(),
mesh->edges(), mesh->edges(),

18
source/blender/blenkernel/intern/mesh_remesh_voxel.cc
View File

@ -462,7 +462,7 @@ static void find_nearest_edges(const Span<float3> src_positions,
static void gather_attributes(const Span<AttributeIDRef> ids, static void gather_attributes(const Span<AttributeIDRef> ids,
const AttributeAccessor src_attributes, const AttributeAccessor src_attributes,
const eAttrDomain domain, const AttrDomain domain,
const Span<int> index_map, const Span<int> index_map,
MutableAttributeAccessor dst_attributes) MutableAttributeAccessor dst_attributes)
{ {
@ -489,16 +489,16 @@ void mesh_remesh_reproject_attributes(const Mesh &src, Mesh &dst)
return true; return true;
} }
switch (meta_data.domain) { switch (meta_data.domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
point_ids.append(id); point_ids.append(id);
break; break;
case ATTR_DOMAIN_EDGE: case AttrDomain::Edge:
edge_ids.append(id); edge_ids.append(id);
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
face_ids.append(id); face_ids.append(id);
break; break;
case ATTR_DOMAIN_CORNER: case AttrDomain::Corner:
corner_ids.append(id); corner_ids.append(id);
break; break;
default: default:
@ -546,7 +546,7 @@ void mesh_remesh_reproject_attributes(const Mesh &src, Mesh &dst)
Array<int> map(dst.verts_num); Array<int> map(dst.verts_num);
find_nearest_verts( find_nearest_verts(
src_positions, src_corner_verts, src_corner_tris, dst_positions, vert_nearest_tris, map); src_positions, src_corner_verts, src_corner_tris, dst_positions, vert_nearest_tris, map);
gather_attributes(point_ids, src_attributes, ATTR_DOMAIN_POINT, map, dst_attributes); gather_attributes(point_ids, src_attributes, AttrDomain::Point, map, dst_attributes);
} }
if (!corner_ids.is_empty()) { if (!corner_ids.is_empty()) {
@ -560,7 +560,7 @@ void mesh_remesh_reproject_attributes(const Mesh &src, Mesh &dst)
dst_corner_verts, dst_corner_verts,
vert_nearest_tris, vert_nearest_tris,
map); map);
gather_attributes(corner_ids, src_attributes, ATTR_DOMAIN_CORNER, map, dst_attributes); gather_attributes(corner_ids, src_attributes, AttrDomain::Corner, map, dst_attributes);
} }
} }
@ -579,14 +579,14 @@ void mesh_remesh_reproject_attributes(const Mesh &src, Mesh &dst)
dst_edges, dst_edges,
bvhtree, bvhtree,
map); map);
gather_attributes(edge_ids, src_attributes, ATTR_DOMAIN_EDGE, map, dst_attributes); gather_attributes(edge_ids, src_attributes, AttrDomain::Edge, map, dst_attributes);
} }
if (!face_ids.is_empty()) { if (!face_ids.is_empty()) {
const Span<int> src_tri_faces = src.corner_tri_faces(); const Span<int> src_tri_faces = src.corner_tri_faces();
Array<int> map(dst.faces_num); Array<int> map(dst.faces_num);
find_nearest_faces(src_tri_faces, dst_positions, dst_faces, dst_corner_verts, bvhtree, map); find_nearest_faces(src_tri_faces, dst_positions, dst_faces, dst_corner_verts, bvhtree, map);
gather_attributes(face_ids, src_attributes, ATTR_DOMAIN_FACE, map, dst_attributes); gather_attributes(face_ids, src_attributes, AttrDomain::Face, map, dst_attributes);
} }
if (src.active_color_attribute) { if (src.active_color_attribute) {

2
source/blender/blenkernel/intern/mesh_sample.cc
View File

@ -483,7 +483,7 @@ void BaryWeightSampleFn::evaluate_source(fn::GField src_field)
/* Use the most complex domain for now, ensuring no information is lost. In the future, it should /* Use the most complex domain for now, ensuring no information is lost. In the future, it should
* be possible to use the most complex domain required by the field inputs, to simplify sampling * be possible to use the most complex domain required by the field inputs, to simplify sampling
* and avoid domain conversions. */ * and avoid domain conversions. */
domain_ = ATTR_DOMAIN_CORNER; domain_ = AttrDomain::Corner;
source_context_.emplace(bke::MeshFieldContext(mesh, domain_)); source_context_.emplace(bke::MeshFieldContext(mesh, domain_));
const int domain_size = mesh.attributes().domain_size(domain_); const int domain_size = mesh.attributes().domain_size(domain_);
source_evaluator_ = std::make_unique<fn::FieldEvaluator>(*source_context_, domain_size); source_evaluator_ = std::make_unique<fn::FieldEvaluator>(*source_context_, domain_size);

5
source/blender/blenkernel/intern/mesh_tangent.cc
View File

@ -123,13 +123,12 @@ void BKE_mesh_calc_loop_tangent_single(Mesh *mesh,
{ {
using namespace blender; using namespace blender;
using namespace blender::bke; using namespace blender::bke;
if (!uvmap) { if (!uvmap) {
uvmap = CustomData_get_active_layer_name(&mesh->corner_data, CD_PROP_FLOAT2); uvmap = CustomData_get_active_layer_name(&mesh->corner_data, CD_PROP_FLOAT2);
} }
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArraySpan uv_map = *attributes.lookup<float2>(uvmap, ATTR_DOMAIN_CORNER); const VArraySpan uv_map = *attributes.lookup<float2>(uvmap, AttrDomain::Corner);
if (uv_map.is_empty()) { if (uv_map.is_empty()) {
BKE_reportf(reports, BKE_reportf(reports,
RPT_ERROR, RPT_ERROR,
@ -585,7 +584,7 @@ void BKE_mesh_calc_loop_tangents(Mesh *me_eval,
using namespace blender::bke; using namespace blender::bke;
const blender::Span<int3> corner_tris = me_eval->corner_tris(); const blender::Span<int3> corner_tris = me_eval->corner_tris();
const bke::AttributeAccessor attributes = me_eval->attributes(); const bke::AttributeAccessor attributes = me_eval->attributes();
const VArraySpan sharp_face = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_face = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
short tangent_mask = 0; short tangent_mask = 0;
BKE_mesh_calc_loop_tangent_ex( BKE_mesh_calc_loop_tangent_ex(
reinterpret_cast<const float(*)[3]>(me_eval->vert_positions().data()), reinterpret_cast<const float(*)[3]>(me_eval->vert_positions().data()),

8
source/blender/blenkernel/intern/multires_reshape_util.cc
View File

@ -187,6 +187,7 @@ bool multires_reshape_context_create_from_object(MultiresReshapeContext *reshape
MultiresModifierData *mmd) MultiresModifierData *mmd)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
context_zero(reshape_context); context_zero(reshape_context);
const bool use_render_params = false; const bool use_render_params = false;
@ -216,8 +217,8 @@ bool multires_reshape_context_create_from_object(MultiresReshapeContext *reshape
reshape_context->top.grid_size = BKE_subdiv_grid_size_from_level(reshape_context->top.level); reshape_context->top.grid_size = BKE_subdiv_grid_size_from_level(reshape_context->top.level);
const bke::AttributeAccessor attributes = base_mesh->attributes(); const bke::AttributeAccessor attributes = base_mesh->attributes();
reshape_context->cd_vertex_crease = *attributes.lookup<float>("crease_vert", ATTR_DOMAIN_POINT); reshape_context->cd_vertex_crease = *attributes.lookup<float>("crease_vert", AttrDomain::Point);
reshape_context->cd_edge_crease = *attributes.lookup<float>("crease_edge", ATTR_DOMAIN_EDGE); reshape_context->cd_edge_crease = *attributes.lookup<float>("crease_edge", AttrDomain::Edge);
context_init_commoon(reshape_context); context_init_commoon(reshape_context);
@ -275,6 +276,7 @@ bool multires_reshape_context_create_from_subdiv(MultiresReshapeContext *reshape
int top_level) int top_level)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
context_zero(reshape_context); context_zero(reshape_context);
Mesh *base_mesh = (Mesh *)object->data; Mesh *base_mesh = (Mesh *)object->data;
@ -288,7 +290,7 @@ bool multires_reshape_context_create_from_subdiv(MultiresReshapeContext *reshape
reshape_context->base_corner_edges = base_mesh->corner_edges(); reshape_context->base_corner_edges = base_mesh->corner_edges();
const bke::AttributeAccessor attributes = base_mesh->attributes(); const bke::AttributeAccessor attributes = base_mesh->attributes();
reshape_context->cd_vertex_crease = *attributes.lookup<float>("crease_vert", ATTR_DOMAIN_POINT); reshape_context->cd_vertex_crease = *attributes.lookup<float>("crease_vert", AttrDomain::Point);
reshape_context->subdiv = subdiv; reshape_context->subdiv = subdiv;
reshape_context->need_free_subdiv = false; reshape_context->need_free_subdiv = false;

75
source/blender/blenkernel/intern/paint.cc
View File

@ -79,10 +79,11 @@ using blender::float3;
using blender::MutableSpan; using blender::MutableSpan;
using blender::Span; using blender::Span;
using blender::Vector; using blender::Vector;
using blender::bke::AttrDomain;
static void sculpt_attribute_update_refs(Object *ob); static void sculpt_attribute_update_refs(Object *ob);
static SculptAttribute *sculpt_attribute_ensure_ex(Object *ob, static SculptAttribute *sculpt_attribute_ensure_ex(Object *ob,
eAttrDomain domain, AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name, const char *name,
const SculptAttributeParams *params, const SculptAttributeParams *params,
@ -1639,11 +1640,11 @@ static void sculpt_update_persistent_base(Object *ob)
SculptSession *ss = ob->sculpt; SculptSession *ss = ob->sculpt;
ss->attrs.persistent_co = BKE_sculpt_attribute_get( ss->attrs.persistent_co = BKE_sculpt_attribute_get(
ob, ATTR_DOMAIN_POINT, CD_PROP_FLOAT3, SCULPT_ATTRIBUTE_NAME(persistent_co)); ob, AttrDomain::Point, CD_PROP_FLOAT3, SCULPT_ATTRIBUTE_NAME(persistent_co));
ss->attrs.persistent_no = BKE_sculpt_attribute_get( ss->attrs.persistent_no = BKE_sculpt_attribute_get(
ob, ATTR_DOMAIN_POINT, CD_PROP_FLOAT3, SCULPT_ATTRIBUTE_NAME(persistent_no)); ob, AttrDomain::Point, CD_PROP_FLOAT3, SCULPT_ATTRIBUTE_NAME(persistent_no));
ss->attrs.persistent_disp = BKE_sculpt_attribute_get( ss->attrs.persistent_disp = BKE_sculpt_attribute_get(
ob, ATTR_DOMAIN_POINT, CD_PROP_FLOAT, SCULPT_ATTRIBUTE_NAME(persistent_disp)); ob, AttrDomain::Point, CD_PROP_FLOAT, SCULPT_ATTRIBUTE_NAME(persistent_disp));
} }
static void sculpt_update_object(Depsgraph *depsgraph, static void sculpt_update_object(Depsgraph *depsgraph,
@ -1705,7 +1706,7 @@ static void sculpt_update_object(Depsgraph *depsgraph,
ss->multires.level = 0; ss->multires.level = 0;
CustomDataLayer *layer; CustomDataLayer *layer;
eAttrDomain domain; AttrDomain domain;
if (BKE_pbvh_get_color_layer(mesh, &layer, &domain)) { if (BKE_pbvh_get_color_layer(mesh, &layer, &domain)) {
if (layer->type == CD_PROP_COLOR) { if (layer->type == CD_PROP_COLOR) {
ss->vcol = static_cast<MPropCol *>(layer->data); ss->vcol = static_cast<MPropCol *>(layer->data);
@ -1722,7 +1723,7 @@ static void sculpt_update_object(Depsgraph *depsgraph,
ss->mcol = nullptr; ss->mcol = nullptr;
ss->vcol_type = (eCustomDataType)-1; ss->vcol_type = (eCustomDataType)-1;
ss->vcol_domain = ATTR_DOMAIN_POINT; ss->vcol_domain = AttrDomain::Point;
} }
} }
@ -1824,7 +1825,7 @@ static void sculpt_update_object(Depsgraph *depsgraph,
} }
if (is_paint_tool) { if (is_paint_tool) {
if (ss->vcol_domain == ATTR_DOMAIN_CORNER) { if (ss->vcol_domain == AttrDomain::Corner) {
/* Ensure pbvh nodes have loop indices; the sculpt undo system /* Ensure pbvh nodes have loop indices; the sculpt undo system
* needs them for color attributes. * needs them for color attributes.
*/ */
@ -1907,7 +1908,7 @@ void BKE_sculpt_color_layer_create_if_needed(Object *object)
char unique_name[MAX_CUSTOMDATA_LAYER_NAME]; char unique_name[MAX_CUSTOMDATA_LAYER_NAME];
BKE_id_attribute_calc_unique_name(&orig_me->id, "Color", unique_name); BKE_id_attribute_calc_unique_name(&orig_me->id, "Color", unique_name);
if (!orig_me->attributes_for_write().add( if (!orig_me->attributes_for_write().add(
unique_name, ATTR_DOMAIN_POINT, CD_PROP_COLOR, AttributeInitDefaultValue())) unique_name, AttrDomain::Point, CD_PROP_COLOR, AttributeInitDefaultValue()))
{ {
return; return;
} }
@ -1969,7 +1970,7 @@ void BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph,
} }
/* If vertices already have mask, copy into multires data. */ /* If vertices already have mask, copy into multires data. */
if (const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", ATTR_DOMAIN_POINT)) { if (const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", AttrDomain::Point)) {
const VArraySpan<float> mask_span(mask); const VArraySpan<float> mask_span(mask);
for (const int i : faces.index_range()) { for (const int i : faces.index_range()) {
const IndexRange face = faces[i]; const IndexRange face = faces[i];
@ -2003,7 +2004,7 @@ void BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph,
} }
/* Create vertex paint mask layer if there isn't one already. */ /* Create vertex paint mask layer if there isn't one already. */
if (attributes.add<float>(".sculpt_mask", ATTR_DOMAIN_POINT, AttributeInitDefaultValue())) { if (attributes.add<float>(".sculpt_mask", AttrDomain::Point, AttributeInitDefaultValue())) {
/* The evaluated mesh must be updated to contain the new data. */ /* The evaluated mesh must be updated to contain the new data. */
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY); DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
} }
@ -2087,7 +2088,7 @@ void BKE_sculpt_sync_face_visibility_to_grids(Mesh *mesh, SubdivCCG *subdiv_ccg)
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", AttrDomain::Face, false);
if (hide_poly.is_single() && !hide_poly.get_internal_single()) { if (hide_poly.is_single() && !hide_poly.get_internal_single()) {
BKE_subdiv_ccg_grid_hidden_free(*subdiv_ccg); BKE_subdiv_ccg_grid_hidden_free(*subdiv_ccg);
return; return;
@ -2273,17 +2274,17 @@ int BKE_sculptsession_vertex_count(const SculptSession *ss)
/** /**
* Returns pointer to a CustomData associated with a given domain, if * Returns pointer to a CustomData associated with a given domain, if
* one exists. If not nullptr is returned (this may happen with e.g. * one exists. If not nullptr is returned (this may happen with e.g.
* multires and #ATTR_DOMAIN_POINT). * multires and #AttrDomain::Point).
*/ */
static CustomData *sculpt_get_cdata(Object *ob, eAttrDomain domain) static CustomData *sculpt_get_cdata(Object *ob, AttrDomain domain)
{ {
SculptSession *ss = ob->sculpt; SculptSession *ss = ob->sculpt;
if (ss->bm) { if (ss->bm) {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return &ss->bm->vdata; return &ss->bm->vdata;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return &ss->bm->pdata; return &ss->bm->pdata;
default: default:
BLI_assert_unreachable(); BLI_assert_unreachable();
@ -2294,14 +2295,14 @@ static CustomData *sculpt_get_cdata(Object *ob, eAttrDomain domain)
Mesh *mesh = BKE_object_get_original_mesh(ob); Mesh *mesh = BKE_object_get_original_mesh(ob);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
/* Cannot get vertex domain for multires grids. */ /* Cannot get vertex domain for multires grids. */
if (ss->pbvh && BKE_pbvh_type(ss->pbvh) == PBVH_GRIDS) { if (ss->pbvh && BKE_pbvh_type(ss->pbvh) == PBVH_GRIDS) {
return nullptr; return nullptr;
} }
return &mesh->vert_data; return &mesh->vert_data;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return &mesh->face_data; return &mesh->face_data;
default: default:
BLI_assert_unreachable(); BLI_assert_unreachable();
@ -2310,15 +2311,15 @@ static CustomData *sculpt_get_cdata(Object *ob, eAttrDomain domain)
} }
} }
static int sculpt_attr_elem_count_get(Object *ob, eAttrDomain domain) static int sculpt_attr_elem_count_get(Object *ob, AttrDomain domain)
{ {
SculptSession *ss = ob->sculpt; SculptSession *ss = ob->sculpt;
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
return BKE_sculptsession_vertex_count(ss); return BKE_sculptsession_vertex_count(ss);
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
return ss->totfaces; return ss->totfaces;
break; break;
default: default:
@ -2329,7 +2330,7 @@ static int sculpt_attr_elem_count_get(Object *ob, eAttrDomain domain)
static bool sculpt_attribute_create(SculptSession *ss, static bool sculpt_attribute_create(SculptSession *ss,
Object *ob, Object *ob,
eAttrDomain domain, AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name, const char *name,
SculptAttribute *out, SculptAttribute *out,
@ -2389,10 +2390,10 @@ static bool sculpt_attribute_create(SculptSession *ss,
out->data_for_bmesh = true; out->data_for_bmesh = true;
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
cdata = &bm->vdata; cdata = &bm->vdata;
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
cdata = &bm->pdata; cdata = &bm->pdata;
break; break;
default: default:
@ -2418,10 +2419,10 @@ static bool sculpt_attribute_create(SculptSession *ss,
CustomData *cdata = nullptr; CustomData *cdata = nullptr;
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
cdata = &mesh->vert_data; cdata = &mesh->vert_data;
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
cdata = &mesh->face_data; cdata = &mesh->face_data;
break; break;
default: default:
@ -2504,7 +2505,7 @@ static bool sculpt_attr_update(Object *ob, SculptAttribute *attr)
} }
static SculptAttribute *sculpt_get_cached_layer(SculptSession *ss, static SculptAttribute *sculpt_get_cached_layer(SculptSession *ss,
eAttrDomain domain, AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name) const char *name)
{ {
@ -2537,7 +2538,7 @@ static SculptAttribute *sculpt_alloc_attr(SculptSession *ss)
} }
SculptAttribute *BKE_sculpt_attribute_get(Object *ob, SculptAttribute *BKE_sculpt_attribute_get(Object *ob,
eAttrDomain domain, AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name) const char *name)
{ {
@ -2563,10 +2564,10 @@ SculptAttribute *BKE_sculpt_attribute_get(Object *ob,
int totelem = 0; int totelem = 0;
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
totelem = BKE_sculptsession_vertex_count(ss); totelem = BKE_sculptsession_vertex_count(ss);
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
totelem = ss->totfaces; totelem = ss->totfaces;
break; break;
default: default:
@ -2594,7 +2595,7 @@ SculptAttribute *BKE_sculpt_attribute_get(Object *ob,
} }
static SculptAttribute *sculpt_attribute_ensure_ex(Object *ob, static SculptAttribute *sculpt_attribute_ensure_ex(Object *ob,
eAttrDomain domain, AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name, const char *name,
const SculptAttributeParams *params, const SculptAttributeParams *params,
@ -2626,7 +2627,7 @@ static SculptAttribute *sculpt_attribute_ensure_ex(Object *ob,
} }
SculptAttribute *BKE_sculpt_attribute_ensure(Object *ob, SculptAttribute *BKE_sculpt_attribute_ensure(Object *ob,
eAttrDomain domain, AttrDomain domain,
eCustomDataType proptype, eCustomDataType proptype,
const char *name, const char *name,
const SculptAttributeParams *params) const SculptAttributeParams *params)
@ -2658,7 +2659,7 @@ static void sculptsession_bmesh_add_layers(Object *ob)
ss->attrs.dyntopo_node_id_vertex = sculpt_attribute_ensure_ex( ss->attrs.dyntopo_node_id_vertex = sculpt_attribute_ensure_ex(
ob, ob,
ATTR_DOMAIN_POINT, AttrDomain::Point,
CD_PROP_INT32, CD_PROP_INT32,
SCULPT_ATTRIBUTE_NAME(dyntopo_node_id_vertex), SCULPT_ATTRIBUTE_NAME(dyntopo_node_id_vertex),
&params, &params,
@ -2667,7 +2668,7 @@ static void sculptsession_bmesh_add_layers(Object *ob)
ss->attrs.dyntopo_node_id_face = sculpt_attribute_ensure_ex( ss->attrs.dyntopo_node_id_face = sculpt_attribute_ensure_ex(
ob, ob,
ATTR_DOMAIN_FACE, AttrDomain::Face,
CD_PROP_INT32, CD_PROP_INT32,
SCULPT_ATTRIBUTE_NAME(dyntopo_node_id_face), SCULPT_ATTRIBUTE_NAME(dyntopo_node_id_face),
&params, &params,
@ -2730,7 +2731,7 @@ void BKE_sculpt_attribute_destroy_temporary_all(Object *ob)
bool BKE_sculpt_attribute_destroy(Object *ob, SculptAttribute *attr) bool BKE_sculpt_attribute_destroy(Object *ob, SculptAttribute *attr)
{ {
SculptSession *ss = ob->sculpt; SculptSession *ss = ob->sculpt;
eAttrDomain domain = attr->domain; AttrDomain domain = attr->domain;
BLI_assert(attr->used); BLI_assert(attr->used);
@ -2762,7 +2763,7 @@ bool BKE_sculpt_attribute_destroy(Object *ob, SculptAttribute *attr)
MEM_SAFE_FREE(attr->data); MEM_SAFE_FREE(attr->data);
} }
else if (ss->bm) { else if (ss->bm) {
CustomData *cdata = attr->domain == ATTR_DOMAIN_POINT ? &ss->bm->vdata : &ss->bm->pdata; CustomData *cdata = attr->domain == AttrDomain::Point ? &ss->bm->vdata : &ss->bm->pdata;
BM_data_layer_free_named(ss->bm, cdata, attr->name); BM_data_layer_free_named(ss->bm, cdata, attr->name);
} }
@ -2771,11 +2772,11 @@ bool BKE_sculpt_attribute_destroy(Object *ob, SculptAttribute *attr)
int totelem = 0; int totelem = 0;
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case AttrDomain::Point:
cdata = ss->bm ? &ss->bm->vdata : &mesh->vert_data; cdata = ss->bm ? &ss->bm->vdata : &mesh->vert_data;
totelem = ss->totvert; totelem = ss->totvert;
break; break;
case ATTR_DOMAIN_FACE: case AttrDomain::Face:
cdata = ss->bm ? &ss->bm->pdata : &mesh->face_data; cdata = ss->bm ? &ss->bm->pdata : &mesh->face_data;
totelem = ss->totfaces; totelem = ss->totfaces;
break; break;

23
source/blender/blenkernel/intern/pbvh.cc
View File

@ -53,6 +53,7 @@ using blender::float3;
using blender::MutableSpan; using blender::MutableSpan;
using blender::Span; using blender::Span;
using blender::Vector; using blender::Vector;
using blender::bke::AttrDomain;
#define LEAF_LIMIT 10000 #define LEAF_LIMIT 10000
@ -760,9 +761,9 @@ PBVH *build_mesh(Mesh *mesh)
if (corner_tris_num) { if (corner_tris_num) {
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", ATTR_DOMAIN_FACE); const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", AttrDomain::Face);
const VArraySpan material_index = *attributes.lookup<int>("material_index", ATTR_DOMAIN_FACE); const VArraySpan material_index = *attributes.lookup<int>("material_index", AttrDomain::Face);
const VArraySpan sharp_face = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_face = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
pbvh_build(pbvh.get(), pbvh_build(pbvh.get(),
corner_verts, corner_verts,
corner_tris, corner_tris,
@ -842,8 +843,8 @@ PBVH *build_grids(const CCGKey *key, Mesh *mesh, SubdivCCG *subdiv_ccg)
if (!grids.is_empty()) { if (!grids.is_empty()) {
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArraySpan material_index = *attributes.lookup<int>("material_index", ATTR_DOMAIN_FACE); const VArraySpan material_index = *attributes.lookup<int>("material_index", AttrDomain::Face);
const VArraySpan sharp_face = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_face = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
pbvh_build(pbvh.get(), pbvh_build(pbvh.get(),
{}, {},
{}, {},
@ -1335,7 +1336,7 @@ void node_update_mask_mesh(const Span<float> mask, PBVHNode &node)
static void update_mask_mesh(const Mesh &mesh, const Span<PBVHNode *> nodes) static void update_mask_mesh(const Mesh &mesh, const Span<PBVHNode *> nodes)
{ {
const AttributeAccessor attributes = mesh.attributes(); const AttributeAccessor attributes = mesh.attributes();
const VArraySpan<float> mask = *attributes.lookup<float>(".sculpt_mask", ATTR_DOMAIN_POINT); const VArraySpan<float> mask = *attributes.lookup<float>(".sculpt_mask", AttrDomain::Point);
if (mask.is_empty()) { if (mask.is_empty()) {
for (PBVHNode *node : nodes) { for (PBVHNode *node : nodes) {
node->flag &= ~PBVH_FullyMasked; node->flag &= ~PBVH_FullyMasked;
@ -1457,7 +1458,7 @@ void node_update_visibility_mesh(const Span<bool> hide_vert, PBVHNode &node)
static void update_visibility_faces(const Mesh &mesh, const Span<PBVHNode *> nodes) static void update_visibility_faces(const Mesh &mesh, const Span<PBVHNode *> nodes)
{ {
const AttributeAccessor attributes = mesh.attributes(); const AttributeAccessor attributes = mesh.attributes();
const VArraySpan<bool> hide_vert = *attributes.lookup<bool>(".hide_vert", ATTR_DOMAIN_POINT); const VArraySpan<bool> hide_vert = *attributes.lookup<bool>(".hide_vert", AttrDomain::Point);
if (hide_vert.is_empty()) { if (hide_vert.is_empty()) {
for (PBVHNode *node : nodes) { for (PBVHNode *node : nodes) {
node->flag &= ~PBVH_FullyHidden; node->flag &= ~PBVH_FullyHidden;
@ -1592,11 +1593,11 @@ IndexMask nodes_to_face_selection_grids(const SubdivCCG &subdiv_ccg,
/***************************** PBVH Access ***********************************/ /***************************** PBVH Access ***********************************/
bool BKE_pbvh_get_color_layer(Mesh *mesh, CustomDataLayer **r_layer, eAttrDomain *r_domain) bool BKE_pbvh_get_color_layer(Mesh *mesh, CustomDataLayer **r_layer, AttrDomain *r_domain)
{ {
*r_layer = BKE_id_attribute_search_for_write( *r_layer = BKE_id_attribute_search_for_write(
&mesh->id, mesh->active_color_attribute, CD_MASK_COLOR_ALL, ATTR_DOMAIN_MASK_COLOR); &mesh->id, mesh->active_color_attribute, CD_MASK_COLOR_ALL, ATTR_DOMAIN_MASK_COLOR);
*r_domain = *r_layer ? BKE_id_attribute_domain(&mesh->id, *r_layer) : ATTR_DOMAIN_POINT; *r_domain = *r_layer ? BKE_id_attribute_domain(&mesh->id, *r_layer) : AttrDomain::Point;
return *r_layer != nullptr; return *r_layer != nullptr;
} }
@ -2597,7 +2598,7 @@ static blender::draw::pbvh::PBVH_GPU_Args pbvh_draw_args_init(const Mesh &mesh,
args.face_normals = pbvh.face_normals; args.face_normals = pbvh.face_normals;
/* Retrieve data from the original mesh. Ideally that would be passed to this function to /* Retrieve data from the original mesh. Ideally that would be passed to this function to
* make it clearer when each is used. */ * make it clearer when each is used. */
args.hide_poly = *pbvh.mesh->attributes().lookup<bool>(".hide_poly", ATTR_DOMAIN_FACE); args.hide_poly = *pbvh.mesh->attributes().lookup<bool>(".hide_poly", AttrDomain::Face);
args.prim_indices = node.prim_indices; args.prim_indices = node.prim_indices;
args.tri_faces = mesh.corner_tri_faces(); args.tri_faces = mesh.corner_tri_faces();
@ -3164,7 +3165,7 @@ void BKE_pbvh_sync_visibility_from_verts(PBVH *pbvh, Mesh *mesh)
} }
else { else {
SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_span<bool>(
".hide_poly", ATTR_DOMAIN_FACE, AttributeInitConstruct()); ".hide_poly", AttrDomain::Face, AttributeInitConstruct());
hide_poly.span.fill(false); hide_poly.span.fill(false);
index_mask::masked_fill(hide_poly.span, true, hidden_faces); index_mask::masked_fill(hide_poly.span, true, hidden_faces);
hide_poly.finish(); hide_poly.finish();

15
source/blender/blenkernel/intern/pbvh_colors.cc
View File

@ -8,21 +8,20 @@
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
#include "BLI_math_color.h"
#include "BLI_math_vector.h"
#include "BLI_utildefines.h"
#include "BLI_bitmap.h" #include "BLI_bitmap.h"
#include "BLI_ghash.h" #include "BLI_ghash.h"
#include "BLI_index_range.hh" #include "BLI_index_range.hh"
#include "BLI_math_color.h"
#include "BLI_math_vector.h"
#include "BLI_rand.h" #include "BLI_rand.h"
#include "BLI_span.hh" #include "BLI_span.hh"
#include "BLI_task.h" #include "BLI_task.h"
#include "BLI_utildefines.h"
#include "DNA_mesh_types.h" #include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h" #include "DNA_meshdata_types.h"
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_ccg.h" #include "BKE_ccg.h"
#include "BKE_mesh.hh" #include "BKE_mesh.hh"
#include "BKE_mesh_mapping.hh" #include "BKE_mesh_mapping.hh"
@ -91,7 +90,7 @@ static void pbvh_vertex_color_get(const PBVH &pbvh, PBVHVertRef vertex, float r_
{ {
int index = vertex.i; int index = vertex.i;
if (pbvh.color_domain == ATTR_DOMAIN_CORNER) { if (pbvh.color_domain == AttrDomain::Corner) {
int count = 0; int count = 0;
zero_v4(r_color); zero_v4(r_color);
for (const int i_face : pbvh.pmap[index]) { for (const int i_face : pbvh.pmap[index]) {
@ -124,7 +123,7 @@ static void pbvh_vertex_color_set(PBVH &pbvh, PBVHVertRef vertex, const float co
{ {
int index = vertex.i; int index = vertex.i;
if (pbvh.color_domain == ATTR_DOMAIN_CORNER) { if (pbvh.color_domain == AttrDomain::Corner) {
for (const int i_face : pbvh.pmap[index]) { for (const int i_face : pbvh.pmap[index]) {
const IndexRange face = pbvh.faces[i_face]; const IndexRange face = pbvh.faces[i_face];
MutableSpan<T> colors{static_cast<T *>(pbvh.color_layer->data) + face.start(), face.size()}; MutableSpan<T> colors{static_cast<T *>(pbvh.color_layer->data) + face.start(), face.size()};
@ -192,7 +191,7 @@ void BKE_pbvh_store_colors_vertex(PBVH *pbvh,
const blender::Span<int> indices, const blender::Span<int> indices,
blender::MutableSpan<blender::float4> r_colors) blender::MutableSpan<blender::float4> r_colors)
{ {
if (pbvh->color_domain == ATTR_DOMAIN_POINT) { if (pbvh->color_domain == blender::bke::AttrDomain::Point) {
BKE_pbvh_store_colors(pbvh, indices, r_colors); BKE_pbvh_store_colors(pbvh, indices, r_colors);
} }
else { else {

2
source/blender/blenkernel/intern/pbvh_intern.hh
View File

@ -188,7 +188,7 @@ struct PBVH {
blender::GroupedSpan<int> pmap; blender::GroupedSpan<int> pmap;
CustomDataLayer *color_layer; CustomDataLayer *color_layer;
eAttrDomain color_domain; blender::bke::AttrDomain color_domain;
/* Initialize this to true, instead of waiting for a draw engine /* Initialize this to true, instead of waiting for a draw engine
* to set it. Prevents a crash in draw manager instancing code. * to set it. Prevents a crash in draw manager instancing code.

2
source/blender/blenkernel/intern/pbvh_pixels.cc
View File

@ -670,7 +670,7 @@ static bool update_pixels(PBVH *pbvh, Mesh *mesh, Image *image, ImageUser *image
} }
const AttributeAccessor attributes = mesh->attributes(); const AttributeAccessor attributes = mesh->attributes();
const VArraySpan uv_map = *attributes.lookup<float2>(active_uv_name, ATTR_DOMAIN_CORNER); const VArraySpan uv_map = *attributes.lookup<float2>(active_uv_name, AttrDomain::Corner);
uv_islands::MeshData mesh_data( uv_islands::MeshData mesh_data(
pbvh->corner_tris, mesh->corner_verts(), uv_map, pbvh->vert_positions); pbvh->corner_tris, mesh->corner_verts(), uv_map, pbvh->vert_positions);

4
source/blender/blenkernel/intern/pointcloud.cc
View File

@ -66,7 +66,7 @@ static void pointcloud_init_data(ID *id)
CustomData_reset(&pointcloud->pdata); CustomData_reset(&pointcloud->pdata);
pointcloud->attributes_for_write().add<float3>( pointcloud->attributes_for_write().add<float3>(
"position", ATTR_DOMAIN_POINT, blender::bke::AttributeInitConstruct()); "position", blender::bke::AttrDomain::Point, blender::bke::AttributeInitConstruct());
pointcloud->runtime = new blender::bke::PointCloudRuntime(); pointcloud->runtime = new blender::bke::PointCloudRuntime();
} }
@ -183,7 +183,7 @@ static void pointcloud_random(PointCloud *pointcloud)
blender::MutableSpan<float3> positions = pointcloud->positions_for_write(); blender::MutableSpan<float3> positions = pointcloud->positions_for_write();
blender::bke::SpanAttributeWriter<float> radii = blender::bke::SpanAttributeWriter<float> radii =
attributes.lookup_or_add_for_write_only_span<float>(POINTCLOUD_ATTR_RADIUS, attributes.lookup_or_add_for_write_only_span<float>(POINTCLOUD_ATTR_RADIUS,
ATTR_DOMAIN_POINT); blender::bke::AttrDomain::Point);
for (const int i : positions.index_range()) { for (const int i : positions.index_range()) {
positions[i] = float3(BLI_rng_get_float(rng), BLI_rng_get_float(rng), BLI_rng_get_float(rng)) * positions[i] = float3(BLI_rng_get_float(rng), BLI_rng_get_float(rng), BLI_rng_get_float(rng)) *

5
source/blender/blenkernel/intern/subdiv_converter_mesh.cc
View File

@ -383,6 +383,7 @@ static void init_user_data(OpenSubdiv_Converter *converter,
const Mesh *mesh) const Mesh *mesh)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
ConverterStorage *user_data = MEM_new<ConverterStorage>(__func__); ConverterStorage *user_data = MEM_new<ConverterStorage>(__func__);
user_data->settings = *settings; user_data->settings = *settings;
user_data->mesh = mesh; user_data->mesh = mesh;
@ -393,8 +394,8 @@ static void init_user_data(OpenSubdiv_Converter *converter,
user_data->corner_edges = mesh->corner_edges(); user_data->corner_edges = mesh->corner_edges();
if (settings->use_creases) { if (settings->use_creases) {
const bke::AttributeAccessor attributes = mesh->attributes(); const bke::AttributeAccessor attributes = mesh->attributes();
user_data->cd_vertex_crease = *attributes.lookup<float>("crease_vert", ATTR_DOMAIN_POINT); user_data->cd_vertex_crease = *attributes.lookup<float>("crease_vert", AttrDomain::Point);
user_data->cd_edge_crease = *attributes.lookup<float>("crease_edge", ATTR_DOMAIN_EDGE); user_data->cd_edge_crease = *attributes.lookup<float>("crease_edge", AttrDomain::Edge);
} }
user_data->loop_uv_indices = nullptr; user_data->loop_uv_indices = nullptr;
initialize_manifold_indices(user_data); initialize_manifold_indices(user_data);

21
source/blender/blenloader/intern/versioning_300.cc
View File

@ -695,6 +695,7 @@ static bool do_versions_sequencer_init_retiming_tool_data(Sequence *seq, void *u
static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *ntree) static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *ntree)
{ {
using namespace blender; using namespace blender;
using namespace blender::bke;
/* Otherwise `ntree->typeInfo` is null. */ /* Otherwise `ntree->typeInfo` is null. */
ntreeSetTypes(nullptr, ntree); ntreeSetTypes(nullptr, ntree);
LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) { LISTBASE_FOREACH_MUTABLE (bNode *, node, &ntree->nodes) {
@ -728,16 +729,18 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
} }
case GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST: { case GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST: {
/* These domains weren't supported by the index transfer mode, but were selectable. */ /* These domains weren't supported by the index transfer mode, but were selectable. */
const eAttrDomain domain = ELEM(storage->domain, ATTR_DOMAIN_INSTANCE, ATTR_DOMAIN_CURVE) ? const AttrDomain domain = ELEM(AttrDomain(storage->domain),
ATTR_DOMAIN_POINT : AttrDomain::Instance,
eAttrDomain(storage->domain); AttrDomain::Curve) ?
AttrDomain::Point :
AttrDomain(storage->domain);
/* Use a sample index node to retrieve the data with this node's index output. */ /* Use a sample index node to retrieve the data with this node's index output. */
bNode *sample_index = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_INDEX); bNode *sample_index = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_INDEX);
NodeGeometrySampleIndex *sample_storage = static_cast<NodeGeometrySampleIndex *>( NodeGeometrySampleIndex *sample_storage = static_cast<NodeGeometrySampleIndex *>(
sample_index->storage); sample_index->storage);
sample_storage->data_type = storage->data_type; sample_storage->data_type = storage->data_type;
sample_storage->domain = domain; sample_storage->domain = int8_t(domain);
sample_index->parent = node->parent; sample_index->parent = node->parent;
sample_index->locx = node->locx + 25.0f; sample_index->locx = node->locx + 25.0f;
sample_index->locy = node->locy; sample_index->locy = node->locy;
@ -752,7 +755,7 @@ static void version_geometry_nodes_replace_transfer_attribute_node(bNodeTree *nt
bNode *sample_nearest = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_NEAREST); bNode *sample_nearest = nodeAddStaticNode(nullptr, ntree, GEO_NODE_SAMPLE_NEAREST);
sample_nearest->parent = node->parent; sample_nearest->parent = node->parent;
sample_nearest->custom1 = storage->data_type; sample_nearest->custom1 = storage->data_type;
sample_nearest->custom2 = domain; sample_nearest->custom2 = int8_t(domain);
sample_nearest->locx = node->locx - 25.0f; sample_nearest->locx = node->locx - 25.0f;
sample_nearest->locy = node->locy; sample_nearest->locy = node->locy;
if (old_geometry_socket->link) { if (old_geometry_socket->link) {
@ -878,7 +881,7 @@ static void version_geometry_nodes_primitive_uv_maps(bNodeTree &ntree)
store_attribute_node->offsety = node->offsety; store_attribute_node->offsety = node->offsety;
NodeGeometryStoreNamedAttribute &storage = *static_cast<NodeGeometryStoreNamedAttribute *>( NodeGeometryStoreNamedAttribute &storage = *static_cast<NodeGeometryStoreNamedAttribute *>(
store_attribute_node->storage); store_attribute_node->storage);
storage.domain = ATTR_DOMAIN_CORNER; storage.domain = int8_t(blender::bke::AttrDomain::Corner);
/* Intentionally use 3D instead of 2D vectors, because 2D vectors did not exist in older /* Intentionally use 3D instead of 2D vectors, because 2D vectors did not exist in older
* releases and would make the file crash when trying to open it. */ * releases and would make the file crash when trying to open it. */
storage.data_type = CD_PROP_FLOAT3; storage.data_type = CD_PROP_FLOAT3;
@ -965,7 +968,8 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
bNode *capture_node = geometry_in_link->fromnode; bNode *capture_node = geometry_in_link->fromnode;
const NodeGeometryAttributeCapture &capture_storage = const NodeGeometryAttributeCapture &capture_storage =
*static_cast<const NodeGeometryAttributeCapture *>(capture_node->storage); *static_cast<const NodeGeometryAttributeCapture *>(capture_node->storage);
if (capture_storage.data_type != CD_PROP_BOOL || capture_storage.domain != ATTR_DOMAIN_FACE) if (capture_storage.data_type != CD_PROP_BOOL ||
bke::AttrDomain(capture_storage.domain) != bke::AttrDomain::Face)
{ {
return false; return false;
} }
@ -1005,7 +1009,8 @@ static void version_geometry_nodes_extrude_smooth_propagation(bNodeTree &ntree)
capture_node->locy = node->locy; capture_node->locy = node->locy;
new_nodes.append(capture_node); new_nodes.append(capture_node);
static_cast<NodeGeometryAttributeCapture *>(capture_node->storage)->data_type = CD_PROP_BOOL; static_cast<NodeGeometryAttributeCapture *>(capture_node->storage)->data_type = CD_PROP_BOOL;
static_cast<NodeGeometryAttributeCapture *>(capture_node->storage)->domain = ATTR_DOMAIN_FACE; static_cast<NodeGeometryAttributeCapture *>(capture_node->storage)->domain = int8_t(
bke::AttrDomain::Face);
bNode *is_smooth_node = nodeAddNode(nullptr, &ntree, "GeometryNodeInputShadeSmooth"); bNode *is_smooth_node = nodeAddNode(nullptr, &ntree, "GeometryNodeInputShadeSmooth");
is_smooth_node->parent = node->parent; is_smooth_node->parent = node->parent;

4
source/blender/blenloader/intern/versioning_400.cc
View File

@ -47,7 +47,7 @@
#include "BKE_anim_data.h" #include "BKE_anim_data.h"
#include "BKE_animsys.h" #include "BKE_animsys.h"
#include "BKE_armature.hh" #include "BKE_armature.hh"
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_collection.h" #include "BKE_collection.h"
#include "BKE_curve.hh" #include "BKE_curve.hh"
#include "BKE_effect.h" #include "BKE_effect.h"
@ -2159,7 +2159,7 @@ void blo_do_versions_400(FileData *fd, Library * /*lib*/, Main *bmain)
if (ntree->type == NTREE_GEOMETRY) { if (ntree->type == NTREE_GEOMETRY) {
LISTBASE_FOREACH (bNode *, node, &ntree->nodes) { LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
if (node->type == GEO_NODE_SET_SHADE_SMOOTH) { if (node->type == GEO_NODE_SET_SHADE_SMOOTH) {
node->custom1 = ATTR_DOMAIN_FACE; node->custom1 = int8_t(blender::bke::AttrDomain::Face);
} }
} }
} }

61
source/blender/bmesh/intern/bmesh_mesh_convert.cc
View File

@ -115,6 +115,7 @@ using blender::MutableSpan;
using blender::Span; using blender::Span;
using blender::StringRef; using blender::StringRef;
using blender::Vector; using blender::Vector;
using blender::bke::AttrDomain;
bool BM_attribute_stored_in_bmesh_builtin(const StringRef name) bool BM_attribute_stored_in_bmesh_builtin(const StringRef name)
{ {
@ -415,16 +416,16 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *mesh, const BMeshFromMeshParams *
-1; -1;
const bke::AttributeAccessor attributes = mesh->attributes(); const bke::AttributeAccessor attributes = mesh->attributes();
const VArraySpan select_vert = *attributes.lookup<bool>(".select_vert", ATTR_DOMAIN_POINT); const VArraySpan select_vert = *attributes.lookup<bool>(".select_vert", AttrDomain::Point);
const VArraySpan select_edge = *attributes.lookup<bool>(".select_edge", ATTR_DOMAIN_EDGE); const VArraySpan select_edge = *attributes.lookup<bool>(".select_edge", AttrDomain::Edge);
const VArraySpan select_poly = *attributes.lookup<bool>(".select_poly", ATTR_DOMAIN_FACE); const VArraySpan select_poly = *attributes.lookup<bool>(".select_poly", AttrDomain::Face);
const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", ATTR_DOMAIN_POINT); const VArraySpan hide_vert = *attributes.lookup<bool>(".hide_vert", AttrDomain::Point);
const VArraySpan hide_edge = *attributes.lookup<bool>(".hide_edge", ATTR_DOMAIN_EDGE); const VArraySpan hide_edge = *attributes.lookup<bool>(".hide_edge", AttrDomain::Edge);
const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", ATTR_DOMAIN_FACE); const VArraySpan hide_poly = *attributes.lookup<bool>(".hide_poly", AttrDomain::Face);
const VArraySpan material_indices = *attributes.lookup<int>("material_index", ATTR_DOMAIN_FACE); const VArraySpan material_indices = *attributes.lookup<int>("material_index", AttrDomain::Face);
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", AttrDomain::Face);
const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", ATTR_DOMAIN_EDGE); const VArraySpan sharp_edges = *attributes.lookup<bool>("sharp_edge", AttrDomain::Edge);
const VArraySpan uv_seams = *attributes.lookup<bool>(".uv_seam", ATTR_DOMAIN_EDGE); const VArraySpan uv_seams = *attributes.lookup<bool>(".uv_seam", AttrDomain::Edge);
const Span<float3> positions = mesh->vert_positions(); const Span<float3> positions = mesh->vert_positions();
Array<BMVert *> vtable(mesh->verts_num); Array<BMVert *> vtable(mesh->verts_num);
@ -1486,35 +1487,35 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *mesh, const BMeshToMeshParam
bke::SpanAttributeWriter<bool> sharp_face; bke::SpanAttributeWriter<bool> sharp_face;
bke::SpanAttributeWriter<int> material_index; bke::SpanAttributeWriter<int> material_index;
if (need_select_vert) { if (need_select_vert) {
select_vert = attrs.lookup_or_add_for_write_only_span<bool>(".select_vert", ATTR_DOMAIN_POINT); select_vert = attrs.lookup_or_add_for_write_only_span<bool>(".select_vert", AttrDomain::Point);
} }
if (need_hide_vert) { if (need_hide_vert) {
hide_vert = attrs.lookup_or_add_for_write_only_span<bool>(".hide_vert", ATTR_DOMAIN_POINT); hide_vert = attrs.lookup_or_add_for_write_only_span<bool>(".hide_vert", AttrDomain::Point);
} }
if (need_select_edge) { if (need_select_edge) {
select_edge = attrs.lookup_or_add_for_write_only_span<bool>(".select_edge", ATTR_DOMAIN_EDGE); select_edge = attrs.lookup_or_add_for_write_only_span<bool>(".select_edge", AttrDomain::Edge);
} }
if (need_sharp_edge) { if (need_sharp_edge) {
sharp_edge = attrs.lookup_or_add_for_write_only_span<bool>("sharp_edge", ATTR_DOMAIN_EDGE); sharp_edge = attrs.lookup_or_add_for_write_only_span<bool>("sharp_edge", AttrDomain::Edge);
} }
if (need_uv_seams) { if (need_uv_seams) {
uv_seams = attrs.lookup_or_add_for_write_only_span<bool>(".uv_seam", ATTR_DOMAIN_EDGE); uv_seams = attrs.lookup_or_add_for_write_only_span<bool>(".uv_seam", AttrDomain::Edge);
} }
if (need_hide_edge) { if (need_hide_edge) {
hide_edge = attrs.lookup_or_add_for_write_only_span<bool>(".hide_edge", ATTR_DOMAIN_EDGE); hide_edge = attrs.lookup_or_add_for_write_only_span<bool>(".hide_edge", AttrDomain::Edge);
} }
if (need_select_poly) { if (need_select_poly) {
select_poly = attrs.lookup_or_add_for_write_only_span<bool>(".select_poly", ATTR_DOMAIN_FACE); select_poly = attrs.lookup_or_add_for_write_only_span<bool>(".select_poly", AttrDomain::Face);
} }
if (need_hide_poly) { if (need_hide_poly) {
hide_poly = attrs.lookup_or_add_for_write_only_span<bool>(".hide_poly", ATTR_DOMAIN_FACE); hide_poly = attrs.lookup_or_add_for_write_only_span<bool>(".hide_poly", AttrDomain::Face);
} }
if (need_sharp_face) { if (need_sharp_face) {
sharp_face = attrs.lookup_or_add_for_write_only_span<bool>("sharp_face", ATTR_DOMAIN_FACE); sharp_face = attrs.lookup_or_add_for_write_only_span<bool>("sharp_face", AttrDomain::Face);
} }
if (need_material_index) { if (need_material_index) {
material_index = attrs.lookup_or_add_for_write_only_span<int>("material_index", material_index = attrs.lookup_or_add_for_write_only_span<int>("material_index",
ATTR_DOMAIN_FACE); AttrDomain::Face);
} }
/* Loop over all elements in parallel, copying attributes and building the Mesh topology. */ /* Loop over all elements in parallel, copying attributes and building the Mesh topology. */
@ -1709,35 +1710,35 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *mesh, const CustomData_MeshMasks
bke::SpanAttributeWriter<bool> sharp_face; bke::SpanAttributeWriter<bool> sharp_face;
bke::SpanAttributeWriter<int> material_index; bke::SpanAttributeWriter<int> material_index;
if (need_select_vert) { if (need_select_vert) {
select_vert = attrs.lookup_or_add_for_write_only_span<bool>(".select_vert", ATTR_DOMAIN_POINT); select_vert = attrs.lookup_or_add_for_write_only_span<bool>(".select_vert", AttrDomain::Point);
} }
if (need_hide_vert) { if (need_hide_vert) {
hide_vert = attrs.lookup_or_add_for_write_only_span<bool>(".hide_vert", ATTR_DOMAIN_POINT); hide_vert = attrs.lookup_or_add_for_write_only_span<bool>(".hide_vert", AttrDomain::Point);
} }
if (need_select_edge) { if (need_select_edge) {
select_edge = attrs.lookup_or_add_for_write_only_span<bool>(".select_edge", ATTR_DOMAIN_EDGE); select_edge = attrs.lookup_or_add_for_write_only_span<bool>(".select_edge", AttrDomain::Edge);
} }
if (need_sharp_edge) { if (need_sharp_edge) {
sharp_edge = attrs.lookup_or_add_for_write_only_span<bool>("sharp_edge", ATTR_DOMAIN_EDGE); sharp_edge = attrs.lookup_or_add_for_write_only_span<bool>("sharp_edge", AttrDomain::Edge);
} }
if (need_uv_seams) { if (need_uv_seams) {
uv_seams = attrs.lookup_or_add_for_write_only_span<bool>(".uv_seam", ATTR_DOMAIN_EDGE); uv_seams = attrs.lookup_or_add_for_write_only_span<bool>(".uv_seam", AttrDomain::Edge);
} }
if (need_hide_edge) { if (need_hide_edge) {
hide_edge = attrs.lookup_or_add_for_write_only_span<bool>(".hide_edge", ATTR_DOMAIN_EDGE); hide_edge = attrs.lookup_or_add_for_write_only_span<bool>(".hide_edge", AttrDomain::Edge);
} }
if (need_select_poly) { if (need_select_poly) {
select_poly = attrs.lookup_or_add_for_write_only_span<bool>(".select_poly", ATTR_DOMAIN_FACE); select_poly = attrs.lookup_or_add_for_write_only_span<bool>(".select_poly", AttrDomain::Face);
} }
if (need_hide_poly) { if (need_hide_poly) {
hide_poly = attrs.lookup_or_add_for_write_only_span<bool>(".hide_poly", ATTR_DOMAIN_FACE); hide_poly = attrs.lookup_or_add_for_write_only_span<bool>(".hide_poly", AttrDomain::Face);
} }
if (need_sharp_face) { if (need_sharp_face) {
sharp_face = attrs.lookup_or_add_for_write_only_span<bool>("sharp_face", ATTR_DOMAIN_FACE); sharp_face = attrs.lookup_or_add_for_write_only_span<bool>("sharp_face", AttrDomain::Face);
} }
if (need_material_index) { if (need_material_index) {
material_index = attrs.lookup_or_add_for_write_only_span<int>("material_index", material_index = attrs.lookup_or_add_for_write_only_span<int>("material_index",
ATTR_DOMAIN_FACE); AttrDomain::Face);
} }
/* Loop over all elements in parallel, copying attributes and building the Mesh topology. */ /* Loop over all elements in parallel, copying attributes and building the Mesh topology. */

4
source/blender/draw/DRW_pbvh.hh
View File

@ -33,8 +33,8 @@ class GenericRequest {
public: public:
std::string name; std::string name;
eCustomDataType type; eCustomDataType type;
eAttrDomain domain; bke::AttrDomain domain;
GenericRequest(const StringRef name, const eCustomDataType type, const eAttrDomain domain) GenericRequest(const StringRef name, const eCustomDataType type, const bke::AttrDomain domain)
: name(name), type(type), domain(domain) : name(name), type(type), domain(domain)
{ {
} }

6
source/blender/draw/engines/overlay/overlay_edit_curves.cc
View File

@ -6,7 +6,7 @@
* \ingroup draw_engine * \ingroup draw_engine
*/ */
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_curves.h" #include "BKE_curves.h"
#include "DRW_render.h" #include "DRW_render.h"
@ -21,12 +21,14 @@
void OVERLAY_edit_curves_init(OVERLAY_Data *vedata) void OVERLAY_edit_curves_init(OVERLAY_Data *vedata)
{ {
using namespace blender;
OVERLAY_PrivateData *pd = vedata->stl->pd; OVERLAY_PrivateData *pd = vedata->stl->pd;
const DRWContextState *draw_ctx = DRW_context_state_get(); const DRWContextState *draw_ctx = DRW_context_state_get();
const Object *obact_orig = DEG_get_original_object(draw_ctx->obact); const Object *obact_orig = DEG_get_original_object(draw_ctx->obact);
const Curves &curves_id = *static_cast<const Curves *>(obact_orig->data); const Curves &curves_id = *static_cast<const Curves *>(obact_orig->data);
pd->edit_curves.do_points = curves_id.selection_domain == ATTR_DOMAIN_POINT; pd->edit_curves.do_points = bke::AttrDomain(curves_id.selection_domain) ==
bke::AttrDomain::Point;
pd->edit_curves.do_zbufclip = XRAY_FLAG_ENABLED(draw_ctx->v3d); pd->edit_curves.do_zbufclip = XRAY_FLAG_ENABLED(draw_ctx->v3d);
/* Create view with depth offset. */ /* Create view with depth offset. */

5
source/blender/draw/engines/overlay/overlay_grease_pencil.cc
View File

@ -16,10 +16,11 @@
void OVERLAY_edit_grease_pencil_cache_init(OVERLAY_Data *vedata) void OVERLAY_edit_grease_pencil_cache_init(OVERLAY_Data *vedata)
{ {
using namespace blender;
OVERLAY_PassList *psl = vedata->psl; OVERLAY_PassList *psl = vedata->psl;
OVERLAY_PrivateData *pd = vedata->stl->pd; OVERLAY_PrivateData *pd = vedata->stl->pd;
const DRWContextState *draw_ctx = DRW_context_state_get(); const DRWContextState *draw_ctx = DRW_context_state_get();
const eAttrDomain selection_domain = ED_grease_pencil_selection_domain_get( const bke::AttrDomain selection_domain = ED_grease_pencil_selection_domain_get(
draw_ctx->scene->toolsettings); draw_ctx->scene->toolsettings);
const View3D *v3d = draw_ctx->v3d; const View3D *v3d = draw_ctx->v3d;
@ -30,7 +31,7 @@ void OVERLAY_edit_grease_pencil_cache_init(OVERLAY_Data *vedata)
DRW_STATE_BLEND_ALPHA; DRW_STATE_BLEND_ALPHA;
DRW_PASS_CREATE(psl->edit_grease_pencil_ps, (state | pd->clipping_state)); DRW_PASS_CREATE(psl->edit_grease_pencil_ps, (state | pd->clipping_state));
const bool show_points = selection_domain == ATTR_DOMAIN_POINT; const bool show_points = selection_domain == bke::AttrDomain::Point;
const bool show_lines = (v3d->gp_flag & V3D_GP_SHOW_EDIT_LINES) != 0; const bool show_lines = (v3d->gp_flag & V3D_GP_SHOW_EDIT_LINES) != 0;
if (show_lines) { if (show_lines) {

2
source/blender/draw/engines/overlay/overlay_sculpt_curves.cc
View File

@ -54,7 +54,7 @@ static bool everything_selected(const Curves &curves_id)
using namespace blender; using namespace blender;
const bke::CurvesGeometry &curves = curves_id.geometry.wrap(); const bke::CurvesGeometry &curves = curves_id.geometry.wrap();
const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>( const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
return selection.is_single() && selection.get_internal_single(); return selection.is_single() && selection.get_internal_single();
} }

2
source/blender/draw/intern/draw_attributes.cc
View File

@ -64,7 +64,7 @@ void drw_attributes_add_request(DRW_Attributes *attrs,
const char *name, const char *name,
const eCustomDataType type, const eCustomDataType type,
const int layer_index, const int layer_index,
const eAttrDomain domain) const blender::bke::AttrDomain domain)
{ {
if (attrs->num_requests >= GPU_MAX_ATTR || if (attrs->num_requests >= GPU_MAX_ATTR ||
drw_attributes_has_request(attrs, {type, layer_index, domain})) drw_attributes_has_request(attrs, {type, layer_index, domain}))

6
source/blender/draw/intern/draw_attributes.hh
View File

@ -14,7 +14,7 @@
#include "DNA_customdata_types.h" #include "DNA_customdata_types.h"
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BLI_sys_types.h" #include "BLI_sys_types.h"
@ -23,7 +23,7 @@
struct DRW_AttributeRequest { struct DRW_AttributeRequest {
eCustomDataType cd_type; eCustomDataType cd_type;
int layer_index; int layer_index;
eAttrDomain domain; blender::bke::AttrDomain domain;
char attribute_name[64]; char attribute_name[64];
}; };
@ -62,7 +62,7 @@ void drw_attributes_add_request(DRW_Attributes *attrs,
const char *name, const char *name,
eCustomDataType data_type, eCustomDataType data_type,
int layer_index, int layer_index,
eAttrDomain domain); blender::bke::AttrDomain domain);
bool drw_custom_data_match_attribute(const CustomData *custom_data, bool drw_custom_data_match_attribute(const CustomData *custom_data,
const char *name, const char *name,

16
source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
View File

@ -683,17 +683,17 @@ MeshRenderData *mesh_render_data_create(Object *object,
const bke::AttributeAccessor attributes = mr->mesh->attributes(); const bke::AttributeAccessor attributes = mr->mesh->attributes();
mr->material_indices = *attributes.lookup<int>("material_index", ATTR_DOMAIN_FACE); mr->material_indices = *attributes.lookup<int>("material_index", bke::AttrDomain::Face);
mr->hide_vert = *attributes.lookup<bool>(".hide_vert", ATTR_DOMAIN_POINT); mr->hide_vert = *attributes.lookup<bool>(".hide_vert", bke::AttrDomain::Point);
mr->hide_edge = *attributes.lookup<bool>(".hide_edge", ATTR_DOMAIN_EDGE); mr->hide_edge = *attributes.lookup<bool>(".hide_edge", bke::AttrDomain::Edge);
mr->hide_poly = *attributes.lookup<bool>(".hide_poly", ATTR_DOMAIN_FACE); mr->hide_poly = *attributes.lookup<bool>(".hide_poly", bke::AttrDomain::Face);
mr->select_vert = *attributes.lookup<bool>(".select_vert", ATTR_DOMAIN_POINT); mr->select_vert = *attributes.lookup<bool>(".select_vert", bke::AttrDomain::Point);
mr->select_edge = *attributes.lookup<bool>(".select_edge", ATTR_DOMAIN_EDGE); mr->select_edge = *attributes.lookup<bool>(".select_edge", bke::AttrDomain::Edge);
mr->select_poly = *attributes.lookup<bool>(".select_poly", ATTR_DOMAIN_FACE); mr->select_poly = *attributes.lookup<bool>(".select_poly", bke::AttrDomain::Face);
mr->sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); mr->sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
} }
else { else {
/* #BMesh */ /* #BMesh */

2
source/blender/draw/intern/draw_cache_impl_curve.cc
View File

@ -500,7 +500,7 @@ static void curve_create_attribute(CurveRenderData *rdata, GPUVertBuf *vbo_attr)
const bke::CurvesGeometry &curves = rdata->curve_eval->geometry.wrap(); const bke::CurvesGeometry &curves = rdata->curve_eval->geometry.wrap();
curves.ensure_can_interpolate_to_evaluated(); curves.ensure_can_interpolate_to_evaluated();
const VArraySpan colors = *curves.attributes().lookup<ColorGeometry4f>(".viewer", const VArraySpan colors = *curves.attributes().lookup<ColorGeometry4f>(".viewer",
ATTR_DOMAIN_POINT); bke::AttrDomain::Point);
ColorGeometry4f *vbo_data = static_cast<ColorGeometry4f *>(GPU_vertbuf_get_data(vbo_attr)); ColorGeometry4f *vbo_data = static_cast<ColorGeometry4f *>(GPU_vertbuf_get_data(vbo_attr));
curves.interpolate_to_evaluated(colors, MutableSpan<ColorGeometry4f>{vbo_data, vert_len}); curves.interpolate_to_evaluated(colors, MutableSpan<ColorGeometry4f>{vbo_data, vert_len});
} }

27
source/blender/draw/intern/draw_cache_impl_curves.cc
View File

@ -271,7 +271,7 @@ static void curves_batch_cache_ensure_edit_points_selection(const bke::CurvesGeo
curves.points_num()); curves.points_num());
const VArray<float> attribute = *curves.attributes().lookup_or_default<float>( const VArray<float> attribute = *curves.attributes().lookup_or_default<float>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
attribute.materialize(data); attribute.materialize(data);
} }
@ -335,8 +335,8 @@ static void curves_batch_ensure_attribute(const Curves &curves,
GPUVertBuf *attr_vbo = cache.proc_attributes_buf[index]; GPUVertBuf *attr_vbo = cache.proc_attributes_buf[index];
GPU_vertbuf_data_alloc(attr_vbo, GPU_vertbuf_data_alloc(attr_vbo,
request.domain == ATTR_DOMAIN_POINT ? curves.geometry.point_num : request.domain == bke::AttrDomain::Point ? curves.geometry.point_num :
curves.geometry.curve_num); curves.geometry.curve_num);
const bke::AttributeAccessor attributes = curves.geometry.wrap().attributes(); const bke::AttributeAccessor attributes = curves.geometry.wrap().attributes();
@ -359,7 +359,7 @@ static void curves_batch_ensure_attribute(const Curves &curves,
GPU_VERTBUF_DISCARD_SAFE(cache.final[subdiv].attributes_buf[index]); GPU_VERTBUF_DISCARD_SAFE(cache.final[subdiv].attributes_buf[index]);
/* Ensure final data for points. */ /* Ensure final data for points. */
if (request.domain == ATTR_DOMAIN_POINT) { if (request.domain == bke::AttrDomain::Point) {
curves_batch_cache_ensure_procedural_final_attr(cache, &format, subdiv, index, sampler_name); curves_batch_cache_ensure_procedural_final_attr(cache, &format, subdiv, index, sampler_name);
} }
} }
@ -537,12 +537,12 @@ static bool curves_ensure_attributes(const Curves &curves,
int layer_index; int layer_index;
eCustomDataType type; eCustomDataType type;
eAttrDomain domain; bke::AttrDomain domain;
if (drw_custom_data_match_attribute(cd_curve, name, &layer_index, &type)) { if (drw_custom_data_match_attribute(cd_curve, name, &layer_index, &type)) {
domain = ATTR_DOMAIN_CURVE; domain = bke::AttrDomain::Curve;
} }
else if (drw_custom_data_match_attribute(cd_point, name, &layer_index, &type)) { else if (drw_custom_data_match_attribute(cd_point, name, &layer_index, &type)) {
domain = ATTR_DOMAIN_POINT; domain = bke::AttrDomain::Point;
} }
else { else {
continue; continue;
@ -570,7 +570,7 @@ static bool curves_ensure_attributes(const Curves &curves,
continue; continue;
} }
if (request.domain == ATTR_DOMAIN_POINT) { if (request.domain == bke::AttrDomain::Point) {
need_tf_update = true; need_tf_update = true;
} }
@ -596,10 +596,10 @@ static void request_attribute(Curves &curves, const char *name)
if (!meta_data) { if (!meta_data) {
return; return;
} }
const eAttrDomain domain = meta_data->domain; const bke::AttrDomain domain = meta_data->domain;
const eCustomDataType type = meta_data->data_type; const eCustomDataType type = meta_data->data_type;
const CustomData &custom_data = domain == ATTR_DOMAIN_POINT ? curves.geometry.point_data : const CustomData &custom_data = domain == bke::AttrDomain::Point ? curves.geometry.point_data :
curves.geometry.curve_data; curves.geometry.curve_data;
drw_attributes_add_request( drw_attributes_add_request(
&attributes, name, type, CustomData_get_named_layer(&custom_data, type, name), domain); &attributes, name, type, CustomData_get_named_layer(&custom_data, type, name), domain);
@ -745,6 +745,7 @@ GPUVertBuf **DRW_curves_texture_for_evaluated_attribute(Curves *curves,
const char *name, const char *name,
bool *r_is_point_domain) bool *r_is_point_domain)
{ {
using namespace blender;
using namespace blender::draw; using namespace blender::draw;
CurvesBatchCache &cache = curves_batch_cache_get(*curves); CurvesBatchCache &cache = curves_batch_cache_get(*curves);
const DRWContextState *draw_ctx = DRW_context_state_get(); const DRWContextState *draw_ctx = DRW_context_state_get();
@ -766,10 +767,10 @@ GPUVertBuf **DRW_curves_texture_for_evaluated_attribute(Curves *curves,
return nullptr; return nullptr;
} }
switch (final_cache.attr_used.requests[request_i].domain) { switch (final_cache.attr_used.requests[request_i].domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
*r_is_point_domain = true; *r_is_point_domain = true;
return &final_cache.attributes_buf[request_i]; return &final_cache.attributes_buf[request_i];
case ATTR_DOMAIN_CURVE: case bke::AttrDomain::Curve:
*r_is_point_domain = false; *r_is_point_domain = false;
return &cache.curves_cache.proc_attributes_buf[request_i]; return &cache.curves_cache.proc_attributes_buf[request_i];
default: default:

16
source/blender/draw/intern/draw_cache_impl_grease_pencil.cc
View File

@ -258,7 +258,7 @@ static void grease_pencil_edit_batch_ensure(Object &object,
/* Assumes that if the ".selection" attribute does not exist, all points are selected. */ /* Assumes that if the ".selection" attribute does not exist, all points are selected. */
const VArray<float> selection_float = *attributes.lookup_or_default<float>( const VArray<float> selection_float = *attributes.lookup_or_default<float>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
edit_points.slice(drawing_start_offset, curves.points_num()).copy_from(curves.positions()); edit_points.slice(drawing_start_offset, curves.points_num()).copy_from(curves.positions());
MutableSpan<float> selection_slice = edit_points_selection.slice(drawing_start_offset, MutableSpan<float> selection_slice = edit_points_selection.slice(drawing_start_offset,
@ -289,7 +289,7 @@ static void grease_pencil_edit_batch_ensure(Object &object,
} }
const VArray<bool> selection = *attributes.lookup_or_default<bool>( const VArray<bool> selection = *attributes.lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
editable_strokes.foreach_index([&](const int curve_i) { editable_strokes.foreach_index([&](const int curve_i) {
const IndexRange points = points_by_curve[curve_i]; const IndexRange points = points_by_curve[curve_i];
@ -340,7 +340,7 @@ static void grease_pencil_edit_batch_ensure(Object &object,
/* Assumes that if the ".selection" attribute does not exist, all points are selected. */ /* Assumes that if the ".selection" attribute does not exist, all points are selected. */
const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>( const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
/* Fill point indices. */ /* Fill point indices. */
if (!layer->is_locked()) { if (!layer->is_locked()) {
@ -486,16 +486,16 @@ static void grease_pencil_geom_batch_ensure(Object &object,
const VArray<float> radii = info.drawing.radii(); const VArray<float> radii = info.drawing.radii();
const VArray<float> opacities = info.drawing.opacities(); const VArray<float> opacities = info.drawing.opacities();
const VArray<ColorGeometry4f> vertex_colors = *attributes.lookup_or_default<ColorGeometry4f>( const VArray<ColorGeometry4f> vertex_colors = *attributes.lookup_or_default<ColorGeometry4f>(
"vertex_color", ATTR_DOMAIN_POINT, ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f)); "vertex_color", bke::AttrDomain::Point, ColorGeometry4f(0.0f, 0.0f, 0.0f, 0.0f));
/* Assumes that if the ".selection" attribute does not exist, all points are selected. */ /* Assumes that if the ".selection" attribute does not exist, all points are selected. */
const VArray<float> selection_float = *attributes.lookup_or_default<float>( const VArray<float> selection_float = *attributes.lookup_or_default<float>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
const VArray<int8_t> start_caps = *attributes.lookup_or_default<int8_t>( const VArray<int8_t> start_caps = *attributes.lookup_or_default<int8_t>(
"start_cap", ATTR_DOMAIN_CURVE, 0); "start_cap", bke::AttrDomain::Curve, 0);
const VArray<int8_t> end_caps = *attributes.lookup_or_default<int8_t>( const VArray<int8_t> end_caps = *attributes.lookup_or_default<int8_t>(
"end_cap", ATTR_DOMAIN_CURVE, 0); "end_cap", bke::AttrDomain::Curve, 0);
const VArray<int> materials = *attributes.lookup_or_default<int>( const VArray<int> materials = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_CURVE, 0); "material_index", bke::AttrDomain::Curve, 0);
const Span<uint3> triangles = info.drawing.triangles(); const Span<uint3> triangles = info.drawing.triangles();
const Span<int> verts_start_offsets = verts_start_offsets_per_visible_drawing[drawing_i]; const Span<int> verts_start_offsets = verts_start_offsets_per_visible_drawing[drawing_i];
const Span<int> tris_start_offsets = tris_start_offsets_per_visible_drawing[drawing_i]; const Span<int> tris_start_offsets = tris_start_offsets_per_visible_drawing[drawing_i];

18
source/blender/draw/intern/draw_cache_impl_mesh.cc
View File

@ -30,7 +30,7 @@
#include "DNA_object_types.h" #include "DNA_object_types.h"
#include "DNA_scene_types.h" #include "DNA_scene_types.h"
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_customdata.hh" #include "BKE_customdata.hh"
#include "BKE_deform.h" #include "BKE_deform.h"
#include "BKE_editmesh.hh" #include "BKE_editmesh.hh"
@ -277,6 +277,7 @@ static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Object *object,
int gpumat_array_len, int gpumat_array_len,
DRW_Attributes *attributes) DRW_Attributes *attributes)
{ {
using namespace blender;
const Mesh *me_final = editmesh_final_or_this(object, mesh); const Mesh *me_final = editmesh_final_or_this(object, mesh);
const CustomData *cd_ldata = mesh_cd_ldata_get_from_mesh(me_final); const CustomData *cd_ldata = mesh_cd_ldata_get_from_mesh(me_final);
const CustomData *cd_pdata = mesh_cd_pdata_get_from_mesh(me_final); const CustomData *cd_pdata = mesh_cd_pdata_get_from_mesh(me_final);
@ -301,7 +302,7 @@ static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Object *object,
const char *name = gpu_attr->name; const char *name = gpu_attr->name;
eCustomDataType type = static_cast<eCustomDataType>(gpu_attr->type); eCustomDataType type = static_cast<eCustomDataType>(gpu_attr->type);
int layer = -1; int layer = -1;
std::optional<eAttrDomain> domain; std::optional<bke::AttrDomain> domain;
if (gpu_attr->is_default_color) { if (gpu_attr->is_default_color) {
name = default_color_name.c_str(); name = default_color_name.c_str();
@ -326,16 +327,16 @@ static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Object *object,
/* Try to match a generic attribute, we use the first attribute domain with a /* Try to match a generic attribute, we use the first attribute domain with a
* matching name. */ * matching name. */
if (drw_custom_data_match_attribute(cd_vdata, name, &layer, &type)) { if (drw_custom_data_match_attribute(cd_vdata, name, &layer, &type)) {
domain = ATTR_DOMAIN_POINT; domain = bke::AttrDomain::Point;
} }
else if (drw_custom_data_match_attribute(cd_ldata, name, &layer, &type)) { else if (drw_custom_data_match_attribute(cd_ldata, name, &layer, &type)) {
domain = ATTR_DOMAIN_CORNER; domain = bke::AttrDomain::Corner;
} }
else if (drw_custom_data_match_attribute(cd_pdata, name, &layer, &type)) { else if (drw_custom_data_match_attribute(cd_pdata, name, &layer, &type)) {
domain = ATTR_DOMAIN_FACE; domain = bke::AttrDomain::Face;
} }
else if (drw_custom_data_match_attribute(cd_edata, name, &layer, &type)) { else if (drw_custom_data_match_attribute(cd_edata, name, &layer, &type)) {
domain = ATTR_DOMAIN_EDGE; domain = bke::AttrDomain::Edge;
} }
else { else {
layer = -1; layer = -1;
@ -867,6 +868,7 @@ static void request_active_and_default_color_attributes(const Object &object,
const Mesh &mesh, const Mesh &mesh,
DRW_Attributes &attributes) DRW_Attributes &attributes)
{ {
using namespace blender;
const Mesh *me_final = editmesh_final_or_this(&object, &mesh); const Mesh *me_final = editmesh_final_or_this(&object, &mesh);
const CustomData *cd_vdata = mesh_cd_vdata_get_from_mesh(me_final); const CustomData *cd_vdata = mesh_cd_vdata_get_from_mesh(me_final);
const CustomData *cd_ldata = mesh_cd_ldata_get_from_mesh(me_final); const CustomData *cd_ldata = mesh_cd_ldata_get_from_mesh(me_final);
@ -876,10 +878,10 @@ static void request_active_and_default_color_attributes(const Object &object,
int layer_index; int layer_index;
eCustomDataType type; eCustomDataType type;
if (drw_custom_data_match_attribute(cd_vdata, name, &layer_index, &type)) { if (drw_custom_data_match_attribute(cd_vdata, name, &layer_index, &type)) {
drw_attributes_add_request(&attributes, name, type, layer_index, ATTR_DOMAIN_POINT); drw_attributes_add_request(&attributes, name, type, layer_index, bke::AttrDomain::Point);
} }
else if (drw_custom_data_match_attribute(cd_ldata, name, &layer_index, &type)) { else if (drw_custom_data_match_attribute(cd_ldata, name, &layer_index, &type)) {
drw_attributes_add_request(&attributes, name, type, layer_index, ATTR_DOMAIN_CORNER); drw_attributes_add_request(&attributes, name, type, layer_index, bke::AttrDomain::Corner);
} }
} }
}; };

6
source/blender/draw/intern/draw_cache_impl_pointcloud.cc
View File

@ -337,6 +337,7 @@ GPUBatch **pointcloud_surface_shaded_get(PointCloud *pointcloud,
GPUMaterial **gpu_materials, GPUMaterial **gpu_materials,
int mat_len) int mat_len)
{ {
using namespace blender;
PointCloudBatchCache *cache = pointcloud_batch_cache_get(*pointcloud); PointCloudBatchCache *cache = pointcloud_batch_cache_get(*pointcloud);
DRW_Attributes attrs_needed; DRW_Attributes attrs_needed;
drw_attributes_clear(&attrs_needed); drw_attributes_clear(&attrs_needed);
@ -348,7 +349,7 @@ GPUBatch **pointcloud_surface_shaded_get(PointCloud *pointcloud,
int layer_index; int layer_index;
eCustomDataType type; eCustomDataType type;
eAttrDomain domain = ATTR_DOMAIN_POINT; bke::AttrDomain domain = bke::AttrDomain::Point;
if (!drw_custom_data_match_attribute(&pointcloud->pdata, name, &layer_index, &type)) { if (!drw_custom_data_match_attribute(&pointcloud->pdata, name, &layer_index, &type)) {
continue; continue;
} }
@ -397,11 +398,12 @@ GPUVertBuf *DRW_pointcloud_position_and_radius_buffer_get(Object *ob)
GPUVertBuf **DRW_pointcloud_evaluated_attribute(PointCloud *pointcloud, const char *name) GPUVertBuf **DRW_pointcloud_evaluated_attribute(PointCloud *pointcloud, const char *name)
{ {
using namespace blender;
PointCloudBatchCache &cache = *pointcloud_batch_cache_get(*pointcloud); PointCloudBatchCache &cache = *pointcloud_batch_cache_get(*pointcloud);
int layer_index; int layer_index;
eCustomDataType type; eCustomDataType type;
eAttrDomain domain = ATTR_DOMAIN_POINT; bke::AttrDomain domain = bke::AttrDomain::Point;
if (drw_custom_data_match_attribute(&pointcloud->pdata, name, &layer_index, &type)) { if (drw_custom_data_match_attribute(&pointcloud->pdata, name, &layer_index, &type)) {
DRW_Attributes attributes{}; DRW_Attributes attributes{};
drw_attributes_add_request(&attributes, name, type, layer_index, domain); drw_attributes_add_request(&attributes, name, type, layer_index, domain);

3
source/blender/draw/intern/draw_cache_impl_subdivision.cc
View File

@ -2023,6 +2023,7 @@ static void draw_subdiv_cache_ensure_mat_offsets(DRWSubdivCache &cache,
Mesh *mesh_eval, Mesh *mesh_eval,
uint mat_len) uint mat_len)
{ {
using namespace blender;
draw_subdiv_cache_free_material_data(cache); draw_subdiv_cache_free_material_data(cache);
const int number_of_quads = cache.num_subdiv_loops / 4; const int number_of_quads = cache.num_subdiv_loops / 4;
@ -2037,7 +2038,7 @@ static void draw_subdiv_cache_ensure_mat_offsets(DRWSubdivCache &cache,
const blender::bke::AttributeAccessor attributes = mesh_eval->attributes(); const blender::bke::AttributeAccessor attributes = mesh_eval->attributes();
const blender::VArraySpan<int> material_indices = *attributes.lookup_or_default<int>( const blender::VArraySpan<int> material_indices = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_FACE, 0); "material_index", bke::AttrDomain::Face, 0);
/* Count number of subdivided polygons for each material. */ /* Count number of subdivided polygons for each material. */
int *mat_start = static_cast<int *>(MEM_callocN(sizeof(int) * mat_len, "subdiv mat_start")); int *mat_start = static_cast<int *>(MEM_callocN(sizeof(int) * mat_len, "subdiv mat_start"));

20
source/blender/draw/intern/draw_curves.cc
View File

@ -168,6 +168,7 @@ static void drw_curves_cache_update_compute(CurvesEvalCache *cache,
static void drw_curves_cache_update_compute(CurvesEvalCache *cache, const int subdiv) static void drw_curves_cache_update_compute(CurvesEvalCache *cache, const int subdiv)
{ {
using namespace blender;
const int strands_len = cache->strands_len; const int strands_len = cache->strands_len;
const int final_points_len = cache->final[subdiv].strands_res * strands_len; const int final_points_len = cache->final[subdiv].strands_res * strands_len;
if (final_points_len == 0) { if (final_points_len == 0) {
@ -180,7 +181,7 @@ static void drw_curves_cache_update_compute(CurvesEvalCache *cache, const int su
const DRW_Attributes &attrs = cache->final[subdiv].attr_used; const DRW_Attributes &attrs = cache->final[subdiv].attr_used;
for (int i = 0; i < attrs.num_requests; i++) { for (int i = 0; i < attrs.num_requests; i++) {
/* Only refine point attributes. */ /* Only refine point attributes. */
if (attrs.requests[i].domain == ATTR_DOMAIN_CURVE) { if (attrs.requests[i].domain == bke::AttrDomain::Curve) {
continue; continue;
} }
@ -225,6 +226,7 @@ static void drw_curves_cache_update_transform_feedback(CurvesEvalCache *cache,
static void drw_curves_cache_update_transform_feedback(CurvesEvalCache *cache, const int subdiv) static void drw_curves_cache_update_transform_feedback(CurvesEvalCache *cache, const int subdiv)
{ {
using namespace blender;
const int final_points_len = cache->final[subdiv].strands_res * cache->strands_len; const int final_points_len = cache->final[subdiv].strands_res * cache->strands_len;
if (final_points_len == 0) { if (final_points_len == 0) {
return; return;
@ -236,7 +238,7 @@ static void drw_curves_cache_update_transform_feedback(CurvesEvalCache *cache, c
const DRW_Attributes &attrs = cache->final[subdiv].attr_used; const DRW_Attributes &attrs = cache->final[subdiv].attr_used;
for (int i = 0; i < attrs.num_requests; i++) { for (int i = 0; i < attrs.num_requests; i++) {
/* Only refine point attributes. */ /* Only refine point attributes. */
if (attrs.requests[i].domain == ATTR_DOMAIN_CURVE) { if (attrs.requests[i].domain == bke::AttrDomain::Curve) {
continue; continue;
} }
@ -339,7 +341,7 @@ DRWShadingGroup *DRW_shgroup_curves_create_sub(Object *object,
const blender::bke::CurvesGeometry &curves = curves_id.geometry.wrap(); const blender::bke::CurvesGeometry &curves = curves_id.geometry.wrap();
if (curves.curves_num() >= 1) { if (curves.curves_num() >= 1) {
blender::VArray<float> radii = *curves.attributes().lookup_or_default( blender::VArray<float> radii = *curves.attributes().lookup_or_default(
"radius", ATTR_DOMAIN_POINT, 0.005f); "radius", bke::AttrDomain::Point, 0.005f);
const blender::IndexRange first_curve_points = curves.points_by_curve()[0]; const blender::IndexRange first_curve_points = curves.points_by_curve()[0];
const float first_radius = radii[first_curve_points.first()]; const float first_radius = radii[first_curve_points.first()];
const float last_radius = radii[first_curve_points.last()]; const float last_radius = radii[first_curve_points.last()];
@ -364,7 +366,7 @@ DRWShadingGroup *DRW_shgroup_curves_create_sub(Object *object,
char sampler_name[32]; char sampler_name[32];
drw_curves_get_attribute_sampler_name(request.attribute_name, sampler_name); drw_curves_get_attribute_sampler_name(request.attribute_name, sampler_name);
if (request.domain == ATTR_DOMAIN_CURVE) { if (request.domain == bke::AttrDomain::Curve) {
if (!curves_cache->proc_attributes_buf[i]) { if (!curves_cache->proc_attributes_buf[i]) {
continue; continue;
} }
@ -385,7 +387,7 @@ DRWShadingGroup *DRW_shgroup_curves_create_sub(Object *object,
* attributes. */ * attributes. */
const int index = attribute_index_in_material(gpu_material, request.attribute_name); const int index = attribute_index_in_material(gpu_material, request.attribute_name);
if (index != -1) { if (index != -1) {
curves_infos.is_point_attribute[index][0] = request.domain == ATTR_DOMAIN_POINT; curves_infos.is_point_attribute[index][0] = request.domain == bke::AttrDomain::Point;
} }
} }
@ -616,7 +618,7 @@ static CurvesEvalCache *curves_cache_get(Curves &curves,
const DRW_Attributes &attrs = cache->final[subdiv].attr_used; const DRW_Attributes &attrs = cache->final[subdiv].attr_used;
for (int i : IndexRange(attrs.num_requests)) { for (int i : IndexRange(attrs.num_requests)) {
/* Only refine point attributes. */ /* Only refine point attributes. */
if (attrs.requests[i].domain != ATTR_DOMAIN_CURVE) { if (attrs.requests[i].domain != bke::AttrDomain::Curve) {
cache_update(cache->final[subdiv].attributes_buf[i], cache->proc_attributes_buf[i]); cache_update(cache->final[subdiv].attributes_buf[i], cache->proc_attributes_buf[i]);
} }
} }
@ -685,7 +687,7 @@ GPUBatch *curves_sub_pass_setup_implementation(PassT &sub_ps,
const blender::bke::CurvesGeometry &curves = curves_id.geometry.wrap(); const blender::bke::CurvesGeometry &curves = curves_id.geometry.wrap();
if (curves.curves_num() >= 1) { if (curves.curves_num() >= 1) {
blender::VArray<float> radii = *curves.attributes().lookup_or_default( blender::VArray<float> radii = *curves.attributes().lookup_or_default(
"radius", ATTR_DOMAIN_POINT, 0.005f); "radius", bke::AttrDomain::Point, 0.005f);
const blender::IndexRange first_curve_points = curves.points_by_curve()[0]; const blender::IndexRange first_curve_points = curves.points_by_curve()[0];
const float first_radius = radii[first_curve_points.first()]; const float first_radius = radii[first_curve_points.first()];
const float last_radius = radii[first_curve_points.last()]; const float last_radius = radii[first_curve_points.last()];
@ -710,7 +712,7 @@ GPUBatch *curves_sub_pass_setup_implementation(PassT &sub_ps,
char sampler_name[32]; char sampler_name[32];
drw_curves_get_attribute_sampler_name(request.attribute_name, sampler_name); drw_curves_get_attribute_sampler_name(request.attribute_name, sampler_name);
if (request.domain == ATTR_DOMAIN_CURVE) { if (request.domain == bke::AttrDomain::Curve) {
if (!curves_cache->proc_attributes_buf[i]) { if (!curves_cache->proc_attributes_buf[i]) {
continue; continue;
} }
@ -729,7 +731,7 @@ GPUBatch *curves_sub_pass_setup_implementation(PassT &sub_ps,
* attributes. */ * attributes. */
const int index = attribute_index_in_material(gpu_material, request.attribute_name); const int index = attribute_index_in_material(gpu_material, request.attribute_name);
if (index != -1) { if (index != -1) {
curves_infos.is_point_attribute[index][0] = request.domain == ATTR_DOMAIN_POINT; curves_infos.is_point_attribute[index][0] = request.domain == bke::AttrDomain::Point;
} }
} }

5
source/blender/draw/intern/draw_manager_data.cc
View File

@ -1433,7 +1433,7 @@ void DRW_shgroup_call_sculpt(DRWShadingGroup *shgroup,
if (use_uv) { if (use_uv) {
if (const char *name = CustomData_get_active_layer_name(&mesh->corner_data, CD_PROP_FLOAT2)) { if (const char *name = CustomData_get_active_layer_name(&mesh->corner_data, CD_PROP_FLOAT2)) {
attrs.append(pbvh::GenericRequest{name, CD_PROP_FLOAT2, ATTR_DOMAIN_CORNER}); attrs.append(pbvh::GenericRequest{name, CD_PROP_FLOAT2, bke::AttrDomain::Corner});
} }
} }
@ -1447,6 +1447,7 @@ void DRW_shgroup_call_sculpt_with_materials(DRWShadingGroup **shgroups,
int num_shgroups, int num_shgroups,
const Object *ob) const Object *ob)
{ {
using namespace blender;
using namespace blender::draw; using namespace blender::draw;
DRW_Attributes draw_attrs; DRW_Attributes draw_attrs;
DRW_MeshCDMask cd_needed; DRW_MeshCDMask cd_needed;
@ -1477,7 +1478,7 @@ void DRW_shgroup_call_sculpt_with_materials(DRWShadingGroup **shgroups,
int layer_i = CustomData_get_layer_index_n(&mesh->corner_data, CD_PROP_FLOAT2, i); int layer_i = CustomData_get_layer_index_n(&mesh->corner_data, CD_PROP_FLOAT2, i);
CustomDataLayer *layer = layer_i != -1 ? mesh->corner_data.layers + layer_i : nullptr; CustomDataLayer *layer = layer_i != -1 ? mesh->corner_data.layers + layer_i : nullptr;
if (layer) { if (layer) {
attrs.append(pbvh::GenericRequest{layer->name, CD_PROP_FLOAT2, ATTR_DOMAIN_CORNER}); attrs.append(pbvh::GenericRequest{layer->name, CD_PROP_FLOAT2, bke::AttrDomain::Corner});
} }
} }
} }

49
source/blender/draw/intern/draw_pbvh.cc
View File

@ -66,7 +66,7 @@ static bool pbvh_attr_supported(const AttributeRequest &request)
return true; return true;
} }
const GenericRequest &attr = std::get<GenericRequest>(request); const GenericRequest &attr = std::get<GenericRequest>(request);
if (!ELEM(attr.domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_FACE, ATTR_DOMAIN_CORNER)) { if (!ELEM(attr.domain, bke::AttrDomain::Point, bke::AttrDomain::Face, bke::AttrDomain::Corner)) {
/* PBVH drawing does not support edge domain attributes. */ /* PBVH drawing does not support edge domain attributes. */
return false; return false;
} }
@ -91,7 +91,7 @@ static std::string calc_request_key(const AttributeRequest &request)
else { else {
const GenericRequest &attr = std::get<GenericRequest>(request); const GenericRequest &attr = std::get<GenericRequest>(request);
const StringRefNull name = attr.name; const StringRefNull name = attr.name;
const eAttrDomain domain = attr.domain; const bke::AttrDomain domain = attr.domain;
const eCustomDataType data_type = attr.type; const eCustomDataType data_type = attr.type;
SNPRINTF(buf, "%d:%d:%s", int(data_type), int(domain), name.c_str()); SNPRINTF(buf, "%d:%d:%s", int(data_type), int(domain), name.c_str());
} }
@ -301,14 +301,14 @@ struct PBVHBatch {
} }
}; };
static const CustomData *get_cdata(eAttrDomain domain, const PBVH_GPU_Args &args) static const CustomData *get_cdata(bke::AttrDomain domain, const PBVH_GPU_Args &args)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
return args.vert_data; return args.vert_data;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
return args.corner_data; return args.corner_data;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
return args.face_data; return args.face_data;
default: default:
return nullptr; return nullptr;
@ -438,7 +438,7 @@ struct PBVHBatches {
void fill_vbo_normal_faces(const PBVH_GPU_Args &args, GPUVertBuf &vert_buf) void fill_vbo_normal_faces(const PBVH_GPU_Args &args, GPUVertBuf &vert_buf)
{ {
const bke::AttributeAccessor attributes = args.mesh->attributes(); const bke::AttributeAccessor attributes = args.mesh->attributes();
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
short4 *data = static_cast<short4 *>(GPU_vertbuf_get_data(&vert_buf)); short4 *data = static_cast<short4 *>(GPU_vertbuf_get_data(&vert_buf));
@ -500,7 +500,8 @@ struct PBVHBatches {
case CustomRequest::Normal: { case CustomRequest::Normal: {
const Span<int> grid_to_face_map = args.subdiv_ccg->grid_to_face_map; const Span<int> grid_to_face_map = args.subdiv_ccg->grid_to_face_map;
const bke::AttributeAccessor attributes = args.mesh->attributes(); const bke::AttributeAccessor attributes = args.mesh->attributes();
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face",
bke::AttrDomain::Face);
foreach_grids([&](int /*x*/, int /*y*/, int grid_index, CCGElem *elems[4], int /*i*/) { foreach_grids([&](int /*x*/, int /*y*/, int grid_index, CCGElem *elems[4], int /*i*/) {
float3 no(0.0f, 0.0f, 0.0f); float3 no(0.0f, 0.0f, 0.0f);
@ -545,7 +546,8 @@ struct PBVHBatches {
case CustomRequest::FaceSet: { case CustomRequest::FaceSet: {
const bke::AttributeAccessor attributes = args.mesh->attributes(); const bke::AttributeAccessor attributes = args.mesh->attributes();
if (const VArray<int> face_sets = *attributes.lookup<int>(".sculpt_face_set", if (const VArray<int> face_sets = *attributes.lookup<int>(".sculpt_face_set",
ATTR_DOMAIN_FACE)) { bke::AttrDomain::Face))
{
const VArraySpan<int> face_sets_span(face_sets); const VArraySpan<int> face_sets_span(face_sets);
foreach_grids( foreach_grids(
[&](int /*x*/, int /*y*/, int grid_index, CCGElem * /*elems*/[4], int /*i*/) { [&](int /*x*/, int /*y*/, int grid_index, CCGElem * /*elems*/[4], int /*i*/) {
@ -681,7 +683,7 @@ struct PBVHBatches {
case CustomRequest::Mask: { case CustomRequest::Mask: {
float *data = static_cast<float *>(GPU_vertbuf_get_data(&vert_buf)); float *data = static_cast<float *>(GPU_vertbuf_get_data(&vert_buf));
if (const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", if (const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask",
ATTR_DOMAIN_POINT)) { bke::AttrDomain::Point)) {
const VArraySpan<float> mask_span(mask); const VArraySpan<float> mask_span(mask);
const Span<int> corner_verts = args.corner_verts; const Span<int> corner_verts = args.corner_verts;
const Span<int3> corner_tris = args.corner_tris; const Span<int3> corner_tris = args.corner_tris;
@ -707,7 +709,8 @@ struct PBVHBatches {
case CustomRequest::FaceSet: { case CustomRequest::FaceSet: {
uchar4 *data = static_cast<uchar4 *>(GPU_vertbuf_get_data(vbo.vert_buf)); uchar4 *data = static_cast<uchar4 *>(GPU_vertbuf_get_data(vbo.vert_buf));
if (const VArray<int> face_sets = *attributes.lookup<int>(".sculpt_face_set", if (const VArray<int> face_sets = *attributes.lookup<int>(".sculpt_face_set",
ATTR_DOMAIN_FACE)) { bke::AttrDomain::Face))
{
const VArraySpan<int> face_sets_span(face_sets); const VArraySpan<int> face_sets_span(face_sets);
int last_face = -1; int last_face = -1;
uchar4 fset_color(UCHAR_MAX); uchar4 fset_color(UCHAR_MAX);
@ -746,19 +749,19 @@ struct PBVHBatches {
const bke::AttributeAccessor attributes = args.mesh->attributes(); const bke::AttributeAccessor attributes = args.mesh->attributes();
const GenericRequest &request = std::get<GenericRequest>(vbo.request); const GenericRequest &request = std::get<GenericRequest>(vbo.request);
const StringRef name = request.name; const StringRef name = request.name;
const eAttrDomain domain = request.domain; const bke::AttrDomain domain = request.domain;
const eCustomDataType data_type = request.type; const eCustomDataType data_type = request.type;
const GVArraySpan attribute = *attributes.lookup_or_default(name, domain, data_type); const GVArraySpan attribute = *attributes.lookup_or_default(name, domain, data_type);
bke::attribute_math::convert_to_static_type(data_type, [&](auto dummy) { bke::attribute_math::convert_to_static_type(data_type, [&](auto dummy) {
using T = decltype(dummy); using T = decltype(dummy);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
extract_data_vert_faces<T>(args, attribute.typed<T>(), vert_buf); extract_data_vert_faces<T>(args, attribute.typed<T>(), vert_buf);
break; break;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
extract_data_face_faces<T>(args, attribute.typed<T>(), vert_buf); extract_data_face_faces<T>(args, attribute.typed<T>(), vert_buf);
break; break;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
extract_data_corner_faces<T>(args, attribute.typed<T>(), vert_buf); extract_data_corner_faces<T>(args, attribute.typed<T>(), vert_buf);
break; break;
default: default:
@ -912,20 +915,20 @@ struct PBVHBatches {
else { else {
const GenericRequest &request = std::get<GenericRequest>(vbo.request); const GenericRequest &request = std::get<GenericRequest>(vbo.request);
const StringRefNull name = request.name; const StringRefNull name = request.name;
const eAttrDomain domain = request.domain; const bke::AttrDomain domain = request.domain;
const eCustomDataType data_type = request.type; const eCustomDataType data_type = request.type;
const CustomData &custom_data = *get_cdata(domain, args); const CustomData &custom_data = *get_cdata(domain, args);
const int cd_offset = CustomData_get_offset_named(&custom_data, data_type, name.c_str()); const int cd_offset = CustomData_get_offset_named(&custom_data, data_type, name.c_str());
bke::attribute_math::convert_to_static_type(data_type, [&](auto dummy) { bke::attribute_math::convert_to_static_type(data_type, [&](auto dummy) {
using T = decltype(dummy); using T = decltype(dummy);
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
extract_data_vert_bmesh<T>(args, cd_offset, *vbo.vert_buf); extract_data_vert_bmesh<T>(args, cd_offset, *vbo.vert_buf);
break; break;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
extract_data_face_bmesh<T>(args, cd_offset, *vbo.vert_buf); extract_data_face_bmesh<T>(args, cd_offset, *vbo.vert_buf);
break; break;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
extract_data_corner_bmesh<T>(args, cd_offset, *vbo.vert_buf); extract_data_corner_bmesh<T>(args, cd_offset, *vbo.vert_buf);
break; break;
default: default:
@ -974,7 +977,7 @@ struct PBVHBatches {
else { else {
const GenericRequest &attr = std::get<GenericRequest>(request); const GenericRequest &attr = std::get<GenericRequest>(request);
const StringRefNull name = attr.name; const StringRefNull name = attr.name;
const eAttrDomain domain = attr.domain; const bke::AttrDomain domain = attr.domain;
const eCustomDataType data_type = attr.type; const eCustomDataType data_type = attr.type;
format = draw::init_format_for_attribute(data_type, "data"); format = draw::init_format_for_attribute(data_type, "data");
@ -1030,7 +1033,7 @@ struct PBVHBatches {
{ {
const bke::AttributeAccessor attributes = args.mesh->attributes(); const bke::AttributeAccessor attributes = args.mesh->attributes();
const VArray material_indices = *attributes.lookup_or_default<int>( const VArray material_indices = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_FACE, 0); "material_index", bke::AttrDomain::Face, 0);
material_index = material_indices[args.tri_faces[args.prim_indices.first()]]; material_index = material_indices[args.tri_faces[args.prim_indices.first()]];
const Span<int2> edges = args.mesh->edges(); const Span<int2> edges = args.mesh->edges();
@ -1113,9 +1116,9 @@ struct PBVHBatches {
void create_index_grids(const PBVH_GPU_Args &args, bool do_coarse) void create_index_grids(const PBVH_GPU_Args &args, bool do_coarse)
{ {
const bke::AttributeAccessor attributes = args.mesh->attributes(); const bke::AttributeAccessor attributes = args.mesh->attributes();
const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", ATTR_DOMAIN_FACE); const VArraySpan sharp_faces = *attributes.lookup<bool>("sharp_face", bke::AttrDomain::Face);
const VArray material_indices = *attributes.lookup_or_default<int>( const VArray material_indices = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_FACE, 0); "material_index", bke::AttrDomain::Face, 0);
const BitGroupVector<> &grid_hidden = args.subdiv_ccg->grid_hidden; const BitGroupVector<> &grid_hidden = args.subdiv_ccg->grid_hidden;
const Span<int> grid_to_face_map = args.subdiv_ccg->grid_to_face_map; const Span<int> grid_to_face_map = args.subdiv_ccg->grid_to_face_map;

4
source/blender/draw/intern/draw_sculpt.cc
View File

@ -147,7 +147,7 @@ Vector<SculptBatch> sculpt_batches_get(const Object *ob, SculptBatchFeature feat
if (features & SCULPT_BATCH_UV) { if (features & SCULPT_BATCH_UV) {
if (const char *name = CustomData_get_active_layer_name(&mesh->corner_data, CD_PROP_FLOAT2)) { if (const char *name = CustomData_get_active_layer_name(&mesh->corner_data, CD_PROP_FLOAT2)) {
attrs.append(pbvh::GenericRequest{name, CD_PROP_FLOAT2, ATTR_DOMAIN_CORNER}); attrs.append(pbvh::GenericRequest{name, CD_PROP_FLOAT2, bke::AttrDomain::Corner});
} }
} }
@ -180,7 +180,7 @@ Vector<SculptBatch> sculpt_batches_per_material_get(const Object *ob,
int layer_i = CustomData_get_layer_index_n(&mesh->corner_data, CD_PROP_FLOAT2, i); int layer_i = CustomData_get_layer_index_n(&mesh->corner_data, CD_PROP_FLOAT2, i);
CustomDataLayer *layer = layer_i != -1 ? mesh->corner_data.layers + layer_i : nullptr; CustomDataLayer *layer = layer_i != -1 ? mesh->corner_data.layers + layer_i : nullptr;
if (layer) { if (layer) {
attrs.append(pbvh::GenericRequest{layer->name, CD_PROP_FLOAT2, ATTR_DOMAIN_CORNER}); attrs.append(pbvh::GenericRequest{layer->name, CD_PROP_FLOAT2, bke::AttrDomain::Corner});
} }
} }
} }

28
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
View File

@ -172,16 +172,16 @@ static void extract_data_bmesh_loop(const BMesh &bm, const int cd_offset, GPUVer
} }
} }
static const CustomData *get_custom_data_for_domain(const BMesh &bm, eAttrDomain domain) static const CustomData *get_custom_data_for_domain(const BMesh &bm, bke::AttrDomain domain)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
return &bm.vdata; return &bm.vdata;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
return &bm.ldata; return &bm.ldata;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
return &bm.pdata; return &bm.pdata;
case ATTR_DOMAIN_EDGE: case bke::AttrDomain::Edge:
return &bm.edata; return &bm.edata;
default: default:
return nullptr; return nullptr;
@ -200,16 +200,16 @@ static void extract_attr(const MeshRenderData &mr,
bke::attribute_math::convert_to_static_type(request.cd_type, [&](auto dummy) { bke::attribute_math::convert_to_static_type(request.cd_type, [&](auto dummy) {
using T = decltype(dummy); using T = decltype(dummy);
switch (request.domain) { switch (request.domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
extract_data_bmesh_vert<T>(*mr.bm, cd_offset, vbo); extract_data_bmesh_vert<T>(*mr.bm, cd_offset, vbo);
break; break;
case ATTR_DOMAIN_EDGE: case bke::AttrDomain::Edge:
extract_data_bmesh_edge<T>(*mr.bm, cd_offset, vbo); extract_data_bmesh_edge<T>(*mr.bm, cd_offset, vbo);
break; break;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
extract_data_bmesh_face<T>(*mr.bm, cd_offset, vbo); extract_data_bmesh_face<T>(*mr.bm, cd_offset, vbo);
break; break;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
extract_data_bmesh_loop<T>(*mr.bm, cd_offset, vbo); extract_data_bmesh_loop<T>(*mr.bm, cd_offset, vbo);
break; break;
default: default:
@ -226,16 +226,16 @@ static void extract_attr(const MeshRenderData &mr,
bke::attribute_math::convert_to_static_type(request.cd_type, [&](auto dummy) { bke::attribute_math::convert_to_static_type(request.cd_type, [&](auto dummy) {
using T = decltype(dummy); using T = decltype(dummy);
switch (request.domain) { switch (request.domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
extract_data_mesh_mapped_corner(attribute.typed<T>(), mr.corner_verts, vbo); extract_data_mesh_mapped_corner(attribute.typed<T>(), mr.corner_verts, vbo);
break; break;
case ATTR_DOMAIN_EDGE: case bke::AttrDomain::Edge:
extract_data_mesh_mapped_corner(attribute.typed<T>(), mr.corner_edges, vbo); extract_data_mesh_mapped_corner(attribute.typed<T>(), mr.corner_edges, vbo);
break; break;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
extract_data_mesh_face(mr.faces, attribute.typed<T>(), vbo); extract_data_mesh_face(mr.faces, attribute.typed<T>(), vbo);
break; break;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
vertbuf_data_extract_direct(attribute.typed<T>(), vbo); vertbuf_data_extract_direct(attribute.typed<T>(), vbo);
break; break;
default: default:
@ -358,7 +358,7 @@ static void extract_mesh_attr_viewer_init(const MeshRenderData &mr,
const StringRefNull attr_name = ".viewer"; const StringRefNull attr_name = ".viewer";
const bke::AttributeAccessor attributes = mr.mesh->attributes(); const bke::AttributeAccessor attributes = mr.mesh->attributes();
const bke::AttributeReader attribute = attributes.lookup_or_default<ColorGeometry4f>( const bke::AttributeReader attribute = attributes.lookup_or_default<ColorGeometry4f>(
attr_name, ATTR_DOMAIN_CORNER, {1.0f, 0.0f, 1.0f, 1.0f}); attr_name, bke::AttrDomain::Corner, {1.0f, 0.0f, 1.0f, 1.0f});
attribute.varray.materialize(attr); attribute.varray.materialize(attr);
} }

10
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc
View File

@ -81,8 +81,9 @@ static void extract_sculpt_data_init(const MeshRenderData &mr,
} }
else { else {
const bke::AttributeAccessor attributes = mr.mesh->attributes(); const bke::AttributeAccessor attributes = mr.mesh->attributes();
const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", ATTR_DOMAIN_POINT); const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", bke::AttrDomain::Point);
const VArray<int> face_set = *attributes.lookup<int>(".sculpt_face_set", ATTR_DOMAIN_FACE); const VArray<int> face_set = *attributes.lookup<int>(".sculpt_face_set",
bke::AttrDomain::Face);
for (int face_index = 0; face_index < mr.face_len; face_index++) { for (int face_index = 0; face_index < mr.face_len; face_index++) {
for (const int corner : mr.faces[face_index]) { for (const int corner : mr.faces[face_index]) {
@ -123,7 +124,7 @@ static void extract_sculpt_data_init_subdiv(const DRWSubdivCache &subdiv_cache,
GPUVertBuf *subdiv_mask_vbo = nullptr; GPUVertBuf *subdiv_mask_vbo = nullptr;
const bke::AttributeAccessor attributes = coarse_mesh->attributes(); const bke::AttributeAccessor attributes = coarse_mesh->attributes();
const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", ATTR_DOMAIN_POINT); const VArray<float> mask = *attributes.lookup<float>(".sculpt_mask", bke::AttrDomain::Point);
const OffsetIndices coarse_faces = coarse_mesh->faces(); const OffsetIndices coarse_faces = coarse_mesh->faces();
const Span<int> coarse_corner_verts = coarse_mesh->corner_verts(); const Span<int> coarse_corner_verts = coarse_mesh->corner_verts();
@ -163,7 +164,8 @@ static void extract_sculpt_data_init_subdiv(const DRWSubdivCache &subdiv_cache,
}; };
gpuFaceSet *face_sets = (gpuFaceSet *)GPU_vertbuf_get_data(face_set_vbo); gpuFaceSet *face_sets = (gpuFaceSet *)GPU_vertbuf_get_data(face_set_vbo);
const VArray<int> cd_face_sets = *attributes.lookup<int>(".sculpt_face_set", ATTR_DOMAIN_FACE); const VArray<int> cd_face_sets = *attributes.lookup<int>(".sculpt_face_set",
bke::AttrDomain::Face);
GPUVertFormat *format = get_sculpt_data_format(); GPUVertFormat *format = get_sculpt_data_format();
GPU_vertbuf_init_build_on_device(vbo, format, subdiv_cache.num_subdiv_loops); GPU_vertbuf_init_build_on_device(vbo, format, subdiv_cache.num_subdiv_loops);

2
source/blender/editors/curves/intern/curves_add.cc
View File

@ -110,7 +110,7 @@ bke::CurvesGeometry primitive_random_sphere(const int curves_size, const int poi
MutableSpan<float3> positions = curves.positions_for_write(); MutableSpan<float3> positions = curves.positions_for_write();
bke::MutableAttributeAccessor attributes = curves.attributes_for_write(); bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
bke::SpanAttributeWriter<float> radius = attributes.lookup_or_add_for_write_only_span<float>( bke::SpanAttributeWriter<float> radius = attributes.lookup_or_add_for_write_only_span<float>(
"radius", ATTR_DOMAIN_POINT); "radius", bke::AttrDomain::Point);
for (const int i : offsets.index_range()) { for (const int i : offsets.index_range()) {
offsets[i] = points_per_curve * i; offsets[i] = points_per_curve * i;

8
source/blender/editors/curves/intern/curves_attribute_set.cc
View File

@ -62,13 +62,13 @@ static bool active_attribute_poll(bContext *C)
} }
static IndexMask retrieve_selected_elements(const Curves &curves_id, static IndexMask retrieve_selected_elements(const Curves &curves_id,
const eAttrDomain domain, const bke::AttrDomain domain,
IndexMaskMemory &memory) IndexMaskMemory &memory)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
return retrieve_selected_points(curves_id, memory); return retrieve_selected_points(curves_id, memory);
case ATTR_DOMAIN_CURVE: case bke::AttrDomain::Curve:
return retrieve_selected_curves(curves_id, memory); return retrieve_selected_curves(curves_id, memory);
default: default:
BLI_assert_unreachable(); BLI_assert_unreachable();
@ -161,7 +161,7 @@ static int set_attribute_invoke(bContext *C, wmOperator *op, const wmEvent *even
const bke::CurvesGeometry &curves = active_curves_id.geometry.wrap(); const bke::CurvesGeometry &curves = active_curves_id.geometry.wrap();
const bke::AttributeAccessor attributes = curves.attributes(); const bke::AttributeAccessor attributes = curves.attributes();
const bke::GAttributeReader attribute = attributes.lookup(active_attribute->name); const bke::GAttributeReader attribute = attributes.lookup(active_attribute->name);
const eAttrDomain domain = attribute.domain; const bke::AttrDomain domain = attribute.domain;
IndexMaskMemory memory; IndexMaskMemory memory;
const IndexMask selection = retrieve_selected_elements(active_curves_id, domain, memory); const IndexMask selection = retrieve_selected_elements(active_curves_id, domain, memory);

20
source/blender/editors/curves/intern/curves_draw.cc
View File

@ -775,7 +775,7 @@ static int curves_draw_exec(bContext *C, wmOperator *op)
const IndexRange new_points = curves.points_by_curve()[curve_index]; const IndexRange new_points = curves.points_by_curve()[curve_index];
bke::SpanAttributeWriter<float> radii = attributes.lookup_or_add_for_write_only_span<float>( bke::SpanAttributeWriter<float> radii = attributes.lookup_or_add_for_write_only_span<float>(
"radius", ATTR_DOMAIN_POINT); "radius", bke::AttrDomain::Point);
float *co = cubic_spline; float *co = cubic_spline;
@ -819,7 +819,7 @@ static int curves_draw_exec(bContext *C, wmOperator *op)
radii.finish(); radii.finish();
bke::AttributeWriter<bool> selection = attributes.lookup_or_add_for_write<bool>( bke::AttributeWriter<bool> selection = attributes.lookup_or_add_for_write<bool>(
".selection", ATTR_DOMAIN_CURVE); ".selection", bke::AttrDomain::Curve);
selection.varray.set(curve_index, true); selection.varray.set(curve_index, true);
selection.finish(); selection.finish();
@ -832,7 +832,7 @@ static int curves_draw_exec(bContext *C, wmOperator *op)
} }
bke::fill_attribute_range_default(attributes, bke::fill_attribute_range_default(attributes,
ATTR_DOMAIN_POINT, bke::AttrDomain::Point,
{"position", {"position",
"radius", "radius",
"handle_left", "handle_left",
@ -842,7 +842,7 @@ static int curves_draw_exec(bContext *C, wmOperator *op)
".selection"}, ".selection"},
new_points); new_points);
bke::fill_attribute_range_default(attributes, bke::fill_attribute_range_default(attributes,
ATTR_DOMAIN_CURVE, bke::AttrDomain::Curve,
{"curve_type", "resolution", "cyclic", ".selection"}, {"curve_type", "resolution", "cyclic", ".selection"},
IndexRange(curve_index, 1)); IndexRange(curve_index, 1));
} }
@ -861,7 +861,7 @@ static int curves_draw_exec(bContext *C, wmOperator *op)
MutableSpan<float3> positions = curves.positions_for_write(); MutableSpan<float3> positions = curves.positions_for_write();
bke::SpanAttributeWriter<float> radii = attributes.lookup_or_add_for_write_only_span<float>( bke::SpanAttributeWriter<float> radii = attributes.lookup_or_add_for_write_only_span<float>(
"radius", ATTR_DOMAIN_POINT); "radius", bke::AttrDomain::Point);
const IndexRange new_points = curves.points_by_curve()[curve_index]; const IndexRange new_points = curves.points_by_curve()[curve_index];
@ -885,14 +885,16 @@ static int curves_draw_exec(bContext *C, wmOperator *op)
radii.finish(); radii.finish();
bke::AttributeWriter<bool> selection = attributes.lookup_or_add_for_write<bool>( bke::AttributeWriter<bool> selection = attributes.lookup_or_add_for_write<bool>(
".selection", ATTR_DOMAIN_CURVE); ".selection", bke::AttrDomain::Curve);
selection.varray.set(curve_index, true); selection.varray.set(curve_index, true);
selection.finish(); selection.finish();
bke::fill_attribute_range_default( bke::fill_attribute_range_default(
attributes, ATTR_DOMAIN_POINT, {"position", "radius", ".selection"}, new_points); attributes, bke::AttrDomain::Point, {"position", "radius", ".selection"}, new_points);
bke::fill_attribute_range_default( bke::fill_attribute_range_default(attributes,
attributes, ATTR_DOMAIN_CURVE, {"curve_type", ".selection"}, IndexRange(curve_index, 1)); bke::AttrDomain::Curve,
{"curve_type", ".selection"},
IndexRange(curve_index, 1));
} }
WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data); WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);

18
source/blender/editors/curves/intern/curves_edit.cc
View File

@ -14,7 +14,7 @@
namespace blender::ed::curves { namespace blender::ed::curves {
bool remove_selection(bke::CurvesGeometry &curves, const eAttrDomain selection_domain) bool remove_selection(bke::CurvesGeometry &curves, const bke::AttrDomain selection_domain)
{ {
const bke::AttributeAccessor attributes = curves.attributes(); const bke::AttributeAccessor attributes = curves.attributes();
const VArray<bool> selection = *attributes.lookup_or_default<bool>( const VArray<bool> selection = *attributes.lookup_or_default<bool>(
@ -23,10 +23,10 @@ bool remove_selection(bke::CurvesGeometry &curves, const eAttrDomain selection_d
IndexMaskMemory memory; IndexMaskMemory memory;
const IndexMask mask = IndexMask::from_bools(selection, memory); const IndexMask mask = IndexMask::from_bools(selection, memory);
switch (selection_domain) { switch (selection_domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
curves.remove_points(mask); curves.remove_points(mask);
break; break;
case ATTR_DOMAIN_CURVE: case bke::AttrDomain::Curve:
curves.remove_curves(mask); curves.remove_curves(mask);
break; break;
default: default:
@ -122,7 +122,7 @@ void duplicate_points(bke::CurvesGeometry &curves, const IndexMask &mask)
} }
switch (meta_data.domain) { switch (meta_data.domain) {
case ATTR_DOMAIN_CURVE: { case bke::AttrDomain::Curve: {
if (id.name() == "cyclic") { if (id.name() == "cyclic") {
return true; return true;
} }
@ -132,7 +132,7 @@ void duplicate_points(bke::CurvesGeometry &curves, const IndexMask &mask)
attribute.span.slice(IndexRange(old_curves_num, num_curves_to_add))); attribute.span.slice(IndexRange(old_curves_num, num_curves_to_add)));
break; break;
} }
case ATTR_DOMAIN_POINT: { case bke::AttrDomain::Point: {
bke::attribute_math::gather( bke::attribute_math::gather(
attribute.span, attribute.span,
dst_to_src_point, dst_to_src_point,
@ -159,7 +159,7 @@ void duplicate_points(bke::CurvesGeometry &curves, const IndexMask &mask)
curves.tag_topology_changed(); curves.tag_topology_changed();
bke::SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>(
".selection", ATTR_DOMAIN_POINT); ".selection", bke::AttrDomain::Point);
selection.span.take_back(num_points_to_add).fill(true); selection.span.take_back(num_points_to_add).fill(true);
selection.finish(); selection.finish();
} }
@ -192,14 +192,14 @@ void duplicate_curves(bke::CurvesGeometry &curves, const IndexMask &mask)
attributes.for_all([&](const bke::AttributeIDRef &id, const bke::AttributeMetaData meta_data) { attributes.for_all([&](const bke::AttributeIDRef &id, const bke::AttributeMetaData meta_data) {
bke::GSpanAttributeWriter attribute = attributes.lookup_for_write_span(id); bke::GSpanAttributeWriter attribute = attributes.lookup_for_write_span(id);
switch (meta_data.domain) { switch (meta_data.domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
bke::attribute_math::gather_group_to_group(points_by_curve.slice(orig_curves_range), bke::attribute_math::gather_group_to_group(points_by_curve.slice(orig_curves_range),
points_by_curve.slice(new_curves_range), points_by_curve.slice(new_curves_range),
mask, mask,
attribute.span, attribute.span,
attribute.span); attribute.span);
break; break;
case ATTR_DOMAIN_CURVE: case bke::AttrDomain::Curve:
array_utils::gather(attribute.span, mask, attribute.span.take_back(mask.size())); array_utils::gather(attribute.span, mask, attribute.span.take_back(mask.size()));
break; break;
default: default:
@ -214,7 +214,7 @@ void duplicate_curves(bke::CurvesGeometry &curves, const IndexMask &mask)
curves.tag_topology_changed(); curves.tag_topology_changed();
bke::SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>(
".selection", ATTR_DOMAIN_CURVE); ".selection", bke::AttrDomain::Curve);
selection.span.take_back(mask.size()).fill(true); selection.span.take_back(mask.size()).fill(true);
selection.finish(); selection.finish();
} }

4
source/blender/editors/curves/intern/curves_masks.cc
View File

@ -44,7 +44,7 @@ IndexMask end_points(const bke::CurvesGeometry &curves,
IndexMask random_mask(const bke::CurvesGeometry &curves, IndexMask random_mask(const bke::CurvesGeometry &curves,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
const uint32_t random_seed, const uint32_t random_seed,
const float probability, const float probability,
IndexMaskMemory &memory) IndexMaskMemory &memory)
@ -62,7 +62,7 @@ IndexMask random_mask(const bke::CurvesGeometry &curves,
} }
IndexMask random_mask(const bke::CurvesGeometry &curves, IndexMask random_mask(const bke::CurvesGeometry &curves,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
const uint32_t random_seed, const uint32_t random_seed,
const float probability, const float probability,
IndexMaskMemory &memory) IndexMaskMemory &memory)

24
source/blender/editors/curves/intern/curves_ops.cc
View File

@ -169,7 +169,7 @@ static bool editable_curves_point_domain_poll(bContext *C)
return false; return false;
} }
const Curves *curves_id = static_cast<const Curves *>(CTX_data_active_object(C)->data); const Curves *curves_id = static_cast<const Curves *>(CTX_data_active_object(C)->data);
if (curves_id->selection_domain != ATTR_DOMAIN_POINT) { if (bke::AttrDomain(curves_id->selection_domain) != bke::AttrDomain::Point) {
CTX_wm_operator_poll_msg_set(C, "Only available in point selection mode"); CTX_wm_operator_poll_msg_set(C, "Only available in point selection mode");
return false; return false;
} }
@ -593,7 +593,7 @@ static void snap_curves_to_surface_exec_object(Object &curves_ob,
if (curves_id.surface_uv_map != nullptr) { if (curves_id.surface_uv_map != nullptr) {
const bke::AttributeAccessor surface_attributes = surface_mesh.attributes(); const bke::AttributeAccessor surface_attributes = surface_mesh.attributes();
surface_uv_map = *surface_attributes.lookup<float2>(curves_id.surface_uv_map, surface_uv_map = *surface_attributes.lookup<float2>(curves_id.surface_uv_map,
ATTR_DOMAIN_CORNER); bke::AttrDomain::Corner);
} }
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
@ -778,14 +778,14 @@ namespace set_selection_domain {
static int curves_set_selection_domain_exec(bContext *C, wmOperator *op) static int curves_set_selection_domain_exec(bContext *C, wmOperator *op)
{ {
const eAttrDomain domain = eAttrDomain(RNA_enum_get(op->ptr, "domain")); const bke::AttrDomain domain = bke::AttrDomain(RNA_enum_get(op->ptr, "domain"));
for (Curves *curves_id : get_unique_editable_curves(*C)) { for (Curves *curves_id : get_unique_editable_curves(*C)) {
if (curves_id->selection_domain == domain) { if (bke::AttrDomain(curves_id->selection_domain) == domain) {
continue; continue;
} }
curves_id->selection_domain = domain; curves_id->selection_domain = char(domain);
CurvesGeometry &curves = curves_id->geometry.wrap(); CurvesGeometry &curves = curves_id->geometry.wrap();
bke::MutableAttributeAccessor attributes = curves.attributes_for_write(); bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
@ -870,7 +870,7 @@ static int select_all_exec(bContext *C, wmOperator *op)
for (Curves *curves_id : unique_curves) { for (Curves *curves_id : unique_curves) {
/* (De)select all the curves. */ /* (De)select all the curves. */
select_all(curves_id->geometry.wrap(), eAttrDomain(curves_id->selection_domain), action); select_all(curves_id->geometry.wrap(), bke::AttrDomain(curves_id->selection_domain), action);
/* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a generic /* Use #ID_RECALC_GEOMETRY instead of #ID_RECALC_SELECT because it is handled as a generic
* attribute for now. */ * attribute for now. */
@ -904,7 +904,7 @@ static int select_random_exec(bContext *C, wmOperator *op)
for (Curves *curves_id : unique_curves) { for (Curves *curves_id : unique_curves) {
CurvesGeometry &curves = curves_id->geometry.wrap(); CurvesGeometry &curves = curves_id->geometry.wrap();
const eAttrDomain selection_domain = eAttrDomain(curves_id->selection_domain); const bke::AttrDomain selection_domain = bke::AttrDomain(curves_id->selection_domain);
const int domain_size = curves.attributes().domain_size(selection_domain); const int domain_size = curves.attributes().domain_size(selection_domain);
IndexMaskMemory memory; IndexMaskMemory memory;
@ -985,7 +985,7 @@ static int select_ends_exec(bContext *C, wmOperator *op)
const bool was_anything_selected = has_anything_selected(curves); const bool was_anything_selected = has_anything_selected(curves);
bke::GSpanAttributeWriter selection = ensure_selection_attribute( bke::GSpanAttributeWriter selection = ensure_selection_attribute(
curves, ATTR_DOMAIN_POINT, CD_PROP_BOOL); curves, bke::AttrDomain::Point, CD_PROP_BOOL);
if (!was_anything_selected) { if (!was_anything_selected) {
fill_selection_true(selection.span); fill_selection_true(selection.span);
} }
@ -1221,7 +1221,7 @@ static int delete_exec(bContext *C, wmOperator * /*op*/)
{ {
for (Curves *curves_id : get_unique_editable_curves(*C)) { for (Curves *curves_id : get_unique_editable_curves(*C)) {
bke::CurvesGeometry &curves = curves_id->geometry.wrap(); bke::CurvesGeometry &curves = curves_id->geometry.wrap();
if (remove_selection(curves, eAttrDomain(curves_id->selection_domain))) { if (remove_selection(curves, bke::AttrDomain(curves_id->selection_domain))) {
DEG_id_tag_update(&curves_id->id, ID_RECALC_GEOMETRY); DEG_id_tag_update(&curves_id->id, ID_RECALC_GEOMETRY);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, curves_id); WM_event_add_notifier(C, NC_GEOM | ND_DATA, curves_id);
} }
@ -1251,11 +1251,11 @@ static int delete_exec(bContext *C, wmOperator * /*op*/)
for (Curves *curves_id : get_unique_editable_curves(*C)) { for (Curves *curves_id : get_unique_editable_curves(*C)) {
bke::CurvesGeometry &curves = curves_id->geometry.wrap(); bke::CurvesGeometry &curves = curves_id->geometry.wrap();
IndexMaskMemory memory; IndexMaskMemory memory;
switch (eAttrDomain(curves_id->selection_domain)) { switch (bke::AttrDomain(curves_id->selection_domain)) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
duplicate_points(curves, retrieve_selected_points(*curves_id, memory)); duplicate_points(curves, retrieve_selected_points(*curves_id, memory));
break; break;
case ATTR_DOMAIN_CURVE: case bke::AttrDomain::Curve:
duplicate_curves(curves, retrieve_selected_curves(*curves_id, memory)); duplicate_curves(curves, retrieve_selected_curves(*curves_id, memory));
break; break;
default: default:

45
source/blender/editors/curves/intern/curves_selection.cc
View File

@ -32,11 +32,11 @@ IndexMask retrieve_selected_curves(const bke::CurvesGeometry &curves, IndexMaskM
* interested in whether any point in each curve is selected. Retrieve meta data since * interested in whether any point in each curve is selected. Retrieve meta data since
* #lookup_or_default from the attribute API doesn't give the domain of the attribute. */ * #lookup_or_default from the attribute API doesn't give the domain of the attribute. */
std::optional<bke::AttributeMetaData> meta_data = attributes.lookup_meta_data(".selection"); std::optional<bke::AttributeMetaData> meta_data = attributes.lookup_meta_data(".selection");
if (meta_data && meta_data->domain == ATTR_DOMAIN_POINT) { if (meta_data && meta_data->domain == bke::AttrDomain::Point) {
/* Avoid the interpolation from interpolating the attribute to the /* Avoid the interpolation from interpolating the attribute to the
* curve domain by retrieving the point domain values directly. */ * curve domain by retrieving the point domain values directly. */
const VArray<bool> selection = *attributes.lookup_or_default<bool>( const VArray<bool> selection = *attributes.lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
if (selection.is_single()) { if (selection.is_single()) {
return selection.get_internal_single() ? IndexMask(curves_range) : IndexMask(); return selection.get_internal_single() ? IndexMask(curves_range) : IndexMask();
} }
@ -51,7 +51,7 @@ IndexMask retrieve_selected_curves(const bke::CurvesGeometry &curves, IndexMaskM
}); });
} }
const VArray<bool> selection = *attributes.lookup_or_default<bool>( const VArray<bool> selection = *attributes.lookup_or_default<bool>(
".selection", ATTR_DOMAIN_CURVE, true); ".selection", bke::AttrDomain::Curve, true);
return IndexMask::from_bools(curves_range, selection, memory); return IndexMask::from_bools(curves_range, selection, memory);
} }
@ -64,7 +64,8 @@ IndexMask retrieve_selected_curves(const Curves &curves_id, IndexMaskMemory &mem
IndexMask retrieve_selected_points(const bke::CurvesGeometry &curves, IndexMaskMemory &memory) IndexMask retrieve_selected_points(const bke::CurvesGeometry &curves, IndexMaskMemory &memory)
{ {
return IndexMask::from_bools( return IndexMask::from_bools(
*curves.attributes().lookup_or_default<bool>(".selection", ATTR_DOMAIN_POINT, true), memory); *curves.attributes().lookup_or_default<bool>(".selection", bke::AttrDomain::Point, true),
memory);
} }
IndexMask retrieve_selected_points(const Curves &curves_id, IndexMaskMemory &memory) IndexMask retrieve_selected_points(const Curves &curves_id, IndexMaskMemory &memory)
@ -74,7 +75,7 @@ IndexMask retrieve_selected_points(const Curves &curves_id, IndexMaskMemory &mem
} }
bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves, bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
const eCustomDataType create_type) const eCustomDataType create_type)
{ {
bke::MutableAttributeAccessor attributes = curves.attributes_for_write(); bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
@ -284,7 +285,7 @@ static void invert_selection(GMutableSpan selection, const IndexMask &mask)
void select_all(bke::CurvesGeometry &curves, void select_all(bke::CurvesGeometry &curves,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
int action) int action)
{ {
bke::MutableAttributeAccessor attributes = curves.attributes_for_write(); bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
@ -311,7 +312,7 @@ void select_all(bke::CurvesGeometry &curves,
selection.finish(); selection.finish();
} }
void select_all(bke::CurvesGeometry &curves, const eAttrDomain selection_domain, int action) void select_all(bke::CurvesGeometry &curves, const bke::AttrDomain selection_domain, int action)
{ {
const IndexRange selection(curves.attributes().domain_size(selection_domain)); const IndexRange selection(curves.attributes().domain_size(selection_domain));
select_all(curves, selection, selection_domain, action); select_all(curves, selection, selection_domain, action);
@ -321,7 +322,7 @@ void select_linked(bke::CurvesGeometry &curves, const IndexMask &curves_mask)
{ {
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
bke::GSpanAttributeWriter selection = ensure_selection_attribute( bke::GSpanAttributeWriter selection = ensure_selection_attribute(
curves, ATTR_DOMAIN_POINT, CD_PROP_BOOL); curves, bke::AttrDomain::Point, CD_PROP_BOOL);
curves_mask.foreach_index(GrainSize(256), [&](const int64_t curve_i) { curves_mask.foreach_index(GrainSize(256), [&](const int64_t curve_i) {
GMutableSpan selection_curve = selection.span.slice(points_by_curve[curve_i]); GMutableSpan selection_curve = selection.span.slice(points_by_curve[curve_i]);
@ -348,7 +349,7 @@ void select_alternate(bke::CurvesGeometry &curves,
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
bke::GSpanAttributeWriter selection = ensure_selection_attribute( bke::GSpanAttributeWriter selection = ensure_selection_attribute(
curves, ATTR_DOMAIN_POINT, CD_PROP_BOOL); curves, bke::AttrDomain::Point, CD_PROP_BOOL);
const VArray<bool> cyclic = curves.cyclic(); const VArray<bool> cyclic = curves.cyclic();
MutableSpan<bool> selection_typed = selection.span.typed<bool>(); MutableSpan<bool> selection_typed = selection.span.typed<bool>();
@ -394,7 +395,7 @@ void select_adjacent(bke::CurvesGeometry &curves,
{ {
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
bke::GSpanAttributeWriter selection = ensure_selection_attribute( bke::GSpanAttributeWriter selection = ensure_selection_attribute(
curves, ATTR_DOMAIN_POINT, CD_PROP_BOOL); curves, bke::AttrDomain::Point, CD_PROP_BOOL);
const VArray<bool> cyclic = curves.cyclic(); const VArray<bool> cyclic = curves.cyclic();
if (deselect) { if (deselect) {
@ -655,12 +656,12 @@ std::optional<FindClosestData> closest_elem_find_screen_space(
const OffsetIndices<int> points_by_curve, const OffsetIndices<int> points_by_curve,
const Span<float3> positions, const Span<float3> positions,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain domain, const bke::AttrDomain domain,
const int2 coord, const int2 coord,
const FindClosestData &initial_closest) const FindClosestData &initial_closest)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
return find_closest_point_to_screen_co(vc.region, return find_closest_point_to_screen_co(vc.region,
vc.rv3d, vc.rv3d,
object, object,
@ -669,7 +670,7 @@ std::optional<FindClosestData> closest_elem_find_screen_space(
float2(coord), float2(coord),
ED_view3d_select_dist_px(), ED_view3d_select_dist_px(),
initial_closest); initial_closest);
case ATTR_DOMAIN_CURVE: case bke::AttrDomain::Curve:
return find_closest_curve_to_screen_co(vc.region, return find_closest_curve_to_screen_co(vc.region,
vc.rv3d, vc.rv3d,
object, object,
@ -689,7 +690,7 @@ bool select_box(const ViewContext &vc,
bke::CurvesGeometry &curves, bke::CurvesGeometry &curves,
const Span<float3> positions, const Span<float3> positions,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
const rcti &rect, const rcti &rect,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
@ -705,7 +706,7 @@ bool select_box(const ViewContext &vc,
const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact); const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact);
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
if (selection_domain == ATTR_DOMAIN_POINT) { if (selection_domain == bke::AttrDomain::Point) {
mask.foreach_index(GrainSize(1024), [&](const int point_i) { mask.foreach_index(GrainSize(1024), [&](const int point_i) {
const float2 pos_proj = ED_view3d_project_float_v2_m4( const float2 pos_proj = ED_view3d_project_float_v2_m4(
vc.region, positions[point_i], projection); vc.region, positions[point_i], projection);
@ -715,7 +716,7 @@ bool select_box(const ViewContext &vc,
} }
}); });
} }
else if (selection_domain == ATTR_DOMAIN_CURVE) { else if (selection_domain == bke::AttrDomain::Curve) {
mask.foreach_index(GrainSize(512), [&](const int curve_i) { mask.foreach_index(GrainSize(512), [&](const int curve_i) {
const IndexRange points = points_by_curve[curve_i]; const IndexRange points = points_by_curve[curve_i];
if (points.size() == 1) { if (points.size() == 1) {
@ -751,7 +752,7 @@ bool select_lasso(const ViewContext &vc,
bke::CurvesGeometry &curves, bke::CurvesGeometry &curves,
const Span<float3> positions, const Span<float3> positions,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
const Span<int2> coords, const Span<int2> coords,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
@ -771,7 +772,7 @@ bool select_lasso(const ViewContext &vc,
const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact); const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact);
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
if (selection_domain == ATTR_DOMAIN_POINT) { if (selection_domain == bke::AttrDomain::Point) {
mask.foreach_index(GrainSize(1024), [&](const int point_i) { mask.foreach_index(GrainSize(1024), [&](const int point_i) {
const float2 pos_proj = ED_view3d_project_float_v2_m4( const float2 pos_proj = ED_view3d_project_float_v2_m4(
vc.region, positions[point_i], projection); vc.region, positions[point_i], projection);
@ -785,7 +786,7 @@ bool select_lasso(const ViewContext &vc,
} }
}); });
} }
else if (selection_domain == ATTR_DOMAIN_CURVE) { else if (selection_domain == bke::AttrDomain::Curve) {
mask.foreach_index(GrainSize(512), [&](const int curve_i) { mask.foreach_index(GrainSize(512), [&](const int curve_i) {
const IndexRange points = points_by_curve[curve_i]; const IndexRange points = points_by_curve[curve_i];
if (points.size() == 1) { if (points.size() == 1) {
@ -834,7 +835,7 @@ bool select_circle(const ViewContext &vc,
bke::CurvesGeometry &curves, bke::CurvesGeometry &curves,
const Span<float3> positions, const Span<float3> positions,
const IndexMask &mask, const IndexMask &mask,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
const int2 coord, const int2 coord,
const float radius, const float radius,
const eSelectOp sel_op) const eSelectOp sel_op)
@ -852,7 +853,7 @@ bool select_circle(const ViewContext &vc,
const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact); const float4x4 projection = ED_view3d_ob_project_mat_get(vc.rv3d, vc.obact);
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
if (selection_domain == ATTR_DOMAIN_POINT) { if (selection_domain == bke::AttrDomain::Point) {
mask.foreach_index(GrainSize(1024), [&](const int point_i) { mask.foreach_index(GrainSize(1024), [&](const int point_i) {
const float2 pos_proj = ED_view3d_project_float_v2_m4( const float2 pos_proj = ED_view3d_project_float_v2_m4(
vc.region, positions[point_i], projection); vc.region, positions[point_i], projection);
@ -862,7 +863,7 @@ bool select_circle(const ViewContext &vc,
} }
}); });
} }
else if (selection_domain == ATTR_DOMAIN_CURVE) { else if (selection_domain == bke::AttrDomain::Curve) {
mask.foreach_index(GrainSize(512), [&](const int curve_i) { mask.foreach_index(GrainSize(512), [&](const int curve_i) {
const IndexRange points = points_by_curve[curve_i]; const IndexRange points = points_by_curve[curve_i];
if (points.size() == 1) { if (points.size() == 1) {

24
source/blender/editors/geometry/geometry_attributes.cc
View File

@ -230,7 +230,7 @@ static int geometry_attribute_add_exec(bContext *C, wmOperator *op)
char name[MAX_NAME]; char name[MAX_NAME];
RNA_string_get(op->ptr, "name", name); RNA_string_get(op->ptr, "name", name);
eCustomDataType type = (eCustomDataType)RNA_enum_get(op->ptr, "data_type"); eCustomDataType type = (eCustomDataType)RNA_enum_get(op->ptr, "data_type");
eAttrDomain domain = (eAttrDomain)RNA_enum_get(op->ptr, "domain"); bke::AttrDomain domain = bke::AttrDomain(RNA_enum_get(op->ptr, "domain"));
CustomDataLayer *layer = BKE_id_attribute_new(id, name, type, domain, op->reports); CustomDataLayer *layer = BKE_id_attribute_new(id, name, type, domain, op->reports);
if (layer == nullptr) { if (layer == nullptr) {
@ -282,7 +282,7 @@ void GEOMETRY_OT_attribute_add(wmOperatorType *ot)
prop = RNA_def_enum(ot->srna, prop = RNA_def_enum(ot->srna,
"domain", "domain",
rna_enum_attribute_domain_items, rna_enum_attribute_domain_items,
ATTR_DOMAIN_POINT, int(bke::AttrDomain::Point),
"Domain", "Domain",
"Type of element that attribute is stored on"); "Type of element that attribute is stored on");
RNA_def_enum_funcs(prop, geometry_attribute_domain_itemf); RNA_def_enum_funcs(prop, geometry_attribute_domain_itemf);
@ -341,7 +341,7 @@ static int geometry_color_attribute_add_exec(bContext *C, wmOperator *op)
char name[MAX_NAME]; char name[MAX_NAME];
RNA_string_get(op->ptr, "name", name); RNA_string_get(op->ptr, "name", name);
eCustomDataType type = (eCustomDataType)RNA_enum_get(op->ptr, "data_type"); eCustomDataType type = (eCustomDataType)RNA_enum_get(op->ptr, "data_type");
eAttrDomain domain = (eAttrDomain)RNA_enum_get(op->ptr, "domain"); bke::AttrDomain domain = bke::AttrDomain(RNA_enum_get(op->ptr, "domain"));
CustomDataLayer *layer = BKE_id_attribute_new(id, name, type, domain, op->reports); CustomDataLayer *layer = BKE_id_attribute_new(id, name, type, domain, op->reports);
float color[4]; float color[4];
@ -423,7 +423,7 @@ static int geometry_attribute_convert_exec(bContext *C, wmOperator *op)
if (!ED_geometry_attribute_convert(mesh, if (!ED_geometry_attribute_convert(mesh,
name.c_str(), name.c_str(),
eCustomDataType(RNA_enum_get(op->ptr, "data_type")), eCustomDataType(RNA_enum_get(op->ptr, "data_type")),
eAttrDomain(RNA_enum_get(op->ptr, "domain")), bke::AttrDomain(RNA_enum_get(op->ptr, "domain")),
op->reports)) op->reports))
{ {
return OPERATOR_CANCELLED; return OPERATOR_CANCELLED;
@ -433,7 +433,7 @@ static int geometry_attribute_convert_exec(bContext *C, wmOperator *op)
case ConvertAttributeMode::VertexGroup: { case ConvertAttributeMode::VertexGroup: {
Array<float> src_weights(mesh->verts_num); Array<float> src_weights(mesh->verts_num);
VArray<float> src_varray = *attributes.lookup_or_default<float>( VArray<float> src_varray = *attributes.lookup_or_default<float>(
name, ATTR_DOMAIN_POINT, 0.0f); name, bke::AttrDomain::Point, 0.0f);
src_varray.materialize(src_weights); src_varray.materialize(src_weights);
attributes.remove(name); attributes.remove(name);
@ -500,7 +500,7 @@ void GEOMETRY_OT_color_attribute_add(wmOperatorType *ot)
prop = RNA_def_enum(ot->srna, prop = RNA_def_enum(ot->srna,
"domain", "domain",
rna_enum_color_attribute_domain_items, rna_enum_color_attribute_domain_items,
ATTR_DOMAIN_POINT, int(bke::AttrDomain::Point),
"Domain", "Domain",
"Type of element that attribute is stored on"); "Type of element that attribute is stored on");
@ -679,7 +679,7 @@ static int geometry_attribute_convert_invoke(bContext *C,
PropertyRNA *prop = RNA_struct_find_property(op->ptr, "domain"); PropertyRNA *prop = RNA_struct_find_property(op->ptr, "domain");
if (!RNA_property_is_set(op->ptr, prop)) { if (!RNA_property_is_set(op->ptr, prop)) {
RNA_property_enum_set(op->ptr, prop, meta_data.domain); RNA_property_enum_set(op->ptr, prop, int(meta_data.domain));
} }
prop = RNA_struct_find_property(op->ptr, "data_type"); prop = RNA_struct_find_property(op->ptr, "data_type");
if (!RNA_property_is_set(op->ptr, prop)) { if (!RNA_property_is_set(op->ptr, prop)) {
@ -746,7 +746,7 @@ static int geometry_color_attribute_convert_exec(bContext *C, wmOperator *op)
ED_geometry_attribute_convert(mesh, ED_geometry_attribute_convert(mesh,
name, name,
eCustomDataType(RNA_enum_get(op->ptr, "data_type")), eCustomDataType(RNA_enum_get(op->ptr, "data_type")),
eAttrDomain(RNA_enum_get(op->ptr, "domain")), bke::AttrDomain(RNA_enum_get(op->ptr, "domain")),
op->reports); op->reports);
return OPERATOR_FINISHED; return OPERATOR_FINISHED;
} }
@ -762,7 +762,7 @@ static int geometry_color_attribute_convert_invoke(bContext *C,
PropertyRNA *prop = RNA_struct_find_property(op->ptr, "domain"); PropertyRNA *prop = RNA_struct_find_property(op->ptr, "domain");
if (!RNA_property_is_set(op->ptr, prop)) { if (!RNA_property_is_set(op->ptr, prop)) {
RNA_property_enum_set(op->ptr, prop, meta_data.domain); RNA_property_enum_set(op->ptr, prop, int(meta_data.domain));
} }
prop = RNA_struct_find_property(op->ptr, "data_type"); prop = RNA_struct_find_property(op->ptr, "data_type");
if (!RNA_property_is_set(op->ptr, prop)) { if (!RNA_property_is_set(op->ptr, prop)) {
@ -800,7 +800,7 @@ void GEOMETRY_OT_color_attribute_convert(wmOperatorType *ot)
prop = RNA_def_enum(ot->srna, prop = RNA_def_enum(ot->srna,
"domain", "domain",
rna_enum_color_attribute_domain_items, rna_enum_color_attribute_domain_items,
ATTR_DOMAIN_POINT, int(bke::AttrDomain::Point),
"Domain", "Domain",
"Type of element that attribute is stored on"); "Type of element that attribute is stored on");
RNA_def_property_flag(prop, PROP_SKIP_SAVE); RNA_def_property_flag(prop, PROP_SKIP_SAVE);
@ -840,7 +840,7 @@ void GEOMETRY_OT_attribute_convert(wmOperatorType *ot)
prop = RNA_def_enum(ot->srna, prop = RNA_def_enum(ot->srna,
"domain", "domain",
rna_enum_attribute_domain_items, rna_enum_attribute_domain_items,
ATTR_DOMAIN_POINT, int(bke::AttrDomain::Point),
"Domain", "Domain",
"Which geometry element to move the attribute to"); "Which geometry element to move the attribute to");
RNA_def_enum_funcs(prop, geometry_attribute_domain_itemf); RNA_def_enum_funcs(prop, geometry_attribute_domain_itemf);
@ -854,7 +854,7 @@ void GEOMETRY_OT_attribute_convert(wmOperatorType *ot)
bool ED_geometry_attribute_convert(Mesh *mesh, bool ED_geometry_attribute_convert(Mesh *mesh,
const char *name, const char *name,
const eCustomDataType dst_type, const eCustomDataType dst_type,
const eAttrDomain dst_domain, const blender::bke::AttrDomain dst_domain,
ReportList *reports) ReportList *reports)
{ {
using namespace blender; using namespace blender;

8
source/blender/editors/grease_pencil/intern/grease_pencil_add.cc
View File

@ -1148,19 +1148,19 @@ static bke::CurvesGeometry create_drawing_data(const Span<float3> positions,
curves.transform(matrix); curves.transform(matrix);
SpanAttributeWriter<float> point_radii = attributes.lookup_or_add_for_write_only_span<float>( SpanAttributeWriter<float> point_radii = attributes.lookup_or_add_for_write_only_span<float>(
"radius", ATTR_DOMAIN_POINT); "radius", AttrDomain::Point);
point_radii.span.copy_from(radii); point_radii.span.copy_from(radii);
SpanAttributeWriter<float> point_opacities = attributes.lookup_or_add_for_write_span<float>( SpanAttributeWriter<float> point_opacities = attributes.lookup_or_add_for_write_span<float>(
"opacity", ATTR_DOMAIN_POINT); "opacity", AttrDomain::Point);
point_opacities.span.copy_from(opacities); point_opacities.span.copy_from(opacities);
SpanAttributeWriter<bool> stroke_cyclic = attributes.lookup_or_add_for_write_span<bool>( SpanAttributeWriter<bool> stroke_cyclic = attributes.lookup_or_add_for_write_span<bool>(
"cyclic", ATTR_DOMAIN_CURVE); "cyclic", AttrDomain::Curve);
stroke_cyclic.span.fill(false); stroke_cyclic.span.fill(false);
SpanAttributeWriter<int> stroke_materials = attributes.lookup_or_add_for_write_span<int>( SpanAttributeWriter<int> stroke_materials = attributes.lookup_or_add_for_write_span<int>(
"material_index", ATTR_DOMAIN_CURVE); "material_index", AttrDomain::Curve);
stroke_materials.span.copy_from(materials); stroke_materials.span.copy_from(materials);
point_radii.finish(); point_radii.finish();

37
source/blender/editors/grease_pencil/intern/grease_pencil_edit.cc
View File

@ -329,7 +329,7 @@ static int grease_pencil_stroke_smooth_exec(bContext *C, wmOperator *op)
const OffsetIndices points_by_curve = curves.points_by_curve(); const OffsetIndices points_by_curve = curves.points_by_curve();
const VArray<bool> cyclic = curves.cyclic(); const VArray<bool> cyclic = curves.cyclic();
const VArray<bool> point_selection = *curves.attributes().lookup_or_default<bool>( const VArray<bool> point_selection = *curves.attributes().lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
if (smooth_position) { if (smooth_position) {
bke::GSpanAttributeWriter positions = attributes.lookup_for_write_span("position"); bke::GSpanAttributeWriter positions = attributes.lookup_for_write_span("position");
@ -517,7 +517,7 @@ static int grease_pencil_stroke_simplify_exec(bContext *C, wmOperator *op)
const VArray<bool> cyclic = curves.cyclic(); const VArray<bool> cyclic = curves.cyclic();
const OffsetIndices<int> points_by_curve = curves.points_by_curve(); const OffsetIndices<int> points_by_curve = curves.points_by_curve();
const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>( const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
/* Mark all points in the editable curves to be deleted. */ /* Mark all points in the editable curves to be deleted. */
Array<bool> points_to_delete(curves.points_num(), false); Array<bool> points_to_delete(curves.points_num(), false);
@ -663,11 +663,12 @@ static bke::CurvesGeometry remove_points_and_split(const bke::CurvesGeometry &cu
/* Transfer curve attributes. */ /* Transfer curve attributes. */
gather_attributes( gather_attributes(
src_attributes, ATTR_DOMAIN_CURVE, {}, {"cyclic"}, dst_to_src_curve, dst_attributes); src_attributes, bke::AttrDomain::Curve, {}, {"cyclic"}, dst_to_src_curve, dst_attributes);
array_utils::copy(dst_cyclic.as_span(), dst_curves.cyclic_for_write()); array_utils::copy(dst_cyclic.as_span(), dst_curves.cyclic_for_write());
/* Transfer point attributes. */ /* Transfer point attributes. */
gather_attributes(src_attributes, ATTR_DOMAIN_POINT, {}, {}, dst_to_src_point, dst_attributes); gather_attributes(
src_attributes, bke::AttrDomain::Point, {}, {}, dst_to_src_point, dst_attributes);
dst_curves.remove_attributes_based_on_types(); dst_curves.remove_attributes_based_on_types();
@ -680,7 +681,8 @@ static int grease_pencil_delete_exec(bContext *C, wmOperator * /*op*/)
Object *object = CTX_data_active_object(C); Object *object = CTX_data_active_object(C);
GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data); GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data);
const eAttrDomain selection_domain = ED_grease_pencil_selection_domain_get(scene->toolsettings); const bke::AttrDomain selection_domain = ED_grease_pencil_selection_domain_get(
scene->toolsettings);
bool changed = false; bool changed = false;
const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil); const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil);
@ -693,10 +695,10 @@ static int grease_pencil_delete_exec(bContext *C, wmOperator * /*op*/)
} }
bke::CurvesGeometry &curves = info.drawing.strokes_for_write(); bke::CurvesGeometry &curves = info.drawing.strokes_for_write();
if (selection_domain == ATTR_DOMAIN_CURVE) { if (selection_domain == bke::AttrDomain::Curve) {
curves.remove_curves(elements); curves.remove_curves(elements);
} }
else if (selection_domain == ATTR_DOMAIN_POINT) { else if (selection_domain == bke::AttrDomain::Point) {
curves = remove_points_and_split(curves, elements); curves = remove_points_and_split(curves, elements);
} }
info.drawing.tag_topology_changed(); info.drawing.tag_topology_changed();
@ -760,7 +762,7 @@ static Array<bool> get_points_to_dissolve(bke::CurvesGeometry &curves,
const DissolveMode mode) const DissolveMode mode)
{ {
const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>( const VArray<bool> selection = *curves.attributes().lookup_or_default<bool>(
".selection", ATTR_DOMAIN_POINT, true); ".selection", bke::AttrDomain::Point, true);
Array<bool> points_to_dissolve(curves.points_num(), false); Array<bool> points_to_dissolve(curves.points_num(), false);
selection.materialize(mask, points_to_dissolve); selection.materialize(mask, points_to_dissolve);
@ -994,7 +996,7 @@ static int grease_pencil_stroke_material_set_exec(bContext *C, wmOperator * /*op
bke::CurvesGeometry &curves = info.drawing.strokes_for_write(); bke::CurvesGeometry &curves = info.drawing.strokes_for_write();
bke::SpanAttributeWriter<int> materials = bke::SpanAttributeWriter<int> materials =
curves.attributes_for_write().lookup_or_add_for_write_span<int>("material_index", curves.attributes_for_write().lookup_or_add_for_write_span<int>("material_index",
ATTR_DOMAIN_CURVE); bke::AttrDomain::Curve);
index_mask::masked_fill(materials.span, material_index, strokes); index_mask::masked_fill(materials.span, material_index, strokes);
materials.finish(); materials.finish();
}); });
@ -1139,7 +1141,7 @@ static int grease_pencil_set_active_material_exec(bContext *C, wmOperator * /*op
bke::CurvesGeometry &curves = info.drawing.strokes_for_write(); bke::CurvesGeometry &curves = info.drawing.strokes_for_write();
const VArray<int> materials = *curves.attributes().lookup_or_default<int>( const VArray<int> materials = *curves.attributes().lookup_or_default<int>(
"material_index", ATTR_DOMAIN_CURVE, 0); "material_index", bke::AttrDomain::Curve, 0);
object->actcol = materials[strokes.first()] + 1; object->actcol = materials[strokes.first()] + 1;
break; break;
}; };
@ -1378,9 +1380,9 @@ static int grease_pencil_caps_set_exec(bContext *C, wmOperator *op)
if (ELEM(mode, CapsMode::ROUND, CapsMode::FLAT)) { if (ELEM(mode, CapsMode::ROUND, CapsMode::FLAT)) {
bke::SpanAttributeWriter<int8_t> start_caps = bke::SpanAttributeWriter<int8_t> start_caps =
attributes.lookup_or_add_for_write_span<int8_t>("start_cap", ATTR_DOMAIN_CURVE); attributes.lookup_or_add_for_write_span<int8_t>("start_cap", bke::AttrDomain::Curve);
bke::SpanAttributeWriter<int8_t> end_caps = attributes.lookup_or_add_for_write_span<int8_t>( bke::SpanAttributeWriter<int8_t> end_caps = attributes.lookup_or_add_for_write_span<int8_t>(
"end_cap", ATTR_DOMAIN_CURVE); "end_cap", bke::AttrDomain::Curve);
const int8_t flag_set = (mode == CapsMode::ROUND) ? int8_t(GP_STROKE_CAP_TYPE_ROUND) : const int8_t flag_set = (mode == CapsMode::ROUND) ? int8_t(GP_STROKE_CAP_TYPE_ROUND) :
int8_t(GP_STROKE_CAP_TYPE_FLAT); int8_t(GP_STROKE_CAP_TYPE_FLAT);
@ -1394,14 +1396,14 @@ static int grease_pencil_caps_set_exec(bContext *C, wmOperator *op)
switch (mode) { switch (mode) {
case CapsMode::START: { case CapsMode::START: {
bke::SpanAttributeWriter<int8_t> caps = attributes.lookup_or_add_for_write_span<int8_t>( bke::SpanAttributeWriter<int8_t> caps = attributes.lookup_or_add_for_write_span<int8_t>(
"start_cap", ATTR_DOMAIN_CURVE); "start_cap", bke::AttrDomain::Curve);
toggle_caps(caps.span, strokes); toggle_caps(caps.span, strokes);
caps.finish(); caps.finish();
break; break;
} }
case CapsMode::END: { case CapsMode::END: {
bke::SpanAttributeWriter<int8_t> caps = attributes.lookup_or_add_for_write_span<int8_t>( bke::SpanAttributeWriter<int8_t> caps = attributes.lookup_or_add_for_write_span<int8_t>(
"end_cap", ATTR_DOMAIN_CURVE); "end_cap", bke::AttrDomain::Curve);
toggle_caps(caps.span, strokes); toggle_caps(caps.span, strokes);
caps.finish(); caps.finish();
break; break;
@ -1536,7 +1538,8 @@ static int grease_pencil_duplicate_exec(bContext *C, wmOperator * /*op*/)
Object *object = CTX_data_active_object(C); Object *object = CTX_data_active_object(C);
GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data); GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data);
const eAttrDomain selection_domain = ED_grease_pencil_selection_domain_get(scene->toolsettings); const bke::AttrDomain selection_domain = ED_grease_pencil_selection_domain_get(
scene->toolsettings);
std::atomic<bool> changed = false; std::atomic<bool> changed = false;
const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil); const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil);
@ -1549,10 +1552,10 @@ static int grease_pencil_duplicate_exec(bContext *C, wmOperator * /*op*/)
} }
bke::CurvesGeometry &curves = info.drawing.strokes_for_write(); bke::CurvesGeometry &curves = info.drawing.strokes_for_write();
if (selection_domain == ATTR_DOMAIN_CURVE) { if (selection_domain == bke::AttrDomain::Curve) {
curves::duplicate_curves(curves, elements); curves::duplicate_curves(curves, elements);
} }
else if (selection_domain == ATTR_DOMAIN_POINT) { else if (selection_domain == bke::AttrDomain::Point) {
curves::duplicate_points(curves, elements); curves::duplicate_points(curves, elements);
} }
info.drawing.tag_topology_changed(); info.drawing.tag_topology_changed();

2
source/blender/editors/grease_pencil/intern/grease_pencil_material.cc
View File

@ -285,7 +285,7 @@ static int grease_pencil_material_lock_unselected_exec(bContext *C, wmOperator *
AttributeAccessor attributes = info.drawing.strokes().attributes(); AttributeAccessor attributes = info.drawing.strokes().attributes();
const VArray<int> material_indices = *attributes.lookup_or_default<int>( const VArray<int> material_indices = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_CURVE, 0); "material_index", AttrDomain::Curve, 0);
if (const std::optional<int> single = material_indices.get_if_single()) { if (const std::optional<int> single = material_indices.get_if_single()) {
materials_used.add(*single); materials_used.add(*single);

23
source/blender/editors/grease_pencil/intern/grease_pencil_select.cc
View File

@ -34,7 +34,7 @@ static int select_all_exec(bContext *C, wmOperator *op)
Scene *scene = CTX_data_scene(C); Scene *scene = CTX_data_scene(C);
Object *object = CTX_data_active_object(C); Object *object = CTX_data_active_object(C);
GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data); GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data);
eAttrDomain selection_domain = ED_grease_pencil_selection_domain_get(scene->toolsettings); bke::AttrDomain selection_domain = ED_grease_pencil_selection_domain_get(scene->toolsettings);
const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil); const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil);
threading::parallel_for_each(drawings, [&](const MutableDrawingInfo &info) { threading::parallel_for_each(drawings, [&](const MutableDrawingInfo &info) {
@ -191,7 +191,7 @@ static int select_random_exec(bContext *C, wmOperator *op)
Scene *scene = CTX_data_scene(C); Scene *scene = CTX_data_scene(C);
Object *object = CTX_data_active_object(C); Object *object = CTX_data_active_object(C);
GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data); GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data);
eAttrDomain selection_domain = ED_grease_pencil_selection_domain_get(scene->toolsettings); bke::AttrDomain selection_domain = ED_grease_pencil_selection_domain_get(scene->toolsettings);
const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil); const Array<MutableDrawingInfo> drawings = retrieve_editable_drawings(*scene, grease_pencil);
threading::parallel_for_each(drawings, [&](const MutableDrawingInfo &info) { threading::parallel_for_each(drawings, [&](const MutableDrawingInfo &info) {
@ -310,7 +310,7 @@ static int select_ends_exec(bContext *C, wmOperator *op)
const bool was_anything_selected = ed::curves::has_anything_selected(curves, const bool was_anything_selected = ed::curves::has_anything_selected(curves,
selectable_points); selectable_points);
bke::GSpanAttributeWriter selection = ed::curves::ensure_selection_attribute( bke::GSpanAttributeWriter selection = ed::curves::ensure_selection_attribute(
curves, ATTR_DOMAIN_POINT, CD_PROP_BOOL); curves, bke::AttrDomain::Point, CD_PROP_BOOL);
if (!was_anything_selected) { if (!was_anything_selected) {
ed::curves::fill_selection_true(selection.span, selectable_points); ed::curves::fill_selection_true(selection.span, selectable_points);
} }
@ -375,7 +375,7 @@ static int select_set_mode_exec(bContext *C, wmOperator *op)
ts->gpencil_selectmode_edit = mode_new; ts->gpencil_selectmode_edit = mode_new;
/* Convert all drawings of the active GP to the new selection domain. */ /* Convert all drawings of the active GP to the new selection domain. */
const eAttrDomain domain = ED_grease_pencil_selection_domain_get(ts); const bke::AttrDomain domain = ED_grease_pencil_selection_domain_get(ts);
Object *object = CTX_data_active_object(C); Object *object = CTX_data_active_object(C);
GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data); GreasePencil &grease_pencil = *static_cast<GreasePencil *>(object->data);
Span<GreasePencilDrawingBase *> drawings = grease_pencil.drawings(); Span<GreasePencilDrawingBase *> drawings = grease_pencil.drawings();
@ -403,7 +403,7 @@ static int select_set_mode_exec(bContext *C, wmOperator *op)
/* When the new selection domain is 'curve', ensure all curves with a point selection /* When the new selection domain is 'curve', ensure all curves with a point selection
* are selected. */ * are selected. */
if (domain == ATTR_DOMAIN_CURVE) { if (domain == bke::AttrDomain::Curve) {
blender::ed::curves::select_linked(curves); blender::ed::curves::select_linked(curves);
} }
@ -461,20 +461,17 @@ static void GREASE_PENCIL_OT_set_selection_mode(wmOperatorType *ot)
} // namespace blender::ed::greasepencil } // namespace blender::ed::greasepencil
eAttrDomain ED_grease_pencil_selection_domain_get(const ToolSettings *tool_settings) blender::bke::AttrDomain ED_grease_pencil_selection_domain_get(const ToolSettings *tool_settings)
{ {
switch (tool_settings->gpencil_selectmode_edit) { switch (tool_settings->gpencil_selectmode_edit) {
case GP_SELECTMODE_POINT: case GP_SELECTMODE_POINT:
return ATTR_DOMAIN_POINT; return blender::bke::AttrDomain::Point;
break;
case GP_SELECTMODE_STROKE: case GP_SELECTMODE_STROKE:
return ATTR_DOMAIN_CURVE; return blender::bke::AttrDomain::Curve;
break;
case GP_SELECTMODE_SEGMENT: case GP_SELECTMODE_SEGMENT:
return ATTR_DOMAIN_POINT; return blender::bke::AttrDomain::Point;
break;
} }
return ATTR_DOMAIN_POINT; return blender::bke::AttrDomain::Point;
} }
void ED_operatortypes_grease_pencil_select() void ED_operatortypes_grease_pencil_select()

18
source/blender/editors/grease_pencil/intern/grease_pencil_utils.cc
View File

@ -353,7 +353,7 @@ IndexMask retrieve_editable_strokes(Object &object,
const IndexRange curves_range = drawing.strokes().curves_range(); const IndexRange curves_range = drawing.strokes().curves_range();
const bke::AttributeAccessor attributes = curves.attributes(); const bke::AttributeAccessor attributes = curves.attributes();
const VArray<int> materials = *attributes.lookup<int>("material_index", ATTR_DOMAIN_CURVE); const VArray<int> materials = *attributes.lookup<int>("material_index", bke::AttrDomain::Curve);
if (!materials) { if (!materials) {
/* If the attribute does not exist then the default is the first material. */ /* If the attribute does not exist then the default is the first material. */
if (editable_material_indices.contains(0)) { if (editable_material_indices.contains(0)) {
@ -384,7 +384,7 @@ IndexMask retrieve_editable_points(Object &object,
const bke::AttributeAccessor attributes = curves.attributes(); const bke::AttributeAccessor attributes = curves.attributes();
/* Propagate the material index to the points. */ /* Propagate the material index to the points. */
const VArray<int> materials = *attributes.lookup<int>("material_index", ATTR_DOMAIN_POINT); const VArray<int> materials = *attributes.lookup<int>("material_index", bke::AttrDomain::Point);
if (!materials) { if (!materials) {
/* If the attribute does not exist then the default is the first material. */ /* If the attribute does not exist then the default is the first material. */
if (editable_material_indices.contains(0)) { if (editable_material_indices.contains(0)) {
@ -402,13 +402,13 @@ IndexMask retrieve_editable_points(Object &object,
IndexMask retrieve_editable_elements(Object &object, IndexMask retrieve_editable_elements(Object &object,
const bke::greasepencil::Drawing &drawing, const bke::greasepencil::Drawing &drawing,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
IndexMaskMemory &memory) IndexMaskMemory &memory)
{ {
if (selection_domain == ATTR_DOMAIN_CURVE) { if (selection_domain == bke::AttrDomain::Curve) {
return ed::greasepencil::retrieve_editable_strokes(object, drawing, memory); return ed::greasepencil::retrieve_editable_strokes(object, drawing, memory);
} }
else if (selection_domain == ATTR_DOMAIN_POINT) { else if (selection_domain == bke::AttrDomain::Point) {
return ed::greasepencil::retrieve_editable_points(object, drawing, memory); return ed::greasepencil::retrieve_editable_points(object, drawing, memory);
} }
return {}; return {};
@ -433,7 +433,7 @@ IndexMask retrieve_visible_strokes(Object &object,
/* Get all the strokes that have their material visible. */ /* Get all the strokes that have their material visible. */
const VArray<int> materials = *attributes.lookup_or_default<int>( const VArray<int> materials = *attributes.lookup_or_default<int>(
"material_index", ATTR_DOMAIN_CURVE, -1); "material_index", bke::AttrDomain::Curve, -1);
return IndexMask::from_predicate( return IndexMask::from_predicate(
curves_range, GrainSize(4096), memory, [&](const int64_t curve_i) { curves_range, GrainSize(4096), memory, [&](const int64_t curve_i) {
const int material_index = materials[curve_i]; const int material_index = materials[curve_i];
@ -483,13 +483,13 @@ IndexMask retrieve_editable_and_selected_points(Object &object,
IndexMask retrieve_editable_and_selected_elements(Object &object, IndexMask retrieve_editable_and_selected_elements(Object &object,
const bke::greasepencil::Drawing &drawing, const bke::greasepencil::Drawing &drawing,
const eAttrDomain selection_domain, const bke::AttrDomain selection_domain,
IndexMaskMemory &memory) IndexMaskMemory &memory)
{ {
if (selection_domain == ATTR_DOMAIN_CURVE) { if (selection_domain == bke::AttrDomain::Curve) {
return ed::greasepencil::retrieve_editable_and_selected_strokes(object, drawing, memory); return ed::greasepencil::retrieve_editable_and_selected_strokes(object, drawing, memory);
} }
else if (selection_domain == ATTR_DOMAIN_POINT) { else if (selection_domain == bke::AttrDomain::Point) {
return ed::greasepencil::retrieve_editable_and_selected_points(object, drawing, memory); return ed::greasepencil::retrieve_editable_and_selected_points(object, drawing, memory);
} }
return {}; return {};

20
source/blender/editors/include/ED_curves.hh
View File

@ -112,13 +112,13 @@ IndexMask end_points(const bke::CurvesGeometry &curves,
* If set to 0.0, nothing will be in the mask, if set to 1.0 everything will be in the mask. * If set to 0.0, nothing will be in the mask, if set to 1.0 everything will be in the mask.
*/ */
IndexMask random_mask(const bke::CurvesGeometry &curves, IndexMask random_mask(const bke::CurvesGeometry &curves,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
uint32_t random_seed, uint32_t random_seed,
float probability, float probability,
IndexMaskMemory &memory); IndexMaskMemory &memory);
IndexMask random_mask(const bke::CurvesGeometry &curves, IndexMask random_mask(const bke::CurvesGeometry &curves,
const IndexMask &mask, const IndexMask &mask,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
uint32_t random_seed, uint32_t random_seed,
float probability, float probability,
IndexMaskMemory &memory); IndexMaskMemory &memory);
@ -174,7 +174,7 @@ IndexMask retrieve_selected_points(const Curves &curves_id, IndexMaskMemory &mem
* If the ".selection" attribute doesn't exist, create it with the requested type (bool or float). * If the ".selection" attribute doesn't exist, create it with the requested type (bool or float).
*/ */
bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves, bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
eCustomDataType create_type); eCustomDataType create_type);
/** Apply a change to a single curve or point. Avoid using this when affecting many elements. */ /** Apply a change to a single curve or point. Avoid using this when affecting many elements. */
@ -188,10 +188,10 @@ void apply_selection_operation_at_index(GMutableSpan selection, int index, eSele
* \param action: One of SEL_TOGGLE, SEL_SELECT, SEL_DESELECT, or SEL_INVERT. See * \param action: One of SEL_TOGGLE, SEL_SELECT, SEL_DESELECT, or SEL_INVERT. See
* "ED_select_utils.hh". * "ED_select_utils.hh".
*/ */
void select_all(bke::CurvesGeometry &curves, eAttrDomain selection_domain, int action); void select_all(bke::CurvesGeometry &curves, bke::AttrDomain selection_domain, int action);
void select_all(bke::CurvesGeometry &curves, void select_all(bke::CurvesGeometry &curves,
const IndexMask &mask, const IndexMask &mask,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
int action); int action);
/** /**
@ -238,7 +238,7 @@ std::optional<FindClosestData> closest_elem_find_screen_space(const ViewContext
OffsetIndices<int> points_by_curve, OffsetIndices<int> points_by_curve,
Span<float3> deformed_positions, Span<float3> deformed_positions,
const IndexMask &mask, const IndexMask &mask,
eAttrDomain domain, bke::AttrDomain domain,
int2 coord, int2 coord,
const FindClosestData &initial); const FindClosestData &initial);
@ -249,7 +249,7 @@ bool select_box(const ViewContext &vc,
bke::CurvesGeometry &curves, bke::CurvesGeometry &curves,
Span<float3> deformed_positions, Span<float3> deformed_positions,
const IndexMask &mask, const IndexMask &mask,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
const rcti &rect, const rcti &rect,
eSelectOp sel_op); eSelectOp sel_op);
@ -260,7 +260,7 @@ bool select_lasso(const ViewContext &vc,
bke::CurvesGeometry &curves, bke::CurvesGeometry &curves,
Span<float3> deformed_positions, Span<float3> deformed_positions,
const IndexMask &mask, const IndexMask &mask,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
Span<int2> coords, Span<int2> coords,
eSelectOp sel_op); eSelectOp sel_op);
@ -271,7 +271,7 @@ bool select_circle(const ViewContext &vc,
bke::CurvesGeometry &curves, bke::CurvesGeometry &curves,
Span<float3> deformed_positions, Span<float3> deformed_positions,
const IndexMask &mask, const IndexMask &mask,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
int2 coord, int2 coord,
float radius, float radius,
eSelectOp sel_op); eSelectOp sel_op);
@ -285,7 +285,7 @@ bool select_circle(const ViewContext &vc,
* Remove (dissolve) selected curves or points based on the ".selection" attribute. * Remove (dissolve) selected curves or points based on the ".selection" attribute.
* \returns true if any point or curve was removed. * \returns true if any point or curve was removed.
*/ */
bool remove_selection(bke::CurvesGeometry &curves, eAttrDomain selection_domain); bool remove_selection(bke::CurvesGeometry &curves, bke::AttrDomain selection_domain);
void duplicate_points(bke::CurvesGeometry &curves, const IndexMask &mask); void duplicate_points(bke::CurvesGeometry &curves, const IndexMask &mask);
void duplicate_curves(bke::CurvesGeometry &curves, const IndexMask &mask); void duplicate_curves(bke::CurvesGeometry &curves, const IndexMask &mask);

2
source/blender/editors/include/ED_geometry.hh
View File

@ -56,7 +56,7 @@ void ED_operatortypes_geometry();
bool ED_geometry_attribute_convert(Mesh *mesh, bool ED_geometry_attribute_convert(Mesh *mesh,
const char *name, const char *name,
eCustomDataType dst_type, eCustomDataType dst_type,
eAttrDomain dst_domain, blender::bke::AttrDomain dst_domain,
ReportList *reports); ReportList *reports);
namespace blender::ed::geometry { namespace blender::ed::geometry {

8
source/blender/editors/include/ED_grease_pencil.hh
View File

@ -8,7 +8,7 @@
#pragma once #pragma once
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_grease_pencil.hh" #include "BKE_grease_pencil.hh"
#include "BLI_generic_span.hh" #include "BLI_generic_span.hh"
@ -48,7 +48,7 @@ void ED_keymap_grease_pencil(wmKeyConfig *keyconf);
/** /**
* Get the selection mode for Grease Pencil selection operators: point, stroke, segment. * Get the selection mode for Grease Pencil selection operators: point, stroke, segment.
*/ */
eAttrDomain ED_grease_pencil_selection_domain_get(const ToolSettings *tool_settings); blender::bke::AttrDomain ED_grease_pencil_selection_domain_get(const ToolSettings *tool_settings);
/** \} */ /** \} */
@ -178,7 +178,7 @@ IndexMask retrieve_editable_points(Object &object,
IndexMaskMemory &memory); IndexMaskMemory &memory);
IndexMask retrieve_editable_elements(Object &object, IndexMask retrieve_editable_elements(Object &object,
const bke::greasepencil::Drawing &drawing, const bke::greasepencil::Drawing &drawing,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
IndexMaskMemory &memory); IndexMaskMemory &memory);
IndexMask retrieve_visible_strokes(Object &grease_pencil_object, IndexMask retrieve_visible_strokes(Object &grease_pencil_object,
@ -193,7 +193,7 @@ IndexMask retrieve_editable_and_selected_points(Object &object,
IndexMaskMemory &memory); IndexMaskMemory &memory);
IndexMask retrieve_editable_and_selected_elements(Object &object, IndexMask retrieve_editable_and_selected_elements(Object &object,
const bke::greasepencil::Drawing &drawing, const bke::greasepencil::Drawing &drawing,
eAttrDomain selection_domain, bke::AttrDomain selection_domain,
IndexMaskMemory &memory); IndexMaskMemory &memory);
void create_blank(Main &bmain, Object &object, int frame_number); void create_blank(Main &bmain, Object &object, int frame_number);

4
source/blender/editors/interface/interface_template_attribute_search.cc
View File

@ -34,10 +34,10 @@ static StringRef attribute_data_type_string(const eCustomDataType type)
return StringRef(IFACE_(name)); return StringRef(IFACE_(name));
} }
static StringRef attribute_domain_string(const eAttrDomain domain) static StringRef attribute_domain_string(const bke::AttrDomain domain)
{ {
const char *name = nullptr; const char *name = nullptr;
RNA_enum_name_from_value(rna_enum_attribute_domain_items, domain, &name); RNA_enum_name_from_value(rna_enum_attribute_domain_items, int(domain), &name);
return StringRef(IFACE_(name)); return StringRef(IFACE_(name));
} }

104
source/blender/editors/mesh/editface.cc
View File

@ -87,18 +87,19 @@ void paintface_flush_flags(bContext *C,
/* Update the COW copy of the mesh. */ /* Update the COW copy of the mesh. */
if (flush_hidden) { if (flush_hidden) {
const VArray<bool> hide_poly_me = *attributes_me.lookup_or_default<bool>( const VArray<bool> hide_poly_me = *attributes_me.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
bke::SpanAttributeWriter<bool> hide_poly_orig = bke::SpanAttributeWriter<bool> hide_poly_orig =
attributes_orig.lookup_or_add_for_write_only_span<bool>(".hide_poly", ATTR_DOMAIN_FACE); attributes_orig.lookup_or_add_for_write_only_span<bool>(".hide_poly",
bke::AttrDomain::Face);
hide_poly_me.materialize(hide_poly_orig.span); hide_poly_me.materialize(hide_poly_orig.span);
hide_poly_orig.finish(); hide_poly_orig.finish();
} }
if (flush_selection) { if (flush_selection) {
const VArray<bool> select_poly_me = *attributes_me.lookup_or_default<bool>( const VArray<bool> select_poly_me = *attributes_me.lookup_or_default<bool>(
".select_poly", ATTR_DOMAIN_FACE, false); ".select_poly", bke::AttrDomain::Face, false);
bke::SpanAttributeWriter<bool> select_poly_orig = bke::SpanAttributeWriter<bool> select_poly_orig =
attributes_orig.lookup_or_add_for_write_only_span<bool>(".select_poly", attributes_orig.lookup_or_add_for_write_only_span<bool>(".select_poly",
ATTR_DOMAIN_FACE); bke::AttrDomain::Face);
select_poly_me.materialize(select_poly_orig.span); select_poly_me.materialize(select_poly_orig.span);
select_poly_orig.finish(); select_poly_orig.finish();
} }
@ -107,10 +108,10 @@ void paintface_flush_flags(bContext *C,
if ((index_array = (const int *)CustomData_get_layer(&me_eval->face_data, CD_ORIGINDEX))) { if ((index_array = (const int *)CustomData_get_layer(&me_eval->face_data, CD_ORIGINDEX))) {
if (flush_hidden) { if (flush_hidden) {
const VArray<bool> hide_poly_orig = *attributes_orig.lookup_or_default<bool>( const VArray<bool> hide_poly_orig = *attributes_orig.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
bke::SpanAttributeWriter<bool> hide_poly_eval = bke::SpanAttributeWriter<bool> hide_poly_eval =
attributes_eval.lookup_or_add_for_write_only_span<bool>(".hide_poly", attributes_eval.lookup_or_add_for_write_only_span<bool>(".hide_poly",
ATTR_DOMAIN_FACE); bke::AttrDomain::Face);
for (const int i : IndexRange(me_eval->faces_num)) { for (const int i : IndexRange(me_eval->faces_num)) {
const int orig_face_index = index_array[i]; const int orig_face_index = index_array[i];
if (orig_face_index != ORIGINDEX_NONE) { if (orig_face_index != ORIGINDEX_NONE) {
@ -121,10 +122,10 @@ void paintface_flush_flags(bContext *C,
} }
if (flush_selection) { if (flush_selection) {
const VArray<bool> select_poly_orig = *attributes_orig.lookup_or_default<bool>( const VArray<bool> select_poly_orig = *attributes_orig.lookup_or_default<bool>(
".select_poly", ATTR_DOMAIN_FACE, false); ".select_poly", bke::AttrDomain::Face, false);
bke::SpanAttributeWriter<bool> select_poly_eval = bke::SpanAttributeWriter<bool> select_poly_eval =
attributes_eval.lookup_or_add_for_write_only_span<bool>(".select_poly", attributes_eval.lookup_or_add_for_write_only_span<bool>(".select_poly",
ATTR_DOMAIN_FACE); bke::AttrDomain::Face);
for (const int i : IndexRange(me_eval->faces_num)) { for (const int i : IndexRange(me_eval->faces_num)) {
const int orig_face_index = index_array[i]; const int orig_face_index = index_array[i];
if (orig_face_index != ORIGINDEX_NONE) { if (orig_face_index != ORIGINDEX_NONE) {
@ -165,9 +166,9 @@ void paintface_hide(bContext *C, Object *ob, const bool unselected)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_span<bool>(
".hide_poly", ATTR_DOMAIN_FACE); ".hide_poly", bke::AttrDomain::Face);
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
for (int i = 0; i < mesh->faces_num; i++) { for (int i = 0; i < mesh->faces_num; i++) {
if (!hide_poly.span[i]) { if (!hide_poly.span[i]) {
@ -201,9 +202,9 @@ void paintface_reveal(bContext *C, Object *ob, const bool select)
if (select) { if (select) {
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
for (const int i : hide_poly.index_range()) { for (const int i : hide_poly.index_range()) {
if (hide_poly[i]) { if (hide_poly[i]) {
select_poly.span[i] = true; select_poly.span[i] = true;
@ -235,9 +236,9 @@ static void build_poly_connections(blender::AtomicDisjointSet &islands,
const bke::AttributeAccessor attributes = mesh.attributes(); const bke::AttributeAccessor attributes = mesh.attributes();
const VArray<bool> uv_seams = *attributes.lookup_or_default<bool>( const VArray<bool> uv_seams = *attributes.lookup_or_default<bool>(
".uv_seam", ATTR_DOMAIN_EDGE, false); ".uv_seam", bke::AttrDomain::Edge, false);
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
/* Faces are connected if they share edges. By connecting all edges of a loop (as long as they /* Faces are connected if they share edges. By connecting all edges of a loop (as long as they
* are not a seam) we can find connected faces. */ * are not a seam) we can find connected faces. */
@ -284,9 +285,9 @@ static void paintface_select_linked_faces(Mesh &mesh,
bke::MutableAttributeAccessor attributes = mesh.attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
const VArray<bool> uv_seams = *attributes.lookup_or_default<bool>( const VArray<bool> uv_seams = *attributes.lookup_or_default<bool>(
".uv_seam", ATTR_DOMAIN_EDGE, false); ".uv_seam", bke::AttrDomain::Edge, false);
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
Set<int> selected_roots; Set<int> selected_roots;
for (const int i : face_indices) { for (const int i : face_indices) {
@ -324,7 +325,7 @@ void paintface_select_linked(bContext *C, Object *ob, const int mval[2], const b
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
Vector<int> indices; Vector<int> indices;
if (mval) { if (mval) {
@ -493,7 +494,7 @@ void paintface_select_loop(bContext *C, Object *ob, const int mval[2], const boo
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
const Span<int> faces_to_closest_edge = edge_to_face_map[closest_edge_index]; const Span<int> faces_to_closest_edge = edge_to_face_map[closest_edge_index];
const bool traced_full_loop = follow_face_loop(faces_to_closest_edge[0], const bool traced_full_loop = follow_face_loop(faces_to_closest_edge[0],
@ -516,7 +517,7 @@ void paintface_select_loop(bContext *C, Object *ob, const int mval[2], const boo
} }
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
/* Toggling behavior. When one of the faces of the picked edge is already selected, /* Toggling behavior. When one of the faces of the picked edge is already selected,
* it deselects the loop instead. */ * it deselects the loop instead. */
@ -560,11 +561,11 @@ void paintface_select_more(Mesh *mesh, const bool face_step)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
const OffsetIndices faces = mesh->faces(); const OffsetIndices faces = mesh->faces();
const Span<int> corner_edges = mesh->corner_edges(); const Span<int> corner_edges = mesh->corner_edges();
@ -614,9 +615,9 @@ void paintface_select_less(Mesh *mesh, const bool face_step)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
const OffsetIndices faces = mesh->faces(); const OffsetIndices faces = mesh->faces();
const Span<int> corner_verts = mesh->corner_verts(); const Span<int> corner_verts = mesh->corner_verts();
@ -663,9 +664,9 @@ bool paintface_deselect_all_visible(bContext *C, Object *ob, int action, bool fl
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write_span<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
if (action == SEL_TOGGLE) { if (action == SEL_TOGGLE) {
action = SEL_SELECT; action = SEL_SELECT;
@ -730,9 +731,9 @@ bool paintface_minmax(Object *ob, float r_min[3], float r_max[3])
const Span<int> corner_verts = mesh->corner_verts(); const Span<int> corner_verts = mesh->corner_verts();
bke::AttributeAccessor attributes = mesh->attributes(); bke::AttributeAccessor attributes = mesh->attributes();
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
const VArray<bool> select_poly = *attributes.lookup_or_default<bool>( const VArray<bool> select_poly = *attributes.lookup_or_default<bool>(
".select_poly", ATTR_DOMAIN_FACE, false); ".select_poly", bke::AttrDomain::Face, false);
for (int i = 0; i < mesh->faces_num; i++) { for (int i = 0; i < mesh->faces_num; i++) {
if (hide_poly[i] || !select_poly[i]) { if (hide_poly[i] || !select_poly[i]) {
@ -766,9 +767,9 @@ bool paintface_mouse_select(bContext *C,
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
bke::AttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write<bool>( bke::AttributeWriter<bool> select_poly = attributes.lookup_or_add_for_write<bool>(
".select_poly", ATTR_DOMAIN_FACE); ".select_poly", bke::AttrDomain::Face);
if (ED_mesh_pick_face(C, ob, mval, ED_MESH_PICK_DEFAULT_FACE_DIST, &index)) { if (ED_mesh_pick_face(C, ob, mval, ED_MESH_PICK_DEFAULT_FACE_DIST, &index)) {
if (index < mesh->faces_num) { if (index < mesh->faces_num) {
@ -840,9 +841,10 @@ void paintvert_flush_flags(Object *ob)
const int *orig_indices = (const int *)CustomData_get_layer(&me_eval->vert_data, CD_ORIGINDEX); const int *orig_indices = (const int *)CustomData_get_layer(&me_eval->vert_data, CD_ORIGINDEX);
const VArray<bool> hide_vert_orig = *attributes_orig.lookup_or_default<bool>( const VArray<bool> hide_vert_orig = *attributes_orig.lookup_or_default<bool>(
".hide_vert", ATTR_DOMAIN_POINT, false); ".hide_vert", bke::AttrDomain::Point, false);
bke::SpanAttributeWriter<bool> hide_vert_eval = bke::SpanAttributeWriter<bool> hide_vert_eval =
attributes_eval.lookup_or_add_for_write_only_span<bool>(".hide_vert", ATTR_DOMAIN_POINT); attributes_eval.lookup_or_add_for_write_only_span<bool>(".hide_vert",
bke::AttrDomain::Point);
if (orig_indices) { if (orig_indices) {
for (const int i : hide_vert_eval.span.index_range()) { for (const int i : hide_vert_eval.span.index_range()) {
if (orig_indices[i] != ORIGINDEX_NONE) { if (orig_indices[i] != ORIGINDEX_NONE) {
@ -856,9 +858,10 @@ void paintvert_flush_flags(Object *ob)
hide_vert_eval.finish(); hide_vert_eval.finish();
const VArray<bool> select_vert_orig = *attributes_orig.lookup_or_default<bool>( const VArray<bool> select_vert_orig = *attributes_orig.lookup_or_default<bool>(
".select_vert", ATTR_DOMAIN_POINT, false); ".select_vert", bke::AttrDomain::Point, false);
bke::SpanAttributeWriter<bool> select_vert_eval = bke::SpanAttributeWriter<bool> select_vert_eval =
attributes_eval.lookup_or_add_for_write_only_span<bool>(".select_vert", ATTR_DOMAIN_POINT); attributes_eval.lookup_or_add_for_write_only_span<bool>(".select_vert",
bke::AttrDomain::Point);
if (orig_indices) { if (orig_indices) {
for (const int i : select_vert_eval.span.index_range()) { for (const int i : select_vert_eval.span.index_range()) {
if (orig_indices[i] != ORIGINDEX_NONE) { if (orig_indices[i] != ORIGINDEX_NONE) {
@ -900,7 +903,7 @@ static void paintvert_select_linked_vertices(bContext *C,
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
Set<int> selected_roots; Set<int> selected_roots;
@ -940,6 +943,7 @@ void paintvert_select_linked_pick(bContext *C,
void paintvert_select_linked(bContext *C, Object *ob) void paintvert_select_linked(bContext *C, Object *ob)
{ {
using namespace blender;
Mesh *mesh = BKE_mesh_from_object(ob); Mesh *mesh = BKE_mesh_from_object(ob);
if (mesh == nullptr || mesh->faces_num == 0) { if (mesh == nullptr || mesh->faces_num == 0) {
return; return;
@ -947,7 +951,7 @@ void paintvert_select_linked(bContext *C, Object *ob)
blender::bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); blender::bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
blender::bke::SpanAttributeWriter<bool> select_vert = blender::bke::SpanAttributeWriter<bool> select_vert =
attributes.lookup_or_add_for_write_span<bool>(".select_vert", ATTR_DOMAIN_POINT); attributes.lookup_or_add_for_write_span<bool>(".select_vert", bke::AttrDomain::Point);
blender::Vector<int> indices; blender::Vector<int> indices;
for (const int i : select_vert.span.index_range()) { for (const int i : select_vert.span.index_range()) {
@ -966,11 +970,11 @@ void paintvert_select_more(Mesh *mesh, const bool face_step)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
const VArray<bool> hide_edge = *attributes.lookup_or_default<bool>( const VArray<bool> hide_edge = *attributes.lookup_or_default<bool>(
".hide_edge", ATTR_DOMAIN_EDGE, false); ".hide_edge", bke::AttrDomain::Edge, false);
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
const OffsetIndices faces = mesh->faces(); const OffsetIndices faces = mesh->faces();
const Span<int> corner_edges = mesh->corner_edges(); const Span<int> corner_edges = mesh->corner_edges();
@ -1024,11 +1028,11 @@ void paintvert_select_less(Mesh *mesh, const bool face_step)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
const VArray<bool> hide_edge = *attributes.lookup_or_default<bool>( const VArray<bool> hide_edge = *attributes.lookup_or_default<bool>(
".hide_edge", ATTR_DOMAIN_EDGE, false); ".hide_edge", bke::AttrDomain::Edge, false);
const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>( const VArray<bool> hide_poly = *attributes.lookup_or_default<bool>(
".hide_poly", ATTR_DOMAIN_FACE, false); ".hide_poly", bke::AttrDomain::Face, false);
const OffsetIndices faces = mesh->faces(); const OffsetIndices faces = mesh->faces();
const Span<int> corner_edges = mesh->corner_edges(); const Span<int> corner_edges = mesh->corner_edges();
@ -1089,9 +1093,9 @@ bool paintvert_deselect_all_visible(Object *ob, int action, bool flush_flags)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>( const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>(
".hide_vert", ATTR_DOMAIN_POINT, false); ".hide_vert", bke::AttrDomain::Point, false);
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
if (action == SEL_TOGGLE) { if (action == SEL_TOGGLE) {
action = SEL_SELECT; action = SEL_SELECT;
@ -1165,9 +1169,9 @@ void paintvert_select_ungrouped(Object *ob, bool extend, bool flush_flags)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>( const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>(
".hide_vert", ATTR_DOMAIN_POINT, false); ".hide_vert", bke::AttrDomain::Point, false);
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
for (const int i : select_vert.span.index_range()) { for (const int i : select_vert.span.index_range()) {
if (!hide_vert[i]) { if (!hide_vert[i]) {
@ -1195,9 +1199,9 @@ void paintvert_hide(bContext *C, Object *ob, const bool unselected)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
bke::SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_span<bool>(
".hide_vert", ATTR_DOMAIN_POINT); ".hide_vert", bke::AttrDomain::Point);
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
for (const int i : hide_vert.span.index_range()) { for (const int i : hide_vert.span.index_range()) {
if (!hide_vert.span[i]) { if (!hide_vert.span[i]) {
@ -1229,9 +1233,9 @@ void paintvert_reveal(bContext *C, Object *ob, const bool select)
bke::MutableAttributeAccessor attributes = mesh->attributes_for_write(); bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>( const VArray<bool> hide_vert = *attributes.lookup_or_default<bool>(
".hide_vert", ATTR_DOMAIN_POINT, false); ".hide_vert", bke::AttrDomain::Point, false);
bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>( bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<bool>(
".select_vert", ATTR_DOMAIN_POINT); ".select_vert", bke::AttrDomain::Point);
for (const int i : select_vert.span.index_range()) { for (const int i : select_vert.span.index_range()) {
if (hide_vert[i]) { if (hide_vert[i]) {

22
source/blender/editors/mesh/editmesh_attribute.cc
View File

@ -10,7 +10,7 @@
#include "BLI_generic_pointer.hh" #include "BLI_generic_pointer.hh"
#include "BLI_math_quaternion.hh" #include "BLI_math_quaternion.hh"
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_context.hh" #include "BKE_context.hh"
#include "BKE_editmesh.hh" #include "BKE_editmesh.hh"
#include "BKE_layer.h" #include "BKE_layer.h"
@ -52,16 +52,16 @@
namespace blender::ed::mesh { namespace blender::ed::mesh {
static char domain_to_htype(const eAttrDomain domain) static char domain_to_htype(const bke::AttrDomain domain)
{ {
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
return BM_VERT; return BM_VERT;
case ATTR_DOMAIN_EDGE: case bke::AttrDomain::Edge:
return BM_EDGE; return BM_EDGE;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
return BM_FACE; return BM_FACE;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
return BM_LOOP; return BM_LOOP;
default: default:
BLI_assert_unreachable(); BLI_assert_unreachable();
@ -188,19 +188,19 @@ static int mesh_set_attribute_exec(bContext *C, wmOperator *op)
conversions.convert_to_uninitialized(type, dst_type, value.get(), dst_buffer); conversions.convert_to_uninitialized(type, dst_type, value.get(), dst_buffer);
const GPointer dst_value(dst_type, dst_buffer); const GPointer dst_value(dst_type, dst_buffer);
switch (BKE_id_attribute_domain(&mesh->id, layer)) { switch (BKE_id_attribute_domain(&mesh->id, layer)) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
bmesh_vert_edge_face_layer_selected_values_set( bmesh_vert_edge_face_layer_selected_values_set(
*bm, BM_VERTS_OF_MESH, dst_value, layer->offset); *bm, BM_VERTS_OF_MESH, dst_value, layer->offset);
break; break;
case ATTR_DOMAIN_EDGE: case bke::AttrDomain::Edge:
bmesh_vert_edge_face_layer_selected_values_set( bmesh_vert_edge_face_layer_selected_values_set(
*bm, BM_EDGES_OF_MESH, dst_value, layer->offset); *bm, BM_EDGES_OF_MESH, dst_value, layer->offset);
break; break;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
bmesh_vert_edge_face_layer_selected_values_set( bmesh_vert_edge_face_layer_selected_values_set(
*bm, BM_FACES_OF_MESH, dst_value, layer->offset); *bm, BM_FACES_OF_MESH, dst_value, layer->offset);
break; break;
case ATTR_DOMAIN_CORNER: case bke::AttrDomain::Corner:
bmesh_loop_layer_selected_values_set(*em, dst_value, layer->offset); bmesh_loop_layer_selected_values_set(*em, dst_value, layer->offset);
break; break;
default: default:
@ -228,7 +228,7 @@ static int mesh_set_attribute_invoke(bContext *C, wmOperator *op, const wmEvent
const CustomDataLayer *layer = BKE_id_attributes_active_get(&mesh->id); const CustomDataLayer *layer = BKE_id_attributes_active_get(&mesh->id);
const eCustomDataType data_type = eCustomDataType(layer->type); const eCustomDataType data_type = eCustomDataType(layer->type);
const eAttrDomain domain = BKE_id_attribute_domain(&mesh->id, layer); const bke::AttrDomain domain = BKE_id_attribute_domain(&mesh->id, layer);
const BMElem *active_elem = BM_mesh_active_elem_get(bm); const BMElem *active_elem = BM_mesh_active_elem_get(bm);
if (!active_elem) { if (!active_elem) {
return WM_operator_props_popup(C, op, event); return WM_operator_props_popup(C, op, event);

17
source/blender/editors/mesh/editmesh_select.cc
View File

@ -24,7 +24,7 @@
#include "BLI_utildefines_stack.h" #include "BLI_utildefines_stack.h"
#include "BLI_vector.hh" #include "BLI_vector.hh"
#include "BKE_attribute.h" #include "BKE_attribute.hh"
#include "BKE_context.hh" #include "BKE_context.hh"
#include "BKE_customdata.hh" #include "BKE_customdata.hh"
#include "BKE_deform.h" #include "BKE_deform.h"
@ -5358,6 +5358,7 @@ void MESH_OT_loop_to_region(wmOperatorType *ot)
static bool edbm_select_by_attribute_poll(bContext *C) static bool edbm_select_by_attribute_poll(bContext *C)
{ {
using namespace blender;
if (!ED_operator_editmesh(C)) { if (!ED_operator_editmesh(C)) {
return false; return false;
} }
@ -5372,7 +5373,7 @@ static bool edbm_select_by_attribute_poll(bContext *C)
CTX_wm_operator_poll_msg_set(C, "The active attribute must have a boolean type"); CTX_wm_operator_poll_msg_set(C, "The active attribute must have a boolean type");
return false; return false;
} }
if (BKE_id_attribute_domain(&mesh->id, layer) == ATTR_DOMAIN_CORNER) { if (BKE_id_attribute_domain(&mesh->id, layer) == bke::AttrDomain::Corner) {
CTX_wm_operator_poll_msg_set( CTX_wm_operator_poll_msg_set(
C, "The active attribute must be on the vertex, edge, or face domain"); C, "The active attribute must be on the vertex, edge, or face domain");
return false; return false;
@ -5380,14 +5381,15 @@ static bool edbm_select_by_attribute_poll(bContext *C)
return true; return true;
} }
static std::optional<BMIterType> domain_to_iter_type(const eAttrDomain domain) static std::optional<BMIterType> domain_to_iter_type(const blender::bke::AttrDomain domain)
{ {
using namespace blender;
switch (domain) { switch (domain) {
case ATTR_DOMAIN_POINT: case bke::AttrDomain::Point:
return BM_VERTS_OF_MESH; return BM_VERTS_OF_MESH;
case ATTR_DOMAIN_EDGE: case bke::AttrDomain::Edge:
return BM_EDGES_OF_MESH; return BM_EDGES_OF_MESH;
case ATTR_DOMAIN_FACE: case bke::AttrDomain::Face:
return BM_FACES_OF_MESH; return BM_FACES_OF_MESH;
default: default:
return std::nullopt; return std::nullopt;
@ -5396,6 +5398,7 @@ static std::optional<BMIterType> domain_to_iter_type(const eAttrDomain domain)
static int edbm_select_by_attribute_exec(bContext *C, wmOperator * /*op*/) static int edbm_select_by_attribute_exec(bContext *C, wmOperator * /*op*/)
{ {
using namespace blender;
const Scene *scene = CTX_data_scene(C); const Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C); ViewLayer *view_layer = CTX_data_view_layer(C);
uint objects_len = 0; uint objects_len = 0;
@ -5414,7 +5417,7 @@ static int edbm_select_by_attribute_exec(bContext *C, wmOperator * /*op*/)
if (layer->type != CD_PROP_BOOL) { if (layer->type != CD_PROP_BOOL) {
continue; continue;
} }
if (BKE_id_attribute_domain(&mesh->id, layer) == ATTR_DOMAIN_CORNER) { if (BKE_id_attribute_domain(&mesh->id, layer) == bke::AttrDomain::Corner) {
continue; continue;
} }
const std::optional<BMIterType> iter_type = domain_to_iter_type( const std::optional<BMIterType> iter_type = domain_to_iter_type(

Some files were not shown because too many files have changed in this diff Show More