2022-02-10 23:07:11 +01:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
* Copyright 2006 Blender Foundation. All rights reserved. */
|
2020-07-03 15:30:04 +02:00
|
|
|
|
|
|
|
/** \file
|
|
|
|
* \ingroup bke
|
2022-02-09 06:00:03 +01:00
|
|
|
* Implementation of generic geometry attributes management. This is built
|
|
|
|
* on top of CustomData, which manages individual domains.
|
2020-07-03 15:30:04 +02:00
|
|
|
*/
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
#include <cstring>
|
2022-07-24 02:59:59 +02:00
|
|
|
#include <optional>
|
2020-07-03 15:30:04 +02:00
|
|
|
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
|
|
|
|
#include "DNA_ID.h"
|
Curves: Rename "Hair" types, variables, and functions to "Curves"
Based on discussions from T95355 and T94193, the plan is to use
the name "Curves" to describe the data-block container for multiple
curves. Eventually this will replace the existing "Curve" data-block.
However, it will be a while before the curve data-block can be replaced
so in order to distinguish the two curve types in the UI, "Hair Curves"
will be used, but eventually changed back to "Curves".
This patch renames "hair-related" files, functions, types, and variable
names to this convention. A deep rename is preferred to keep code
consistent and to avoid any "hair" terminology from leaking, since the
new data-block is meant for all curve types, not just hair use cases.
The downside of this naming is that the difference between "Curve"
and "Curves" has become important. That was considered during
design discussons and deemed acceptable, especially given the
non-permanent nature of the somewhat common conflict.
Some points of interest:
- All DNA compatibility is lost, just like rBf59767ff9729.
- I renamed `ID_HA` to `ID_CV` so there is no complete mismatch.
- `hair_curves` is used where necessary to distinguish from the
existing "curves" plural.
- I didn't rename any of the cycles/rendering code function names,
since that is also used by the old hair particle system.
Differential Revision: https://developer.blender.org/D14007
2022-02-07 18:55:54 +01:00
|
|
|
#include "DNA_curves_types.h"
|
2020-07-03 15:30:04 +02:00
|
|
|
#include "DNA_customdata_types.h"
|
|
|
|
#include "DNA_mesh_types.h"
|
|
|
|
#include "DNA_meshdata_types.h"
|
|
|
|
#include "DNA_pointcloud_types.h"
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
#include "BLI_index_range.hh"
|
2022-08-04 00:16:46 +02:00
|
|
|
#include "BLI_string.h"
|
2020-07-03 15:30:04 +02:00
|
|
|
#include "BLI_string_utf8.h"
|
2022-04-05 20:42:55 +02:00
|
|
|
#include "BLI_string_utils.h"
|
2020-07-03 15:30:04 +02:00
|
|
|
|
2022-08-04 00:16:46 +02:00
|
|
|
#include "BLT_translation.h"
|
|
|
|
|
2020-07-03 15:30:04 +02:00
|
|
|
#include "BKE_attribute.h"
|
Geometry Nodes: new geometry attribute API
Currently, there are two attribute API. The first, defined in `BKE_attribute.h` is
accessible from RNA and C code. The second is implemented with `GeometryComponent`
and is only accessible in C++ code. The second is widely used, but only being
accessible through the `GeometrySet` API makes it awkward to use, and even impossible
for types that don't correspond directly to a geometry component like `CurvesGeometry`.
This patch adds a new attribute API, designed to replace the `GeometryComponent`
attribute API now, and to eventually replace or be the basis of the other one.
The basic idea is that there is an `AttributeAccessor` class that allows code to
interact with a set of attributes owned by some geometry. The accessor itself has
no ownership. `AttributeAccessor` is a simple type that can be passed around by
value. That makes it easy to return it from functions and to store it in containers.
For const-correctness, there is also a `MutableAttributeAccessor` that allows
changing individual and can add or remove attributes.
Currently, `AttributeAccessor` is composed of two pointers. The first is a pointer
to the owner of the attribute data. The second is a pointer to a struct with
function pointers, that is similar to a virtual function table. The functions
know how to access attributes on the owner.
The actual attribute access for geometries is still implemented with the `AttributeProvider`
pattern, which makes it easy to support different sources of attributes on a
geometry and simplifies dealing with built-in attributes.
There are different ways to get an attribute accessor for a geometry:
* `GeometryComponent.attributes()`
* `CurvesGeometry.attributes()`
* `bke::mesh_attributes(const Mesh &)`
* `bke::pointcloud_attributes(const PointCloud &)`
All of these also have a `_for_write` variant that returns a `MutabelAttributeAccessor`.
Differential Revision: https://developer.blender.org/D15280
2022-07-08 16:16:56 +02:00
|
|
|
#include "BKE_attribute.hh"
|
2022-07-24 02:59:59 +02:00
|
|
|
#include "BKE_curves.hh"
|
2020-07-03 15:30:04 +02:00
|
|
|
#include "BKE_customdata.h"
|
2021-07-22 14:05:55 +02:00
|
|
|
#include "BKE_editmesh.h"
|
2020-08-04 12:52:04 +02:00
|
|
|
#include "BKE_pointcloud.h"
|
2020-07-03 15:30:04 +02:00
|
|
|
#include "BKE_report.h"
|
|
|
|
|
|
|
|
#include "RNA_access.h"
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
using blender::IndexRange;
|
|
|
|
|
|
|
|
struct DomainInfo {
|
2020-07-03 15:30:04 +02:00
|
|
|
CustomData *customdata;
|
|
|
|
int length;
|
2022-05-30 18:06:39 +02:00
|
|
|
};
|
2020-07-03 15:30:04 +02:00
|
|
|
|
2021-09-09 17:22:20 +02:00
|
|
|
static void get_domains(const ID *id, DomainInfo info[ATTR_DOMAIN_NUM])
|
2020-07-03 15:30:04 +02:00
|
|
|
{
|
|
|
|
memset(info, 0, sizeof(DomainInfo) * ATTR_DOMAIN_NUM);
|
|
|
|
|
|
|
|
switch (GS(id->name)) {
|
|
|
|
case ID_PT: {
|
|
|
|
PointCloud *pointcloud = (PointCloud *)id;
|
|
|
|
info[ATTR_DOMAIN_POINT].customdata = &pointcloud->pdata;
|
|
|
|
info[ATTR_DOMAIN_POINT].length = pointcloud->totpoint;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ID_ME: {
|
|
|
|
Mesh *mesh = (Mesh *)id;
|
2021-07-22 14:05:55 +02:00
|
|
|
BMEditMesh *em = mesh->edit_mesh;
|
2022-05-30 18:06:39 +02:00
|
|
|
if (em != nullptr) {
|
2021-07-22 14:05:55 +02:00
|
|
|
BMesh *bm = em->bm;
|
|
|
|
info[ATTR_DOMAIN_POINT].customdata = &bm->vdata;
|
|
|
|
info[ATTR_DOMAIN_POINT].length = bm->totvert;
|
|
|
|
info[ATTR_DOMAIN_EDGE].customdata = &bm->edata;
|
|
|
|
info[ATTR_DOMAIN_EDGE].length = bm->totedge;
|
|
|
|
info[ATTR_DOMAIN_CORNER].customdata = &bm->ldata;
|
|
|
|
info[ATTR_DOMAIN_CORNER].length = bm->totloop;
|
|
|
|
info[ATTR_DOMAIN_FACE].customdata = &bm->pdata;
|
|
|
|
info[ATTR_DOMAIN_FACE].length = bm->totface;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
info[ATTR_DOMAIN_POINT].customdata = &mesh->vdata;
|
|
|
|
info[ATTR_DOMAIN_POINT].length = mesh->totvert;
|
|
|
|
info[ATTR_DOMAIN_EDGE].customdata = &mesh->edata;
|
|
|
|
info[ATTR_DOMAIN_EDGE].length = mesh->totedge;
|
|
|
|
info[ATTR_DOMAIN_CORNER].customdata = &mesh->ldata;
|
|
|
|
info[ATTR_DOMAIN_CORNER].length = mesh->totloop;
|
|
|
|
info[ATTR_DOMAIN_FACE].customdata = &mesh->pdata;
|
|
|
|
info[ATTR_DOMAIN_FACE].length = mesh->totpoly;
|
|
|
|
}
|
2020-07-03 15:30:04 +02:00
|
|
|
break;
|
|
|
|
}
|
Curves: Rename "Hair" types, variables, and functions to "Curves"
Based on discussions from T95355 and T94193, the plan is to use
the name "Curves" to describe the data-block container for multiple
curves. Eventually this will replace the existing "Curve" data-block.
However, it will be a while before the curve data-block can be replaced
so in order to distinguish the two curve types in the UI, "Hair Curves"
will be used, but eventually changed back to "Curves".
This patch renames "hair-related" files, functions, types, and variable
names to this convention. A deep rename is preferred to keep code
consistent and to avoid any "hair" terminology from leaking, since the
new data-block is meant for all curve types, not just hair use cases.
The downside of this naming is that the difference between "Curve"
and "Curves" has become important. That was considered during
design discussons and deemed acceptable, especially given the
non-permanent nature of the somewhat common conflict.
Some points of interest:
- All DNA compatibility is lost, just like rBf59767ff9729.
- I renamed `ID_HA` to `ID_CV` so there is no complete mismatch.
- `hair_curves` is used where necessary to distinguish from the
existing "curves" plural.
- I didn't rename any of the cycles/rendering code function names,
since that is also used by the old hair particle system.
Differential Revision: https://developer.blender.org/D14007
2022-02-07 18:55:54 +01:00
|
|
|
case ID_CV: {
|
|
|
|
Curves *curves = (Curves *)id;
|
|
|
|
info[ATTR_DOMAIN_POINT].customdata = &curves->geometry.point_data;
|
2022-05-11 01:58:39 +02:00
|
|
|
info[ATTR_DOMAIN_POINT].length = curves->geometry.point_num;
|
Curves: Rename "Hair" types, variables, and functions to "Curves"
Based on discussions from T95355 and T94193, the plan is to use
the name "Curves" to describe the data-block container for multiple
curves. Eventually this will replace the existing "Curve" data-block.
However, it will be a while before the curve data-block can be replaced
so in order to distinguish the two curve types in the UI, "Hair Curves"
will be used, but eventually changed back to "Curves".
This patch renames "hair-related" files, functions, types, and variable
names to this convention. A deep rename is preferred to keep code
consistent and to avoid any "hair" terminology from leaking, since the
new data-block is meant for all curve types, not just hair use cases.
The downside of this naming is that the difference between "Curve"
and "Curves" has become important. That was considered during
design discussons and deemed acceptable, especially given the
non-permanent nature of the somewhat common conflict.
Some points of interest:
- All DNA compatibility is lost, just like rBf59767ff9729.
- I renamed `ID_HA` to `ID_CV` so there is no complete mismatch.
- `hair_curves` is used where necessary to distinguish from the
existing "curves" plural.
- I didn't rename any of the cycles/rendering code function names,
since that is also used by the old hair particle system.
Differential Revision: https://developer.blender.org/D14007
2022-02-07 18:55:54 +01:00
|
|
|
info[ATTR_DOMAIN_CURVE].customdata = &curves->geometry.curve_data;
|
2022-05-11 01:58:39 +02:00
|
|
|
info[ATTR_DOMAIN_CURVE].length = curves->geometry.curve_num;
|
2020-07-03 15:30:04 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-24 02:59:59 +02:00
|
|
|
namespace blender::bke {
|
|
|
|
|
|
|
|
static std::optional<blender::bke::MutableAttributeAccessor> get_attribute_accessor_for_write(
|
|
|
|
ID &id)
|
|
|
|
{
|
|
|
|
switch (GS(id.name)) {
|
|
|
|
case ID_ME: {
|
|
|
|
Mesh &mesh = reinterpret_cast<Mesh &>(id);
|
|
|
|
/* The attribute API isn't implemented for BMesh, so edit mode meshes are not supported. */
|
|
|
|
BLI_assert(mesh.edit_mesh == nullptr);
|
|
|
|
return mesh_attributes_for_write(mesh);
|
|
|
|
}
|
|
|
|
case ID_PT: {
|
|
|
|
PointCloud &pointcloud = reinterpret_cast<PointCloud &>(id);
|
|
|
|
return pointcloud_attributes_for_write(pointcloud);
|
|
|
|
}
|
|
|
|
case ID_CV: {
|
|
|
|
Curves &curves_id = reinterpret_cast<Curves &>(id);
|
|
|
|
CurvesGeometry &curves = CurvesGeometry::wrap(curves_id.geometry);
|
|
|
|
return curves.attributes_for_write();
|
|
|
|
}
|
|
|
|
default: {
|
|
|
|
BLI_assert_unreachable();
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace blender::bke
|
|
|
|
|
2022-06-07 18:55:56 +02:00
|
|
|
bool BKE_id_attributes_supported(const ID *id)
|
2020-08-19 18:12:52 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2020-08-19 18:12:52 +02:00
|
|
|
if (info[domain].customdata) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-05-31 13:20:16 +02:00
|
|
|
bool BKE_attribute_allow_procedural_access(const char *attribute_name)
|
|
|
|
{
|
|
|
|
return blender::bke::allow_procedural_attribute_access(attribute_name);
|
|
|
|
}
|
|
|
|
|
2020-07-03 15:30:04 +02:00
|
|
|
bool BKE_id_attribute_rename(ID *id,
|
2022-06-08 10:42:21 +02:00
|
|
|
const char *old_name,
|
2020-07-03 15:30:04 +02:00
|
|
|
const char *new_name,
|
|
|
|
ReportList *reports)
|
|
|
|
{
|
2022-06-08 10:42:21 +02:00
|
|
|
if (BKE_id_attribute_required(id, old_name)) {
|
2021-07-15 10:23:28 +02:00
|
|
|
BLI_assert_msg(0, "Required attribute name is not editable");
|
2020-08-04 12:52:04 +02:00
|
|
|
return false;
|
|
|
|
}
|
2022-07-25 13:16:59 +02:00
|
|
|
if (STREQ(new_name, "")) {
|
|
|
|
BKE_report(reports, RPT_ERROR, "Attribute name can not be empty");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (STREQ(old_name, new_name)) {
|
|
|
|
return false;
|
|
|
|
}
|
2020-08-04 12:52:04 +02:00
|
|
|
|
2022-06-08 10:42:21 +02:00
|
|
|
CustomDataLayer *layer = BKE_id_attribute_search(
|
|
|
|
id, old_name, CD_MASK_PROP_ALL, ATTR_DOMAIN_MASK_ALL);
|
|
|
|
if (layer == nullptr) {
|
2020-07-03 15:30:04 +02:00
|
|
|
BKE_report(reports, RPT_ERROR, "Attribute is not part of this geometry");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-06-07 14:51:52 +02:00
|
|
|
char result_name[MAX_CUSTOMDATA_LAYER_NAME];
|
|
|
|
BKE_id_attribute_calc_unique_name(id, new_name, result_name);
|
|
|
|
BLI_strncpy_utf8(layer->name, result_name, sizeof(layer->name));
|
|
|
|
|
2020-07-03 15:30:04 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
struct AttrUniqueData {
|
2022-04-05 20:42:55 +02:00
|
|
|
ID *id;
|
2022-05-30 18:06:39 +02:00
|
|
|
};
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
static bool unique_name_cb(void *arg, const char *name)
|
|
|
|
{
|
|
|
|
AttrUniqueData *data = (AttrUniqueData *)arg;
|
|
|
|
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(data->id, info);
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-04-05 20:42:55 +02:00
|
|
|
if (!info[domain].customdata) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-08-30 00:00:46 +02:00
|
|
|
const CustomData *cdata = info[domain].customdata;
|
2022-04-05 20:42:55 +02:00
|
|
|
for (int i = 0; i < cdata->totlayer; i++) {
|
2022-08-30 00:00:46 +02:00
|
|
|
const CustomDataLayer *layer = cdata->layers + i;
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
if (STREQ(layer->name, name)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool BKE_id_attribute_calc_unique_name(ID *id, const char *name, char *outname)
|
|
|
|
{
|
2022-05-30 18:06:39 +02:00
|
|
|
AttrUniqueData data{id};
|
2022-04-05 20:42:55 +02:00
|
|
|
|
2022-08-04 00:16:46 +02:00
|
|
|
/* Set default name if none specified.
|
|
|
|
* NOTE: We only call IFACE_() if needed to avoid locale lookup overhead. */
|
|
|
|
if (!name || name[0] == '\0') {
|
|
|
|
BLI_strncpy(outname, IFACE_("Attribute"), MAX_CUSTOMDATA_LAYER_NAME);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
BLI_strncpy_utf8(outname, name, MAX_CUSTOMDATA_LAYER_NAME);
|
|
|
|
}
|
2022-04-05 20:42:55 +02:00
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
return BLI_uniquename_cb(
|
|
|
|
unique_name_cb, &data, nullptr, '.', outname, MAX_CUSTOMDATA_LAYER_NAME);
|
2022-04-05 20:42:55 +02:00
|
|
|
}
|
|
|
|
|
2020-07-03 15:30:04 +02:00
|
|
|
CustomDataLayer *BKE_id_attribute_new(
|
2022-06-01 06:38:06 +02:00
|
|
|
ID *id, const char *name, const int type, const eAttrDomain domain, ReportList *reports)
|
2020-07-03 15:30:04 +02:00
|
|
|
{
|
2022-07-24 19:46:08 +02:00
|
|
|
using namespace blender::bke;
|
2020-07-03 15:30:04 +02:00
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
CustomData *customdata = info[domain].customdata;
|
2022-05-30 18:06:39 +02:00
|
|
|
if (customdata == nullptr) {
|
2020-07-03 15:30:04 +02:00
|
|
|
BKE_report(reports, RPT_ERROR, "Attribute domain not supported by this geometry type");
|
2022-05-30 18:06:39 +02:00
|
|
|
return nullptr;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
|
2022-04-05 20:42:55 +02:00
|
|
|
char uniquename[MAX_CUSTOMDATA_LAYER_NAME];
|
|
|
|
BKE_id_attribute_calc_unique_name(id, name, uniquename);
|
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
if (GS(id->name) == ID_ME) {
|
|
|
|
Mesh *mesh = reinterpret_cast<Mesh *>(id);
|
|
|
|
if (BMEditMesh *em = mesh->edit_mesh) {
|
|
|
|
BM_data_layer_add_named(em->bm, customdata, type, uniquename);
|
|
|
|
const int index = CustomData_get_named_layer_index(customdata, type, uniquename);
|
|
|
|
return (index == -1) ? nullptr : &(customdata->layers[index]);
|
2021-07-22 14:05:55 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
std::optional<MutableAttributeAccessor> attributes = get_attribute_accessor_for_write(*id);
|
|
|
|
if (!attributes) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
Attributes: Improve custom data initialization options
When allocating new `CustomData` layers, often we do redundant
initialization of arrays. For example, it's common that values are
allocated, set to their default value, and then set to some other
value. This is wasteful, and it negates the benefits of optimizations
to the allocator like D15082. There are two reasons for this. The
first is array-of-structs storage that makes it annoying to initialize
values manually, and the second is confusing options in the Custom Data
API. This patch addresses the latter.
The `CustomData` "alloc type" options are rearranged. Now, besides
the options that use existing layers, there are two remaining:
* `CD_SET_DEFAULT` sets the default value.
* Usually zeroes, but for colors this is white (how it was before).
* Should be used when you add the layer but don't set all values.
* `CD_CONSTRUCT` refers to the "default construct" C++ term.
* Only necessary or defined for non-trivial types like vertex groups.
* Doesn't do anything for trivial types like `int` or `float3`.
* Should be used every other time, when all values will be set.
The attribute API's `AttributeInit` types are updated as well.
To update code, replace `CD_CALLOC` with `CD_SET_DEFAULT` and
`CD_DEFAULT` with `CD_CONSTRUCT`. This doesn't cause any functional
changes yet. Follow-up commits will change to avoid initializing
new layers where the correctness is clear.
Differential Revision: https://developer.blender.org/D15617
2022-08-30 21:54:53 +02:00
|
|
|
attributes->add(uniquename, domain, eCustomDataType(type), AttributeInitDefaultValue());
|
2022-07-24 19:46:08 +02:00
|
|
|
|
2022-04-05 20:42:55 +02:00
|
|
|
const int index = CustomData_get_named_layer_index(customdata, type, uniquename);
|
2022-05-30 18:06:39 +02:00
|
|
|
return (index == -1) ? nullptr : &(customdata->layers[index]);
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
|
2022-06-14 16:25:24 +02:00
|
|
|
CustomDataLayer *BKE_id_attribute_duplicate(ID *id, const char *name, ReportList *reports)
|
2022-06-08 21:10:32 +02:00
|
|
|
{
|
2022-07-24 19:46:08 +02:00
|
|
|
using namespace blender::bke;
|
|
|
|
char uniquename[MAX_CUSTOMDATA_LAYER_NAME];
|
|
|
|
BKE_id_attribute_calc_unique_name(id, name, uniquename);
|
2022-06-08 21:10:32 +02:00
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
if (GS(id->name) == ID_ME) {
|
|
|
|
Mesh *mesh = reinterpret_cast<Mesh *>(id);
|
|
|
|
if (BMEditMesh *em = mesh->edit_mesh) {
|
|
|
|
BLI_assert_unreachable();
|
|
|
|
UNUSED_VARS(em);
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
}
|
2022-06-08 21:10:32 +02:00
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
std::optional<MutableAttributeAccessor> attributes = get_attribute_accessor_for_write(*id);
|
|
|
|
if (!attributes) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2022-06-14 16:25:24 +02:00
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
GAttributeReader src = attributes->lookup(name);
|
|
|
|
if (!src) {
|
|
|
|
BKE_report(reports, RPT_ERROR, "Attribute is not part of this geometry");
|
2022-06-14 16:25:24 +02:00
|
|
|
return nullptr;
|
2022-06-08 21:10:32 +02:00
|
|
|
}
|
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
const eCustomDataType type = cpp_type_to_custom_data_type(src.varray.type());
|
|
|
|
attributes->add(uniquename, src.domain, type, AttributeInitVArray(src.varray));
|
2022-06-08 21:10:32 +02:00
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
return BKE_id_attribute_search(id, uniquename, CD_MASK_PROP_ALL, ATTR_DOMAIN_MASK_ALL);
|
2022-06-08 21:10:32 +02:00
|
|
|
}
|
|
|
|
|
2022-06-08 10:42:21 +02:00
|
|
|
bool BKE_id_attribute_remove(ID *id, const char *name, ReportList *reports)
|
2020-07-03 15:30:04 +02:00
|
|
|
{
|
2022-07-24 02:59:59 +02:00
|
|
|
using namespace blender::bke;
|
2022-08-29 21:45:55 +02:00
|
|
|
if (!name || name[0] == '\0') {
|
|
|
|
BKE_report(reports, RPT_ERROR, "The attribute name must not be empty");
|
|
|
|
return false;
|
|
|
|
}
|
2022-06-08 10:42:21 +02:00
|
|
|
if (BKE_id_attribute_required(id, name)) {
|
2020-08-04 12:52:04 +02:00
|
|
|
BKE_report(reports, RPT_ERROR, "Attribute is required and can't be removed");
|
2020-08-19 18:12:52 +02:00
|
|
|
return false;
|
2020-08-04 12:52:04 +02:00
|
|
|
}
|
|
|
|
|
2022-06-08 10:42:21 +02:00
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
2022-07-24 19:46:08 +02:00
|
|
|
if (GS(id->name) == ID_ME) {
|
|
|
|
Mesh *mesh = reinterpret_cast<Mesh *>(id);
|
|
|
|
if (BMEditMesh *em = mesh->edit_mesh) {
|
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
|
|
|
if (CustomData *data = info[domain].customdata) {
|
|
|
|
if (BM_data_layer_free_named(em->bm, data, name)) {
|
|
|
|
return true;
|
2022-06-08 10:42:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
2022-07-24 19:46:08 +02:00
|
|
|
}
|
2021-07-22 14:05:55 +02:00
|
|
|
}
|
2022-07-24 19:46:08 +02:00
|
|
|
|
|
|
|
std::optional<MutableAttributeAccessor> attributes = get_attribute_accessor_for_write(*id);
|
|
|
|
if (!attributes) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return attributes->remove(name);
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
|
2021-09-09 17:22:20 +02:00
|
|
|
CustomDataLayer *BKE_id_attribute_find(const ID *id,
|
|
|
|
const char *name,
|
|
|
|
const int type,
|
2022-06-01 06:38:06 +02:00
|
|
|
const eAttrDomain domain)
|
2021-09-09 17:22:20 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
CustomData *customdata = info[domain].customdata;
|
2022-05-30 18:06:39 +02:00
|
|
|
if (customdata == nullptr) {
|
|
|
|
return nullptr;
|
2021-09-09 17:22:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < customdata->totlayer; i++) {
|
|
|
|
CustomDataLayer *layer = &customdata->layers[i];
|
|
|
|
if (layer->type == type && STREQ(layer->name, name)) {
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
return nullptr;
|
2021-09-09 17:22:20 +02:00
|
|
|
}
|
|
|
|
|
2022-06-14 17:25:53 +02:00
|
|
|
CustomDataLayer *BKE_id_attribute_search(ID *id,
|
2022-06-01 00:46:09 +02:00
|
|
|
const char *name,
|
2022-06-01 06:38:06 +02:00
|
|
|
const eCustomDataMask type_mask,
|
|
|
|
const eAttrDomainMask domain_mask)
|
2022-06-01 00:46:09 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
2022-06-01 06:38:06 +02:00
|
|
|
for (eAttrDomain domain = ATTR_DOMAIN_POINT; domain < ATTR_DOMAIN_NUM;
|
|
|
|
domain = static_cast<eAttrDomain>((static_cast<int>(domain)) + 1)) {
|
2022-06-01 00:46:09 +02:00
|
|
|
if (!(domain_mask & ATTR_DOMAIN_AS_MASK(domain))) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomData *customdata = info[domain].customdata;
|
2022-06-08 21:10:32 +02:00
|
|
|
if (customdata == nullptr) {
|
2022-06-07 18:38:30 +02:00
|
|
|
continue;
|
2022-06-01 00:46:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < customdata->totlayer; i++) {
|
|
|
|
CustomDataLayer *layer = &customdata->layers[i];
|
|
|
|
if ((CD_TYPE_AS_MASK(layer->type) & type_mask) && STREQ(layer->name, name)) {
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-08 21:10:32 +02:00
|
|
|
return nullptr;
|
2022-06-01 00:46:09 +02:00
|
|
|
}
|
|
|
|
|
2022-06-01 06:38:06 +02:00
|
|
|
int BKE_id_attributes_length(const ID *id, eAttrDomainMask domain_mask, eCustomDataMask mask)
|
2020-07-03 15:30:04 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
int length = 0;
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-09-06 09:27:28 +02:00
|
|
|
const CustomData *customdata = info[domain].customdata;
|
|
|
|
if (customdata == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
2022-04-05 20:42:55 +02:00
|
|
|
|
2022-09-06 09:27:28 +02:00
|
|
|
if ((1 << (int)domain) & domain_mask) {
|
2020-07-03 15:30:04 +02:00
|
|
|
length += CustomData_number_of_layers_typemask(customdata, mask);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomain BKE_id_attribute_domain(const ID *id, const CustomDataLayer *layer)
|
2020-07-03 15:30:04 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-09-06 09:27:28 +02:00
|
|
|
const CustomData *customdata = info[domain].customdata;
|
|
|
|
if (customdata == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (ARRAY_HAS_ITEM((CustomDataLayer *)layer, customdata->layers, customdata->totlayer)) {
|
2022-06-01 06:38:06 +02:00
|
|
|
return static_cast<eAttrDomain>(domain);
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-15 10:23:28 +02:00
|
|
|
BLI_assert_msg(0, "Custom data layer not found in geometry");
|
2022-06-01 06:38:06 +02:00
|
|
|
return static_cast<eAttrDomain>(ATTR_DOMAIN_POINT);
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int BKE_id_attribute_data_length(ID *id, CustomDataLayer *layer)
|
|
|
|
{
|
2022-04-21 12:39:09 +02:00
|
|
|
/* When in mesh editmode, attributes point to bmesh customdata layers, the attribute data is
|
|
|
|
* empty since custom data is stored per element instead of a single array there (same es UVs
|
|
|
|
* etc.), see D11998. */
|
|
|
|
switch (GS(id->name)) {
|
|
|
|
case ID_ME: {
|
|
|
|
Mesh *mesh = (Mesh *)id;
|
2022-05-30 18:06:39 +02:00
|
|
|
if (mesh->edit_mesh != nullptr) {
|
2022-04-21 12:39:09 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2022-08-31 07:58:33 +02:00
|
|
|
break;
|
2022-04-21 12:39:09 +02:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-07-03 15:30:04 +02:00
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-09-06 09:27:28 +02:00
|
|
|
const CustomData *customdata = info[domain].customdata;
|
|
|
|
if (customdata == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (ARRAY_HAS_ITEM((CustomDataLayer *)layer, customdata->layers, customdata->totlayer)) {
|
2020-07-03 15:30:04 +02:00
|
|
|
return info[domain].length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-15 10:23:28 +02:00
|
|
|
BLI_assert_msg(0, "Custom data layer not found in geometry");
|
2020-07-03 15:30:04 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-06-08 10:42:21 +02:00
|
|
|
bool BKE_id_attribute_required(const ID *id, const char *name)
|
2020-08-04 12:52:04 +02:00
|
|
|
{
|
|
|
|
switch (GS(id->name)) {
|
|
|
|
case ID_PT: {
|
2022-06-08 10:42:21 +02:00
|
|
|
return BKE_pointcloud_customdata_required((const PointCloud *)id, name);
|
2020-08-04 12:52:04 +02:00
|
|
|
}
|
Curves: Rename "Hair" types, variables, and functions to "Curves"
Based on discussions from T95355 and T94193, the plan is to use
the name "Curves" to describe the data-block container for multiple
curves. Eventually this will replace the existing "Curve" data-block.
However, it will be a while before the curve data-block can be replaced
so in order to distinguish the two curve types in the UI, "Hair Curves"
will be used, but eventually changed back to "Curves".
This patch renames "hair-related" files, functions, types, and variable
names to this convention. A deep rename is preferred to keep code
consistent and to avoid any "hair" terminology from leaking, since the
new data-block is meant for all curve types, not just hair use cases.
The downside of this naming is that the difference between "Curve"
and "Curves" has become important. That was considered during
design discussons and deemed acceptable, especially given the
non-permanent nature of the somewhat common conflict.
Some points of interest:
- All DNA compatibility is lost, just like rBf59767ff9729.
- I renamed `ID_HA` to `ID_CV` so there is no complete mismatch.
- `hair_curves` is used where necessary to distinguish from the
existing "curves" plural.
- I didn't rename any of the cycles/rendering code function names,
since that is also used by the old hair particle system.
Differential Revision: https://developer.blender.org/D14007
2022-02-07 18:55:54 +01:00
|
|
|
case ID_CV: {
|
2022-06-08 10:42:21 +02:00
|
|
|
return BKE_curves_customdata_required((const Curves *)id, name);
|
2020-08-04 12:52:04 +02:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-03 15:30:04 +02:00
|
|
|
CustomDataLayer *BKE_id_attributes_active_get(ID *id)
|
|
|
|
{
|
|
|
|
int active_index = *BKE_id_attributes_active_index_p(id);
|
2022-04-05 20:42:55 +02:00
|
|
|
if (active_index > BKE_id_attributes_length(id, ATTR_DOMAIN_MASK_ALL, CD_MASK_PROP_ALL)) {
|
2020-07-03 15:30:04 +02:00
|
|
|
active_index = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
int index = 0;
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2020-07-03 15:30:04 +02:00
|
|
|
CustomData *customdata = info[domain].customdata;
|
2022-09-06 09:27:28 +02:00
|
|
|
if (customdata == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
for (int i = 0; i < customdata->totlayer; i++) {
|
|
|
|
CustomDataLayer *layer = &customdata->layers[i];
|
|
|
|
if (CD_MASK_PROP_ALL & CD_TYPE_AS_MASK(layer->type)) {
|
|
|
|
if (index == active_index) {
|
|
|
|
if (BKE_attribute_allow_procedural_access(layer->name)) {
|
|
|
|
return layer;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
2022-09-06 09:27:28 +02:00
|
|
|
return nullptr;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
2022-09-06 09:27:28 +02:00
|
|
|
index++;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
return nullptr;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void BKE_id_attributes_active_set(ID *id, CustomDataLayer *active_layer)
|
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
int index = 0;
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-08-30 00:00:46 +02:00
|
|
|
const CustomData *customdata = info[domain].customdata;
|
2022-09-06 09:27:28 +02:00
|
|
|
if (customdata == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
for (int i = 0; i < customdata->totlayer; i++) {
|
|
|
|
const CustomDataLayer *layer = &customdata->layers[i];
|
|
|
|
if (layer == active_layer) {
|
|
|
|
*BKE_id_attributes_active_index_p(id) = index;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (CD_MASK_PROP_ALL & CD_TYPE_AS_MASK(layer->type)) {
|
|
|
|
index++;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int *BKE_id_attributes_active_index_p(ID *id)
|
|
|
|
{
|
|
|
|
switch (GS(id->name)) {
|
|
|
|
case ID_PT: {
|
|
|
|
return &((PointCloud *)id)->attributes_active_index;
|
|
|
|
}
|
|
|
|
case ID_ME: {
|
|
|
|
return &((Mesh *)id)->attributes_active_index;
|
|
|
|
}
|
Curves: Rename "Hair" types, variables, and functions to "Curves"
Based on discussions from T95355 and T94193, the plan is to use
the name "Curves" to describe the data-block container for multiple
curves. Eventually this will replace the existing "Curve" data-block.
However, it will be a while before the curve data-block can be replaced
so in order to distinguish the two curve types in the UI, "Hair Curves"
will be used, but eventually changed back to "Curves".
This patch renames "hair-related" files, functions, types, and variable
names to this convention. A deep rename is preferred to keep code
consistent and to avoid any "hair" terminology from leaking, since the
new data-block is meant for all curve types, not just hair use cases.
The downside of this naming is that the difference between "Curve"
and "Curves" has become important. That was considered during
design discussons and deemed acceptable, especially given the
non-permanent nature of the somewhat common conflict.
Some points of interest:
- All DNA compatibility is lost, just like rBf59767ff9729.
- I renamed `ID_HA` to `ID_CV` so there is no complete mismatch.
- `hair_curves` is used where necessary to distinguish from the
existing "curves" plural.
- I didn't rename any of the cycles/rendering code function names,
since that is also used by the old hair particle system.
Differential Revision: https://developer.blender.org/D14007
2022-02-07 18:55:54 +01:00
|
|
|
case ID_CV: {
|
|
|
|
return &((Curves *)id)->attributes_active_index;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
default:
|
2022-05-30 18:06:39 +02:00
|
|
|
return nullptr;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomData *BKE_id_attributes_iterator_next_domain(ID *id, CustomDataLayer *layers)
|
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
bool use_next = (layers == nullptr);
|
2020-07-03 15:30:04 +02:00
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2020-07-03 15:30:04 +02:00
|
|
|
CustomData *customdata = info[domain].customdata;
|
2022-09-06 09:27:28 +02:00
|
|
|
if (customdata == nullptr) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (customdata->layers && customdata->totlayer) {
|
2020-07-03 15:30:04 +02:00
|
|
|
if (customdata->layers == layers) {
|
|
|
|
use_next = true;
|
|
|
|
}
|
|
|
|
else if (use_next) {
|
|
|
|
return customdata;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
return nullptr;
|
2020-07-03 15:30:04 +02:00
|
|
|
}
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
CustomDataLayer *BKE_id_attribute_from_index(ID *id,
|
|
|
|
int lookup_index,
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomainMask domain_mask,
|
|
|
|
eCustomDataMask layer_mask)
|
2022-04-05 20:42:55 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
int index = 0;
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int domain : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-04-05 20:42:55 +02:00
|
|
|
CustomData *customdata = info[domain].customdata;
|
|
|
|
|
|
|
|
if (!customdata || !((1 << (int)domain) & domain_mask)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < customdata->totlayer; i++) {
|
|
|
|
if (!(layer_mask & CD_TYPE_AS_MASK(customdata->layers[i].type)) ||
|
2022-04-11 18:40:13 +02:00
|
|
|
(customdata->layers[i].flag & CD_FLAG_TEMPORARY)) {
|
2022-04-05 20:42:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (index == lookup_index) {
|
|
|
|
return customdata->layers + i;
|
|
|
|
}
|
|
|
|
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
return nullptr;
|
2022-04-05 20:42:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/** Get list of domain types but with ATTR_DOMAIN_FACE and
|
|
|
|
* ATTR_DOMAIN_CORNER swapped.
|
|
|
|
*/
|
2022-06-01 06:38:06 +02:00
|
|
|
static void get_domains_types(eAttrDomain domains[ATTR_DOMAIN_NUM])
|
2022-04-05 20:42:55 +02:00
|
|
|
{
|
2022-05-30 18:06:39 +02:00
|
|
|
for (const int i : IndexRange(ATTR_DOMAIN_NUM)) {
|
2022-06-01 06:38:06 +02:00
|
|
|
domains[i] = static_cast<eAttrDomain>(i);
|
2022-04-05 20:42:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Swap corner and face. */
|
2022-06-01 06:38:06 +02:00
|
|
|
SWAP(eAttrDomain, domains[ATTR_DOMAIN_FACE], domains[ATTR_DOMAIN_CORNER]);
|
2022-04-05 20:42:55 +02:00
|
|
|
}
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
int BKE_id_attribute_to_index(const ID *id,
|
2022-04-05 20:42:55 +02:00
|
|
|
const CustomDataLayer *layer,
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomainMask domain_mask,
|
|
|
|
eCustomDataMask layer_mask)
|
2022-04-05 20:42:55 +02:00
|
|
|
{
|
|
|
|
if (!layer) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomain domains[ATTR_DOMAIN_NUM];
|
2022-04-05 20:42:55 +02:00
|
|
|
get_domains_types(domains);
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
int index = 0;
|
|
|
|
for (int i = 0; i < ATTR_DOMAIN_NUM; i++) {
|
|
|
|
if (!(domain_mask & (1 << domains[i])) || !info[domains[i]].customdata) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2022-06-08 10:42:21 +02:00
|
|
|
const CustomData *cdata = info[domains[i]].customdata;
|
2022-04-05 20:42:55 +02:00
|
|
|
for (int j = 0; j < cdata->totlayer; j++) {
|
2022-06-08 10:42:21 +02:00
|
|
|
const CustomDataLayer *layer_iter = cdata->layers + j;
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
if (!(CD_TYPE_AS_MASK(layer_iter->type) & layer_mask) ||
|
2022-04-11 18:40:13 +02:00
|
|
|
(layer_iter->flag & CD_FLAG_TEMPORARY)) {
|
2022-04-05 20:42:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (layer == layer_iter) {
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomDataLayer *BKE_id_attribute_subset_active_get(const ID *id,
|
|
|
|
int active_flag,
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomainMask domain_mask,
|
|
|
|
eCustomDataMask mask)
|
2022-04-05 20:42:55 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomain domains[ATTR_DOMAIN_NUM];
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
get_domains_types(domains);
|
|
|
|
get_domains(id, info);
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
CustomDataLayer *candidate = nullptr;
|
2022-04-05 20:42:55 +02:00
|
|
|
for (int i = 0; i < ARRAY_SIZE(domains); i++) {
|
|
|
|
if (!((1 << domains[i]) & domain_mask) || !info[domains[i]].customdata) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomData *cdata = info[domains[i]].customdata;
|
|
|
|
|
|
|
|
for (int j = 0; j < cdata->totlayer; j++) {
|
|
|
|
CustomDataLayer *layer = cdata->layers + j;
|
|
|
|
|
2022-04-11 23:49:37 +02:00
|
|
|
if (!(CD_TYPE_AS_MASK(layer->type) & mask) || (layer->flag & CD_FLAG_TEMPORARY)) {
|
2022-04-05 20:42:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (layer->flag & active_flag) {
|
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
|
|
|
|
candidate = layer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return candidate;
|
|
|
|
}
|
|
|
|
|
|
|
|
void BKE_id_attribute_subset_active_set(ID *id,
|
|
|
|
CustomDataLayer *layer,
|
|
|
|
int active_flag,
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomainMask domain_mask,
|
|
|
|
eCustomDataMask mask)
|
2022-04-05 20:42:55 +02:00
|
|
|
{
|
|
|
|
DomainInfo info[ATTR_DOMAIN_NUM];
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomain domains[ATTR_DOMAIN_NUM];
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
get_domains_types(domains);
|
|
|
|
get_domains(id, info);
|
|
|
|
|
|
|
|
for (int i = 0; i < ATTR_DOMAIN_NUM; i++) {
|
2022-06-01 06:38:06 +02:00
|
|
|
eAttrDomainMask domain_mask2 = (eAttrDomainMask)(1 << domains[i]);
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
if (!(domain_mask2 & domain_mask) || !info[domains[i]].customdata) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomData *cdata = info[domains[i]].customdata;
|
|
|
|
|
|
|
|
for (int j = 0; j < cdata->totlayer; j++) {
|
|
|
|
CustomDataLayer *layer_iter = cdata->layers + j;
|
|
|
|
|
2022-04-11 23:49:37 +02:00
|
|
|
if (!(CD_TYPE_AS_MASK(layer_iter->type) & mask) || (layer_iter->flag & CD_FLAG_TEMPORARY)) {
|
2022-04-05 20:42:55 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
layer_iter->flag &= ~active_flag;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
layer->flag |= active_flag;
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomDataLayer *BKE_id_attributes_active_color_get(const ID *id)
|
|
|
|
{
|
|
|
|
return BKE_id_attribute_subset_active_get(
|
|
|
|
id, CD_FLAG_COLOR_ACTIVE, ATTR_DOMAIN_MASK_COLOR, CD_MASK_COLOR_ALL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BKE_id_attributes_active_color_set(ID *id, CustomDataLayer *active_layer)
|
|
|
|
{
|
|
|
|
BKE_id_attribute_subset_active_set(
|
|
|
|
id, active_layer, CD_FLAG_COLOR_ACTIVE, ATTR_DOMAIN_MASK_COLOR, CD_MASK_COLOR_ALL);
|
|
|
|
}
|
|
|
|
|
|
|
|
CustomDataLayer *BKE_id_attributes_render_color_get(const ID *id)
|
|
|
|
{
|
|
|
|
return BKE_id_attribute_subset_active_get(
|
|
|
|
id, CD_FLAG_COLOR_RENDER, ATTR_DOMAIN_MASK_COLOR, CD_MASK_COLOR_ALL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BKE_id_attributes_render_color_set(ID *id, CustomDataLayer *active_layer)
|
|
|
|
{
|
|
|
|
BKE_id_attribute_subset_active_set(
|
|
|
|
id, active_layer, CD_FLAG_COLOR_RENDER, ATTR_DOMAIN_MASK_COLOR, CD_MASK_COLOR_ALL);
|
|
|
|
}
|
|
|
|
|
2022-04-08 16:37:35 +02:00
|
|
|
CustomDataLayer *BKE_id_attributes_color_find(const ID *id, const char *name)
|
|
|
|
{
|
|
|
|
CustomDataLayer *layer = BKE_id_attribute_find(id, name, CD_PROP_COLOR, ATTR_DOMAIN_POINT);
|
2022-05-30 18:06:39 +02:00
|
|
|
if (layer == nullptr) {
|
2022-04-08 16:37:35 +02:00
|
|
|
layer = BKE_id_attribute_find(id, name, CD_PROP_COLOR, ATTR_DOMAIN_CORNER);
|
|
|
|
}
|
2022-05-30 18:06:39 +02:00
|
|
|
if (layer == nullptr) {
|
2022-04-20 16:10:10 +02:00
|
|
|
layer = BKE_id_attribute_find(id, name, CD_PROP_BYTE_COLOR, ATTR_DOMAIN_POINT);
|
2022-04-08 16:37:35 +02:00
|
|
|
}
|
2022-05-30 18:06:39 +02:00
|
|
|
if (layer == nullptr) {
|
2022-04-20 16:10:10 +02:00
|
|
|
layer = BKE_id_attribute_find(id, name, CD_PROP_BYTE_COLOR, ATTR_DOMAIN_CORNER);
|
2022-04-08 16:37:35 +02:00
|
|
|
}
|
2022-06-01 00:46:09 +02:00
|
|
|
|
2022-04-08 16:37:35 +02:00
|
|
|
return layer;
|
|
|
|
}
|
|
|
|
|
2022-04-05 20:42:55 +02:00
|
|
|
void BKE_id_attribute_copy_domains_temp(short id_type,
|
|
|
|
const CustomData *vdata,
|
|
|
|
const CustomData *edata,
|
|
|
|
const CustomData *ldata,
|
|
|
|
const CustomData *pdata,
|
|
|
|
const CustomData *cdata,
|
|
|
|
ID *r_id)
|
|
|
|
{
|
|
|
|
CustomData reset;
|
|
|
|
|
|
|
|
CustomData_reset(&reset);
|
|
|
|
|
|
|
|
switch (id_type) {
|
|
|
|
case ID_ME: {
|
|
|
|
Mesh *me = (Mesh *)r_id;
|
|
|
|
memset((void *)me, 0, sizeof(*me));
|
|
|
|
|
2022-05-30 18:06:39 +02:00
|
|
|
me->edit_mesh = nullptr;
|
2022-04-05 20:42:55 +02:00
|
|
|
|
|
|
|
me->vdata = vdata ? *vdata : reset;
|
|
|
|
me->edata = edata ? *edata : reset;
|
|
|
|
me->ldata = ldata ? *ldata : reset;
|
|
|
|
me->pdata = pdata ? *pdata : reset;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ID_PT: {
|
|
|
|
PointCloud *pointcloud = (PointCloud *)r_id;
|
|
|
|
|
|
|
|
memset((void *)pointcloud, 0, sizeof(*pointcloud));
|
|
|
|
|
|
|
|
pointcloud->pdata = vdata ? *vdata : reset;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ID_CV: {
|
|
|
|
Curves *curves = (Curves *)r_id;
|
|
|
|
|
|
|
|
memset((void *)curves, 0, sizeof(*curves));
|
|
|
|
|
|
|
|
curves->geometry.point_data = vdata ? *vdata : reset;
|
|
|
|
curves->geometry.curve_data = cdata ? *cdata : reset;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
*((short *)r_id->name) = id_type;
|
|
|
|
}
|