blender
/
blender
129
398
Fork 572
Code Issues 6.2k Pull Requests 747 Projects 19 Wiki Activity

Refactor: Const correct Custom Data API, prepare for CoW 

Currently you can retrieve a mutable array from a const CustomData.
That makes code unsafe since the compiler can't check for correctness
itself. Fix that by introducing a separate function to retrieve mutable
arrays from CustomData. The new functions have the `_for_write`
suffix that make the code's intention clearer.

Because it makes retrieving write access an explicit step, this change
also makes proper copy-on-write possible for attributes.

Notes:
- The previous "duplicate referenced layer" functions are redundant
  with retrieving layers with write access
- The custom data functions that give a specific index only have
  `for_write` to simplify the API

Differential Revision: https://developer.blender.org/D14140
This commit is contained in:
Hans Goudey 2023-01-13 17:21:20 -06:00
parent 4160da187c
commit 3a3d9488a1
Notes: blender-bot 2023-06-07 10:31:13 +02:00 
Referenced by commit 5a97b282e9, Fix (unreported) crash when importing data with custom normals.
Referenced by issue #95842, Prepare custom data API for attribute sharing.
Referenced by issue #107151, Regression: Multires data is not loaded if it comes from an external file
Referenced by commit 34e29440f7, Fix #107151: Multires data from external file is not loaded
76 changed files with 524 additions and 503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
source/blender/blenkernel/BKE_customdata.h
View File

@ -283,21 +283,6 @@ bool CustomData_has_layer(const struct CustomData *data, int type);
int CustomData_number_of_layers(const struct CustomData *data, int type);
int CustomData_number_of_layers_typemask(const struct CustomData *data, eCustomDataMask mask);
/**
* Duplicate data of a layer with flag NOFREE, and remove that flag.
* \return the layer data.
*/
void *CustomData_duplicate_referenced_layer(struct CustomData *data, int type, int totelem);
void *CustomData_duplicate_referenced_layer_n(struct CustomData *data,
int type,
int n,
int totelem);
void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
int type,
const char *name,
int totelem);
bool CustomData_is_referenced_layer(struct CustomData *data, int type);
/**
* Duplicate all the layers with flag NOFREE, and remove the flag from duplicated layers.
*/
@ -409,11 +394,15 @@ void CustomData_swap_corners(struct CustomData *data, int index, const int *corn
void CustomData_swap(struct CustomData *data, int index_a, int index_b);
/**
* Gets a pointer to the data element at index from the first layer of type.
* \return NULL if there is no layer of type.
* Retrieve a pointer to an element of the active layer of the given \a type, chosen by the
* \a index, if it exists.
*/
void *CustomData_get(const struct CustomData *data, int index, int type);
void *CustomData_get_n(const struct CustomData *data, int type, int index, int n);
void *CustomData_get_for_write(struct CustomData *data, int index, int type, int totelem);
/**
* Retrieve a pointer to an element of the \a nth layer of the given \a type, chosen by the
* \a index, if it exists.
*/
void *CustomData_get_n_for_write(struct CustomData *data, int type, int index, int n, int totelem);
/* BMesh Custom Data Functions.
* Should replace edit-mesh ones with these as well, due to more efficient memory alloc. */
@ -431,12 +420,29 @@ bool CustomData_set_layer_name(struct CustomData *data, int type, int n, const c
const char *CustomData_get_layer_name(const struct CustomData *data, int type, int n);
/**
* Gets a pointer to the active or first layer of type.
* \return NULL if there is no layer of type.
* Retrieve the data array of the active layer of the given \a type, if it exists. Return null
* otherwise.
*/
void *CustomData_get_layer(const struct CustomData *data, int type);
void *CustomData_get_layer_n(const struct CustomData *data, int type, int n);
void *CustomData_get_layer_named(const struct CustomData *data, int type, const char *name);
const void *CustomData_get_layer(const struct CustomData *data, int type);
void *CustomData_get_layer_for_write(struct CustomData *data, int type, int totelem);
/**
* Retrieve the data array of the \a nth layer of the given \a type, if it exists. Return null
* otherwise.
*/
const void *CustomData_get_layer_n(const struct CustomData *data, int type, int n);
void *CustomData_get_layer_n_for_write(struct CustomData *data, int type, int n, int totelem);
/**
* Retrieve the data array of the layer with the given \a name and \a type, if it exists. Return
* null otherwise.
*/
const void *CustomData_get_layer_named(const struct CustomData *data, int type, const char *name);
void *CustomData_get_layer_named_for_write(CustomData *data,
int type,
const char *name,
int totelem);
int CustomData_get_offset(const struct CustomData *data, int type);
int CustomData_get_offset_named(const CustomData *data, int type, const char *name);
int CustomData_get_n_offset(const struct CustomData *data, int type, int n);

2
source/blender/blenkernel/BKE_key.h
View File

@ -145,7 +145,7 @@ void BKE_keyblock_convert_to_mesh(const struct KeyBlock *kb,
* \param r_loop_normals: if non-NULL, an array of vectors, same length as number of loops.
*/
void BKE_keyblock_mesh_calc_normals(const struct KeyBlock *kb,
const struct Mesh *mesh,
struct Mesh *mesh,
float (*r_vert_normals)[3],
float (*r_poly_normals)[3],
float (*r_loop_normals)[3]);

15
source/blender/blenkernel/BKE_mesh.h
View File

@ -759,7 +759,8 @@ void BKE_mesh_polygon_flip_ex(const struct MPoly *mpoly,
bool use_loop_mdisp_flip);
void BKE_mesh_polygon_flip(const struct MPoly *mpoly,
struct MLoop *mloop,
struct CustomData *ldata);
struct CustomData *ldata,
int totloop);
/**
* Flip (invert winding of) all polygons (used to inverse their normals).
*
@ -983,7 +984,7 @@ BLI_INLINE const int *BKE_mesh_material_indices(const Mesh *mesh)
*/
BLI_INLINE int *BKE_mesh_material_indices_for_write(Mesh *mesh)
{
int *indices = (int *)CustomData_duplicate_referenced_layer_named(
int *indices = (int *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_INT32, "material_index", mesh->totpoly);
if (indices) {
return indices;
@ -998,7 +999,7 @@ BLI_INLINE const float (*BKE_mesh_vert_positions(const Mesh *mesh))[3]
}
BLI_INLINE float (*BKE_mesh_vert_positions_for_write(Mesh *mesh))[3]
{
return (float(*)[3])CustomData_duplicate_referenced_layer_named(
return (float(*)[3])CustomData_get_layer_named_for_write(
&mesh->vdata, CD_PROP_FLOAT3, "position", mesh->totvert);
}
@ -1008,7 +1009,7 @@ BLI_INLINE const MEdge *BKE_mesh_edges(const Mesh *mesh)
}
BLI_INLINE MEdge *BKE_mesh_edges_for_write(Mesh *mesh)
{
return (MEdge *)CustomData_duplicate_referenced_layer(&mesh->edata, CD_MEDGE, mesh->totedge);
return (MEdge *)CustomData_get_layer_for_write(&mesh->edata, CD_MEDGE, mesh->totedge);
}
BLI_INLINE const MPoly *BKE_mesh_polys(const Mesh *mesh)
@ -1017,7 +1018,7 @@ BLI_INLINE const MPoly *BKE_mesh_polys(const Mesh *mesh)
}
BLI_INLINE MPoly *BKE_mesh_polys_for_write(Mesh *mesh)
{
return (MPoly *)CustomData_duplicate_referenced_layer(&mesh->pdata, CD_MPOLY, mesh->totpoly);
return (MPoly *)CustomData_get_layer_for_write(&mesh->pdata, CD_MPOLY, mesh->totpoly);
}
BLI_INLINE const MLoop *BKE_mesh_loops(const Mesh *mesh)
@ -1026,7 +1027,7 @@ BLI_INLINE const MLoop *BKE_mesh_loops(const Mesh *mesh)
}
BLI_INLINE MLoop *BKE_mesh_loops_for_write(Mesh *mesh)
{
return (MLoop *)CustomData_duplicate_referenced_layer(&mesh->ldata, CD_MLOOP, mesh->totloop);
return (MLoop *)CustomData_get_layer_for_write(&mesh->ldata, CD_MLOOP, mesh->totloop);
}
BLI_INLINE const MDeformVert *BKE_mesh_deform_verts(const Mesh *mesh)
@ -1035,7 +1036,7 @@ BLI_INLINE const MDeformVert *BKE_mesh_deform_verts(const Mesh *mesh)
}
BLI_INLINE MDeformVert *BKE_mesh_deform_verts_for_write(Mesh *mesh)
{
MDeformVert *dvert = (MDeformVert *)CustomData_duplicate_referenced_layer(
MDeformVert *dvert = (MDeformVert *)CustomData_get_layer_for_write(
&mesh->vdata, CD_MDEFORMVERT, mesh->totvert);
if (dvert) {
return dvert;

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

@ -94,8 +94,8 @@ static void editbmesh_calc_modifier_final_normals_or_defer(
static float *dm_getVertArray(DerivedMesh *dm)
{
float(*positions)[3] = (float(*)[3])CustomData_get_layer_named(
&dm->vertData, CD_PROP_FLOAT3, "position");
float(*positions)[3] = (float(*)[3])CustomData_get_layer_named_for_write(
&dm->vertData, CD_PROP_FLOAT3, "position", dm->getNumVerts(dm));
if (!positions) {
positions = (float(*)[3])CustomData_add_layer_named(
@ -109,7 +109,8 @@ static float *dm_getVertArray(DerivedMesh *dm)
static MEdge *dm_getEdgeArray(DerivedMesh *dm)
{
MEdge *medge = (MEdge *)CustomData_get_layer(&dm->edgeData, CD_MEDGE);
MEdge *medge = (MEdge *)CustomData_get_layer_for_write(
&dm->edgeData, CD_MEDGE, dm->getNumEdges(dm));
if (!medge) {
medge = (MEdge *)CustomData_add_layer(
@ -123,7 +124,8 @@ static MEdge *dm_getEdgeArray(DerivedMesh *dm)
static MLoop *dm_getLoopArray(DerivedMesh *dm)
{
MLoop *mloop = (MLoop *)CustomData_get_layer(&dm->loopData, CD_MLOOP);
MLoop *mloop = (MLoop *)CustomData_get_layer_for_write(
&dm->loopData, CD_MLOOP, dm->getNumLoops(dm));
if (!mloop) {
mloop = (MLoop *)CustomData_add_layer(
@ -137,7 +139,8 @@ static MLoop *dm_getLoopArray(DerivedMesh *dm)
static MPoly *dm_getPolyArray(DerivedMesh *dm)
{
MPoly *mpoly = (MPoly *)CustomData_get_layer(&dm->polyData, CD_MPOLY);
MPoly *mpoly = (MPoly *)CustomData_get_layer_for_write(
&dm->polyData, CD_MPOLY, dm->getNumPolys(dm));
if (!mpoly) {
mpoly = (MPoly *)CustomData_add_layer(
@ -351,7 +354,7 @@ static void mesh_set_only_copy(Mesh *mesh, const CustomData_MeshMasks *mask)
void *DM_get_vert_data_layer(DerivedMesh *dm, int type)
{
return CustomData_get_layer(&dm->vertData, type);
return CustomData_get_layer_for_write(&dm->vertData, type, dm->getNumVerts(dm));
}
void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
@ -360,17 +363,17 @@ void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
return dm->getEdgeArray(dm);
}
return CustomData_get_layer(&dm->edgeData, type);
return CustomData_get_layer_for_write(&dm->edgeData, type, dm->getNumEdges(dm));
}
void *DM_get_poly_data_layer(DerivedMesh *dm, int type)
{
return CustomData_get_layer(&dm->polyData, type);
return CustomData_get_layer_for_write(&dm->polyData, type, dm->getNumPolys(dm));
}
void *DM_get_loop_data_layer(DerivedMesh *dm, int type)
{
return CustomData_get_layer(&dm->loopData, type);
return CustomData_get_layer_for_write(&dm->loopData, type, dm->getNumLoops(dm));
}
void DM_copy_vert_data(
@ -499,10 +502,10 @@ static void add_orco_mesh(Object *ob, BMEditMesh *em, Mesh *mesh, Mesh *mesh_orc
BKE_mesh_orco_verts_transform((Mesh *)ob->data, orco, totvert, 0);
}
if (!(layerorco = (float(*)[3])CustomData_get_layer(&mesh->vdata, layer))) {
CustomData_add_layer(&mesh->vdata, layer, CD_SET_DEFAULT, nullptr, mesh->totvert);
layerorco = (float(*)[3])CustomData_get_layer(&mesh->vdata, layer);
layerorco = (float(*)[3])CustomData_get_layer_for_write(&mesh->vdata, layer, mesh->totvert);
if (!layerorco) {
layerorco = (float(*)[3])CustomData_add_layer(
&mesh->vdata, layer, CD_SET_DEFAULT, nullptr, mesh->totvert);
}
memcpy(layerorco, orco, sizeof(float[3]) * totvert);
@ -924,13 +927,16 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
/* Not worth parallelizing this,
* gives less than 0.1% overall speedup in best of best cases... */
range_vn_i((int *)CustomData_get_layer(&mesh_final->vdata, CD_ORIGINDEX),
range_vn_i((int *)CustomData_get_layer_for_write(
&mesh_final->vdata, CD_ORIGINDEX, mesh_final->totvert),
mesh_final->totvert,
0);
range_vn_i((int *)CustomData_get_layer(&mesh_final->edata, CD_ORIGINDEX),
range_vn_i((int *)CustomData_get_layer_for_write(
&mesh_final->edata, CD_ORIGINDEX, mesh_final->totedge),
mesh_final->totedge,
0);
range_vn_i((int *)CustomData_get_layer(&mesh_final->pdata, CD_ORIGINDEX),
range_vn_i((int *)CustomData_get_layer_for_write(
&mesh_final->pdata, CD_ORIGINDEX, mesh_final->totpoly),
mesh_final->totpoly,
0);
}
@ -1932,8 +1938,8 @@ static void mesh_init_origspace(Mesh *mesh)
{
const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
OrigSpaceLoop *lof_array = (OrigSpaceLoop *)CustomData_get_layer(&mesh->ldata,
CD_ORIGSPACE_MLOOP);
OrigSpaceLoop *lof_array = (OrigSpaceLoop *)CustomData_get_layer_for_write(
&mesh->ldata, CD_ORIGSPACE_MLOOP, mesh->totloop);
const int numpoly = mesh->totpoly;
// const int numloop = mesh->totloop;
const Span<float3> positions = mesh->vert_positions();

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

@ -340,11 +340,11 @@ GAttributeWriter BuiltinCustomDataLayerProvider::try_get_for_write(void *owner)
void *data = nullptr;
if (stored_as_named_attribute_) {
data = CustomData_duplicate_referenced_layer_named(
data = CustomData_get_layer_named_for_write(
custom_data, stored_type_, name_.c_str(), element_num);
}
else {
data = CustomData_duplicate_referenced_layer(custom_data, stored_type_, element_num);
data = CustomData_get_layer_for_write(custom_data, stored_type_, element_num);
}
if (data == nullptr) {
return {};
@ -461,7 +461,7 @@ GAttributeWriter CustomDataAttributeProvider::try_get_for_write(
if (!custom_data_layer_matches_attribute_id(layer, attribute_id)) {
continue;
}
CustomData_duplicate_referenced_layer_named(custom_data, layer.type, layer.name, element_num);
CustomData_get_layer_named_for_write(custom_data, layer.type, layer.name, element_num);
const CPPType *type = custom_data_type_to_cpp_type((eCustomDataType)layer.type);
if (type == nullptr) {

9
source/blender/blenkernel/intern/cdderivedmesh.c
View File

@ -221,13 +221,14 @@ static DerivedMesh *cdDM_from_mesh_ex(Mesh *mesh,
CustomData_merge(&mesh->ldata, &dm->loopData, cddata_masks.lmask, alloctype, mesh->totloop);
CustomData_merge(&mesh->pdata, &dm->polyData, cddata_masks.pmask, alloctype, mesh->totpoly);
cddm->vert_positions = CustomData_get_layer_named(&dm->vertData, CD_PROP_FLOAT3, "position");
cddm->vert_positions = CustomData_get_layer_named_for_write(
&dm->vertData, CD_PROP_FLOAT3, "position", mesh->totvert);
/* Though this may be an unnecessary calculation, simply retrieving the layer may return nothing
* or dirty normals. */
cddm->vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
cddm->medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
cddm->mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
cddm->mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
cddm->medge = CustomData_get_layer_for_write(&dm->edgeData, CD_MEDGE, mesh->totedge);
cddm->mloop = CustomData_get_layer_for_write(&dm->loopData, CD_MLOOP, mesh->totloop);
cddm->mpoly = CustomData_get_layer_for_write(&dm->polyData, CD_MPOLY, mesh->totpoly);
#if 0
cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
#else

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

@ -216,8 +216,7 @@ static MutableSpan<T> get_mutable_attribute(CurvesGeometry &curves,
const eCustomDataType type = cpp_type_to_custom_data_type(CPPType::get<T>());
CustomData &custom_data = domain_custom_data(curves, domain);
T *data = (T *)CustomData_duplicate_referenced_layer_named(
&custom_data, type, name.c_str(), num);
T *data = (T *)CustomData_get_layer_named_for_write(&custom_data, type, name.c_str(), num);
if (data != nullptr) {
return {data, num};
}

80
source/blender/blenkernel/intern/customdata.cc
View File

@ -3052,35 +3052,6 @@ static void *customData_duplicate_referenced_layer_index(CustomData *data,
return layer->data;
}
void *CustomData_duplicate_referenced_layer(CustomData *data, const int type, const int totelem)
{
int layer_index = CustomData_get_active_layer_index(data, type);
return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
}
void *CustomData_duplicate_referenced_layer_n(CustomData *data,
const int type,
const int n,
const int totelem)
{
/* get the layer index of the desired layer */
int layer_index = CustomData_get_layer_index_n(data, type, n);
return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
}
void *CustomData_duplicate_referenced_layer_named(CustomData *data,
const int type,
const char *name,
const int totelem)
{
/* get the layer index of the desired layer */
int layer_index = CustomData_get_named_layer_index(data, type, name);
return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
}
void CustomData_duplicate_referenced_layers(CustomData *data, const int totelem)
{
for (int i = 0; i < data->totlayer; i++) {
@ -3089,18 +3060,6 @@ void CustomData_duplicate_referenced_layers(CustomData *data, const int totelem)
}
}
bool CustomData_is_referenced_layer(CustomData *data, const int type)
{
int layer_index = CustomData_get_active_layer_index(data, type);
if (layer_index == -1) {
return false;
}
CustomDataLayer *layer = &data->layers[layer_index];
return (layer->flag & CD_FLAG_NOFREE) != 0;
}
void CustomData_free_temporary(CustomData *data, const int totelem)
{
int i, j;
@ -3415,20 +3374,21 @@ void CustomData_swap(CustomData *data, const int index_a, const int index_b)
}
}
void *CustomData_get(const CustomData *data, const int index, const int type)
void *CustomData_get_for_write(CustomData *data, const int index, const int type, int totelem)
{
BLI_assert(index >= 0);
void *layer_data = CustomData_get_layer(data, type);
void *layer_data = CustomData_get_layer_for_write(data, type, totelem);
if (!layer_data) {
return nullptr;
}
return POINTER_OFFSET(layer_data, size_t(index) * layerType_getInfo(type)->size);
}
void *CustomData_get_n(const CustomData *data, const int type, const int index, const int n)
void *CustomData_get_n_for_write(
CustomData *data, const int type, const int index, const int n, int totelem)
{
BLI_assert(index >= 0);
void *layer_data = CustomData_get_layer_n(data, type, n);
void *layer_data = CustomData_get_layer_n_for_write(data, type, n, totelem);
if (!layer_data) {
return nullptr;
}
@ -3436,7 +3396,7 @@ void *CustomData_get_n(const CustomData *data, const int type, const int index,
return POINTER_OFFSET(layer_data, size_t(index) * layerType_getInfo(type)->size);
}
void *CustomData_get_layer(const CustomData *data, const int type)
const void *CustomData_get_layer(const CustomData *data, const int type)
{
int layer_index = CustomData_get_active_layer_index(data, type);
if (layer_index == -1) {
@ -3446,7 +3406,13 @@ void *CustomData_get_layer(const CustomData *data, const int type)
return data->layers[layer_index].data;
}
void *CustomData_get_layer_n(const CustomData *data, const int type, const int n)
void *CustomData_get_layer_for_write(CustomData *data, const int type, const int totelem)
{
const int layer_index = CustomData_get_active_layer_index(data, type);
return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
}
const void *CustomData_get_layer_n(const CustomData *data, const int type, const int n)
{
int layer_index = CustomData_get_layer_index_n(data, type, n);
if (layer_index == -1) {
@ -3456,7 +3422,16 @@ void *CustomData_get_layer_n(const CustomData *data, const int type, const int n
return data->layers[layer_index].data;
}
void *CustomData_get_layer_named(const CustomData *data, const int type, const char *name)
void *CustomData_get_layer_n_for_write(CustomData *data,
const int type,
const int n,
const int totelem)
{
const int layer_index = CustomData_get_layer_index_n(data, type, n);
return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
}
const void *CustomData_get_layer_named(const CustomData *data, const int type, const char *name)
{
int layer_index = CustomData_get_named_layer_index(data, type, name);
if (layer_index == -1) {
@ -3466,6 +3441,15 @@ void *CustomData_get_layer_named(const CustomData *data, const int type, const c
return data->layers[layer_index].data;
}
void *CustomData_get_layer_named_for_write(CustomData *data,
const int type,
const char *name,
const int totelem)
{
const int layer_index = CustomData_get_named_layer_index(data, type, name);
return customData_duplicate_referenced_layer_index(data, layer_index, totelem);
}
int CustomData_get_offset(const CustomData *data, const int type)
{
int layer_index = CustomData_get_active_layer_index(data, type);

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

@ -277,10 +277,11 @@ static void data_transfer_dtdata_type_preprocess(Mesh *me_src,
float(*loop_nors_dst)[3];
short(*custom_nors_dst)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL));
CustomData_get_layer_for_write(ldata_dst, CD_CUSTOMLOOPNORMAL, me_dst->totloop));
/* Cache loop nors into a temp CDLayer. */
loop_nors_dst = static_cast<float(*)[3]>(CustomData_get_layer(ldata_dst, CD_NORMAL));
loop_nors_dst = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(ldata_dst, CD_NORMAL, me_dst->totloop));
const bool do_loop_nors_dst = (loop_nors_dst == nullptr);
if (do_loop_nors_dst) {
loop_nors_dst = static_cast<float(*)[3]>(
@ -337,9 +338,9 @@ static void data_transfer_dtdata_type_postprocess(Object * /*ob_src*/,
const float(*poly_nors_dst)[3] = BKE_mesh_poly_normals_ensure(me_dst);
float(*loop_nors_dst)[3] = static_cast<float(*)[3]>(
CustomData_get_layer(ldata_dst, CD_NORMAL));
CustomData_get_layer_for_write(ldata_dst, CD_NORMAL, me_dst->totloop));
short(*custom_nors_dst)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL));
CustomData_get_layer_for_write(ldata_dst, CD_CUSTOMLOOPNORMAL, me_dst->totloop));
if (!custom_nors_dst) {
custom_nors_dst = static_cast<short(*)[2]>(CustomData_add_layer(
@ -514,7 +515,6 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
const bool use_delete,
const CustomData *cd_src,
CustomData *cd_dst,
const bool use_dupref_dst,
const int tolayers,
const bool *use_layers_src,
const int num_layers_src,
@ -571,15 +571,7 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
continue;
}
data_src = CustomData_get_layer_n(cd_src, cddata_type, idx_src);
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
if (use_dupref_dst) {
data_dst = CustomData_duplicate_referenced_layer_n(
cd_dst, cddata_type, idx_src, num_elem_dst);
}
else {
data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_src);
}
data_dst = CustomData_get_layer_n_for_write(cd_dst, cddata_type, idx_src, num_elem_dst);
data_transfer_layersmapping_add_item_cd(r_map,
cddata_type,
mix_mode,
@ -627,15 +619,7 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
data_dst_to_delete[idx_dst] = false;
}
if (r_map) {
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
if (use_dupref_dst) {
data_dst = CustomData_duplicate_referenced_layer_n(
cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else {
data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst);
}
data_dst = CustomData_get_layer_n_for_write(cd_dst, cddata_type, idx_dst, num_elem_dst);
data_transfer_layersmapping_add_item_cd(r_map,
cddata_type,
mix_mode,
@ -677,9 +661,8 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
const int num_elem_dst,
const bool use_create,
const bool use_delete,
CustomData *cd_src,
const CustomData *cd_src,
CustomData *cd_dst,
const bool use_dupref_dst,
const int fromlayers,
const int tolayers,
cd_datatransfer_interp interp,
@ -697,18 +680,13 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
return true;
}
data_dst = CustomData_get_layer(cd_dst, cddata_type);
data_dst = CustomData_get_layer_for_write(cd_dst, cddata_type, num_elem_dst);
if (!data_dst) {
if (!use_create) {
return true;
}
data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
}
else if (use_dupref_dst && r_map) {
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
data_dst = CustomData_duplicate_referenced_layer(cd_dst, cddata_type, num_elem_dst);
}
if (r_map) {
data_transfer_layersmapping_add_item_cd(r_map,
@ -740,15 +718,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (tolayers >= 0) { /* Real-layer index */
idx_dst = tolayers;
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
if (use_dupref_dst && r_map) {
data_dst = CustomData_duplicate_referenced_layer_n(
cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else {
data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst);
}
data_dst = CustomData_get_layer_n_for_write(cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else if (tolayers == DT_LAYERS_ACTIVE_DST) {
if ((idx_dst = CustomData_get_active_layer(cd_dst, cddata_type)) == -1) {
@ -759,15 +729,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
}
else {
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
if (use_dupref_dst && r_map) {
data_dst = CustomData_duplicate_referenced_layer_n(
cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else {
data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst);
}
data_dst = CustomData_get_layer_n_for_write(cd_dst, cddata_type, idx_dst, num_elem_dst);
}
}
else if (tolayers == DT_LAYERS_INDEX_DST) {
@ -782,15 +744,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
}
}
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
if (use_dupref_dst && r_map) {
data_dst = CustomData_duplicate_referenced_layer_n(
cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else {
data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst);
}
data_dst = CustomData_get_layer_n_for_write(cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else if (tolayers == DT_LAYERS_NAME_DST) {
const char *name = CustomData_get_layer_name(cd_src, cddata_type, idx_src);
@ -802,15 +756,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst, name);
idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name);
}
/* If dest is a evaluated mesh (from modifier),
* we do not want to overwrite cdlayers of orig mesh! */
if (use_dupref_dst && r_map) {
data_dst = CustomData_duplicate_referenced_layer_n(
cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else {
data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst);
}
data_dst = CustomData_get_layer_n_for_write(cd_dst, cddata_type, idx_dst, num_elem_dst);
}
else {
return false;
@ -853,7 +799,6 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
use_delete,
cd_src,
cd_dst,
use_dupref_dst,
tolayers,
use_layers_src,
num_src,
@ -909,7 +854,6 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
use_delete,
cd_src,
cd_dst,
me_dst != ob_dst->data,
fromlayers,
tolayers,
interp,
@ -962,7 +906,6 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
use_delete,
cd_src,
cd_dst,
me_dst != ob_dst->data,
fromlayers,
tolayers,
interp,
@ -1007,7 +950,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
mix_factor,
mix_weights,
CustomData_get_layer_named(&me_src->edata, CD_PROP_BOOL, "sharp_edge"),
CustomData_get_layer_named(&me_dst->edata, CD_PROP_BOOL, "sharp_edge"),
CustomData_get_layer_named_for_write(
&me_dst->edata, CD_PROP_BOOL, "sharp_edge", me_dst->totedge),
interp,
interp_data);
return true;
@ -1040,7 +984,6 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
use_delete,
cd_src,
cd_dst,
me_dst != ob_dst->data,
fromlayers,
tolayers,
interp,
@ -1072,7 +1015,6 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
use_delete,
cd_src,
cd_dst,
me_dst != ob_dst->data,
fromlayers,
tolayers,
interp,

4
source/blender/blenkernel/intern/deform.c
View File

@ -1395,10 +1395,10 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
const MDeformVert *data_src = CustomData_get_layer(cd_src, CD_MDEFORMVERT);
MDeformVert *data_dst = CustomData_get_layer(cd_dst, CD_MDEFORMVERT);
MDeformVert *data_dst = CustomData_get_layer_for_write(cd_dst, CD_MDEFORMVERT, num_elem_dst);
if (data_dst && use_dupref_dst && r_map) {
/* If dest is a derivedmesh, we do not want to overwrite cdlayers of org mesh! */
data_dst = CustomData_duplicate_referenced_layer(cd_dst, CD_MDEFORMVERT, num_elem_dst);
data_dst = CustomData_get_layer_for_write(cd_dst, CD_MDEFORMVERT, num_elem_dst);
}
if (fromlayers == DT_LAYERS_ACTIVE_SRC || fromlayers >= 0) {

11
source/blender/blenkernel/intern/dynamicpaint.c
View File

@ -1934,8 +1934,8 @@ static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *
}
/* paint layer */
MLoopCol *mloopcol = CustomData_get_layer_named(
&result->ldata, CD_PROP_BYTE_COLOR, surface->output_name);
MLoopCol *mloopcol = CustomData_get_layer_named_for_write(
&result->ldata, CD_PROP_BYTE_COLOR, surface->output_name, result->totloop);
/* if output layer is lost from a constructive modifier, re-add it */
if (!mloopcol && dynamicPaint_outputLayerExists(surface, ob, 0)) {
mloopcol = CustomData_add_layer_named(&result->ldata,
@ -1947,8 +1947,8 @@ static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *
}
/* wet layer */
MLoopCol *mloopcol_wet = CustomData_get_layer_named(
&result->ldata, CD_PROP_BYTE_COLOR, surface->output_name2);
MLoopCol *mloopcol_wet = CustomData_get_layer_named_for_write(
&result->ldata, CD_PROP_BYTE_COLOR, surface->output_name2, result->totloop);
/* if output layer is lost from a constructive modifier, re-add it */
if (!mloopcol_wet && dynamicPaint_outputLayerExists(surface, ob, 1)) {
mloopcol_wet = CustomData_add_layer_named(&result->ldata,
@ -1978,7 +1978,8 @@ static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *
/* vertex group paint */
else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
int defgrp_index = BKE_object_defgroup_name_index(ob, surface->output_name);
MDeformVert *dvert = CustomData_get_layer(&result->vdata, CD_MDEFORMVERT);
MDeformVert *dvert = CustomData_get_layer_for_write(
&result->vdata, CD_MDEFORMVERT, result->totvert);
float *weight = (float *)sData->type_data;
/* apply weights into a vertex group, if doesn't exists add a new layer */

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

@ -2222,7 +2222,7 @@ void BKE_keyblock_convert_to_mesh(const KeyBlock *kb,
}
void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
const Mesh *mesh,
Mesh *mesh,
float (*r_vert_normals)[3],
float (*r_poly_normals)[3],
float (*r_loop_normals)[3])
@ -2272,8 +2272,8 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
vert_normals);
}
if (loop_normals_needed) {
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL)); /* May be nullptr. */
short(*clnors)[2] = static_cast<short(*)[2]>(CustomData_get_layer_for_write(
&mesh->ldata, CD_CUSTOMLOOPNORMAL, mesh->totloop)); /* May be nullptr. */
const bool *sharp_edges = static_cast<const bool *>(
CustomData_get_layer_named(&mesh->edata, CD_PROP_BOOL, "sharp_edge"));
BKE_mesh_normals_loop_split(positions,

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

@ -1601,7 +1601,7 @@ void BKE_mesh_transform(Mesh *me, const float mat[4][4], bool do_keys)
/* don't update normals, caller can do this explicitly.
* We do update loop normals though, those may not be auto-generated
* (see e.g. STL import script)! */
float(*lnors)[3] = (float(*)[3])CustomData_duplicate_referenced_layer(
float(*lnors)[3] = (float(*)[3])CustomData_get_layer_for_write(
&me->ldata, CD_NORMAL, me->totloop);
if (lnors) {
float m3[3][3];
@ -1815,7 +1815,8 @@ static float (*ensure_corner_normal_layer(Mesh &mesh))[3]
{
float(*r_loop_normals)[3];
if (CustomData_has_layer(&mesh.ldata, CD_NORMAL)) {
r_loop_normals = (float(*)[3])CustomData_get_layer(&mesh.ldata, CD_NORMAL);
r_loop_normals = (float(*)[3])CustomData_get_layer_for_write(
&mesh.ldata, CD_NORMAL, mesh.totloop);
memset(r_loop_normals, 0, sizeof(float[3]) * mesh.totloop);
}
else {
@ -1838,7 +1839,8 @@ void BKE_mesh_calc_normals_split_ex(Mesh *mesh,
const float split_angle = (mesh->flag & ME_AUTOSMOOTH) != 0 ? mesh->smoothresh : float(M_PI);
/* may be nullptr */
short(*clnors)[2] = (short(*)[2])CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);
short(*clnors)[2] = (short(*)[2])CustomData_get_layer_for_write(
&mesh->ldata, CD_CUSTOMLOOPNORMAL, mesh->totloop);
const bool *sharp_edges = static_cast<const bool *>(
CustomData_get_layer_named(&mesh->edata, CD_PROP_BOOL, "sharp_edge"));

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

@ -641,11 +641,14 @@ static void copy_or_interp_loop_attributes(Mesh *dest_mesh,
}
int source_layer_type_index = source_layer_i - source_cd->typemap[ty];
BLI_assert(target_layer_type_index != -1 && source_layer_type_index >= 0);
const int size = CustomData_sizeof(ty);
for (int j = 0; j < orig_mp->totloop; ++j) {
src_blocks_ofs[j] = CustomData_get_n(
source_cd, ty, orig_mp->loopstart + j, source_layer_type_index);
const void *layer = CustomData_get_layer_n(source_cd, ty, source_layer_type_index);
src_blocks_ofs[j] = POINTER_OFFSET(layer, size * (orig_mp->loopstart + j));
}
void *dst_block_ofs = CustomData_get_n(target_cd, ty, loop_index, target_layer_type_index);
void *dst_layer = CustomData_get_layer_n_for_write(
target_cd, ty, target_layer_type_index, dest_mesh->totloop);
void *dst_block_ofs = POINTER_OFFSET(dst_layer, size * loop_index);
CustomData_bmesh_interp_n(target_cd,
src_blocks_ofs.data(),
weights.data(),

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

@ -595,15 +595,15 @@ void BKE_mesh_polygon_flip_ex(const MPoly *mpoly,
}
}
void BKE_mesh_polygon_flip(const MPoly *mpoly, MLoop *mloop, CustomData *ldata)
void BKE_mesh_polygon_flip(const MPoly *mpoly, MLoop *mloop, CustomData *ldata, const int totloop)
{
MDisps *mdisp = (MDisps *)CustomData_get_layer(ldata, CD_MDISPS);
MDisps *mdisp = (MDisps *)CustomData_get_layer_for_write(ldata, CD_MDISPS, totloop);
BKE_mesh_polygon_flip_ex(mpoly, mloop, ldata, nullptr, mdisp, true);
}
void BKE_mesh_polys_flip(const MPoly *mpoly, MLoop *mloop, CustomData *ldata, int totpoly)
{
MDisps *mdisp = (MDisps *)CustomData_get_layer(ldata, CD_MDISPS);
MDisps *mdisp = (MDisps *)CustomData_get_layer_for_write(ldata, CD_MDISPS, totpoly);
const MPoly *mp;
int i;

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

@ -289,6 +289,7 @@ void BKE_mesh_do_versions_cd_flag_init(Mesh *mesh)
static void bm_corners_to_loops_ex(ID *id,
CustomData *fdata,
const int totface,
CustomData *ldata,
MFace *mface,
int totloop,
@ -300,10 +301,11 @@ static void bm_corners_to_loops_ex(ID *id,
MFace *mf = mface + findex;
for (int i = 0; i < numTex; i++) {
const MTFace *texface = (const MTFace *)CustomData_get_n(fdata, CD_MTFACE, findex, i);
const MTFace *texface = (const MTFace *)CustomData_get_n_for_write(
fdata, CD_MTFACE, findex, i, totface);
blender::float2 *uv = static_cast<blender::float2 *>(
CustomData_get_n(ldata, CD_PROP_FLOAT2, loopstart, i));
CustomData_get_n_for_write(ldata, CD_PROP_FLOAT2, loopstart, i, totloop));
copy_v2_v2(*uv, texface->uv[0]);
uv++;
copy_v2_v2(*uv, texface->uv[1]);
@ -318,8 +320,10 @@ static void bm_corners_to_loops_ex(ID *id,
}
for (int i = 0; i < numCol; i++) {
MLoopCol *mloopcol = (MLoopCol *)CustomData_get_n(ldata, CD_PROP_BYTE_COLOR, loopstart, i);
const MCol *mcol = (const MCol *)CustomData_get_n(fdata, CD_MCOL, findex, i);
MLoopCol *mloopcol = (MLoopCol *)CustomData_get_n_for_write(
ldata, CD_PROP_BYTE_COLOR, loopstart, i, totloop);
const MCol *mcol = (const MCol *)CustomData_get_n_for_write(
fdata, CD_MCOL, findex, i, totface);
MESH_MLOOPCOL_FROM_MCOL(mloopcol, &mcol[0]);
mloopcol++;
@ -334,9 +338,10 @@ static void bm_corners_to_loops_ex(ID *id,
}
if (CustomData_has_layer(fdata, CD_TESSLOOPNORMAL)) {
float(*loop_normals)[3] = (float(*)[3])CustomData_get(ldata, loopstart, CD_NORMAL);
const short(*tessloop_normals)[3] = (short(*)[3])CustomData_get(
fdata, findex, CD_TESSLOOPNORMAL);
float(*loop_normals)[3] = (float(*)[3])CustomData_get_for_write(
ldata, loopstart, CD_NORMAL, totloop);
const short(*tessloop_normals)[3] = (short(*)[3])CustomData_get_for_write(
fdata, findex, CD_TESSLOOPNORMAL, totface);
const int max = mf->v4 ? 4 : 3;
for (int i = 0; i < max; i++, loop_normals++, tessloop_normals++) {
@ -345,8 +350,8 @@ static void bm_corners_to_loops_ex(ID *id,
}
if (CustomData_has_layer(fdata, CD_MDISPS)) {
MDisps *ld = (MDisps *)CustomData_get(ldata, loopstart, CD_MDISPS);
const MDisps *fd = (const MDisps *)CustomData_get(fdata, findex, CD_MDISPS);
MDisps *ld = (MDisps *)CustomData_get_for_write(ldata, loopstart, CD_MDISPS, totloop);
const MDisps *fd = (const MDisps *)CustomData_get_for_write(fdata, findex, CD_MDISPS, totface);
const float(*disps)[3] = fd->disps;
int tot = mf->v4 ? 4 : 3;
int corners;
@ -443,7 +448,7 @@ static void convert_mfaces_to_mpolys(ID *id,
totpoly = totface_i;
mpoly = (MPoly *)CustomData_add_layer(pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, totpoly);
int *material_indices = static_cast<int *>(
CustomData_get_layer_named(pdata, CD_PROP_INT32, "material_index"));
CustomData_get_layer_named_for_write(pdata, CD_PROP_INT32, "material_index", totpoly));
if (material_indices == nullptr) {
material_indices = static_cast<int *>(CustomData_add_layer_named(
pdata, CD_PROP_INT32, CD_SET_DEFAULT, nullptr, totpoly, "material_index"));
@ -515,7 +520,8 @@ static void convert_mfaces_to_mpolys(ID *id,
#undef ML
bm_corners_to_loops_ex(id, fdata, ldata, mface, totloop, i, mp->loopstart, numTex, numCol);
bm_corners_to_loops_ex(
id, fdata, totface_i, ldata, mface, totloop, i, mp->loopstart, numTex, numCol);
if (polyindex) {
*polyindex = i;
@ -804,7 +810,7 @@ static void mesh_loops_to_tessdata(CustomData *fdata,
uint(*lidx)[4];
for (i = 0; i < numUV; i++) {
MTFace *texface = (MTFace *)CustomData_get_layer_n(fdata, CD_MTFACE, i);
MTFace *texface = (MTFace *)CustomData_get_layer_n_for_write(fdata, CD_MTFACE, i, num_faces);
const blender::float2 *uv = static_cast<const blender::float2 *>(
CustomData_get_layer_n(ldata, CD_PROP_FLOAT2, i));
@ -817,7 +823,7 @@ static void mesh_loops_to_tessdata(CustomData *fdata,
}
for (i = 0; i < numCol; i++) {
MCol(*mcol)[4] = (MCol(*)[4])CustomData_get_layer_n(fdata, CD_MCOL, i);
MCol(*mcol)[4] = (MCol(*)[4])CustomData_get_layer_n_for_write(fdata, CD_MCOL, i, num_faces);
const MLoopCol *mloopcol = (const MLoopCol *)CustomData_get_layer_n(
ldata, CD_PROP_BYTE_COLOR, i);
@ -1835,7 +1841,7 @@ void BKE_mesh_legacy_convert_verts_to_positions(Mesh *mesh)
using namespace blender;
using namespace blender::bke;
const Span<MVert> verts(static_cast<MVert *>(CustomData_get_layer(&mesh->vdata, CD_MVERT)),
const Span<MVert> verts(static_cast<const MVert *>(CustomData_get_layer(&mesh->vdata, CD_MVERT)),
mesh->totvert);
MutableSpan<float3> positions(
static_cast<float3 *>(CustomData_add_layer_named(

3
source/blender/blenkernel/intern/mesh_merge_customdata.cc
View File

@ -125,7 +125,8 @@ void BKE_mesh_merge_customdata_for_apply_modifier(Mesh *me)
Vector<float2 *> mloopuv_layers;
mloopuv_layers.reserve(mloopuv_layers_num);
for (int a = 0; a < mloopuv_layers_num; a++) {
float2 *mloopuv = static_cast<float2 *>(CustomData_get_layer_n(&me->ldata, CD_PROP_FLOAT2, a));
float2 *mloopuv = static_cast<float2 *>(
CustomData_get_layer_n_for_write(&me->ldata, CD_PROP_FLOAT2, a, me->totloop));
mloopuv_layers.append_unchecked(mloopuv);
}

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

@ -298,7 +298,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
totshape = CustomData_number_of_layers(&result->vdata, CD_SHAPEKEY);
for (a = 0; a < totshape; a++) {
float(*cos)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_n(&result->vdata, CD_SHAPEKEY, a));
CustomData_get_layer_n_for_write(&result->vdata, CD_SHAPEKEY, a, result->totvert));
for (i = maxVerts; i < result->totvert; i++) {
mul_m4_v3(mtx, cos[i]);
}
@ -361,7 +361,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
for (a = 0; a < totuv; a++) {
float(*dmloopuv)[2] = static_cast<float(*)[2]>(
CustomData_get_layer_n(&result->ldata, CD_PROP_FLOAT2, a));
CustomData_get_layer_n_for_write(&result->ldata, CD_PROP_FLOAT2, a, result->totloop));
int j = maxLoops;
dmloopuv += j; /* second set of loops only */
for (; j-- > 0; dmloopuv++) {
@ -397,7 +397,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
float(*loop_normals)[3] = static_cast<float(*)[3]>(
MEM_calloc_arrayN(size_t(totloop), sizeof(*loop_normals), __func__));
CustomData *ldata = &result->ldata;
short(*clnors)[2] = static_cast<short(*)[2]>(CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL));
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer_for_write(ldata, CD_CUSTOMLOOPNORMAL, totloop));
MLoopNorSpaceArray lnors_spacearr = {nullptr};
/* The transform matrix of a normal must be

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

@ -1913,7 +1913,8 @@ static void mesh_set_custom_normals(Mesh *mesh, float (*r_custom_nors)[3], const
short(*clnors)[2];
const int numloops = mesh->totloop;
clnors = (short(*)[2])CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);
clnors = (short(*)[2])CustomData_get_layer_for_write(
&mesh->ldata, CD_CUSTOMLOOPNORMAL, mesh->totloop);
if (clnors != nullptr) {
memset(clnors, 0, sizeof(*clnors) * size_t(numloops));
}

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

@ -1357,10 +1357,11 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
}
if (need_lnors_dst) {
short(*custom_nors_dst)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL));
CustomData_get_layer_for_write(ldata_dst, CD_CUSTOMLOOPNORMAL, numloops_dst));
/* Cache loop normals into a temporary custom data layer. */
loop_nors_dst = static_cast<float(*)[3]>(CustomData_get_layer(ldata_dst, CD_NORMAL));
loop_nors_dst = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(ldata_dst, CD_NORMAL, numloops_dst));
const bool do_loop_nors_dst = (loop_nors_dst == nullptr);
if (!loop_nors_dst) {
loop_nors_dst = static_cast<float(*)[3]>(

70
source/blender/blenkernel/intern/mesh_validate.cc
View File

@ -1071,21 +1071,22 @@ bool BKE_mesh_validate(Mesh *me, const bool do_verbose, const bool cddata_check_
MutableSpan<MPoly> polys = me->polys_for_write();
MutableSpan<MLoop> loops = me->loops_for_write();
BKE_mesh_validate_arrays(me,
reinterpret_cast<float(*)[3]>(positions.data()),
positions.size(),
edges.data(),
edges.size(),
(MFace *)CustomData_get_layer(&me->fdata, CD_MFACE),
me->totface,
loops.data(),
loops.size(),
polys.data(),
polys.size(),
me->deform_verts_for_write().data(),
do_verbose,
true,
&changed);
BKE_mesh_validate_arrays(
me,
reinterpret_cast<float(*)[3]>(positions.data()),
positions.size(),
edges.data(),
edges.size(),
(MFace *)CustomData_get_layer_for_write(&me->fdata, CD_MFACE, me->totface),
me->totface,
loops.data(),
loops.size(),
polys.data(),
polys.size(),
me->deform_verts_for_write().data(),
do_verbose,
true,
&changed);
if (changed) {
DEG_id_tag_update(&me->id, ID_RECALC_GEOMETRY_ALL_MODES);
@ -1122,21 +1123,22 @@ bool BKE_mesh_is_valid(Mesh *me)
MutableSpan<MPoly> polys = me->polys_for_write();
MutableSpan<MLoop> loops = me->loops_for_write();
is_valid &= BKE_mesh_validate_arrays(me,
reinterpret_cast<float(*)[3]>(positions.data()),
positions.size(),
edges.data(),
edges.size(),
(MFace *)CustomData_get_layer(&me->fdata, CD_MFACE),
me->totface,
loops.data(),
loops.size(),
polys.data(),
polys.size(),
me->deform_verts_for_write().data(),
do_verbose,
do_fixes,
&changed);
is_valid &= BKE_mesh_validate_arrays(
me,
reinterpret_cast<float(*)[3]>(positions.data()),
positions.size(),
edges.data(),
edges.size(),
(MFace *)CustomData_get_layer_for_write(&me->fdata, CD_MFACE, me->totface),
me->totface,
loops.data(),
loops.size(),
polys.data(),
polys.size(),
me->deform_verts_for_write().data(),
do_verbose,
do_fixes,
&changed);
if (!me->runtime->vert_normals_dirty) {
BLI_assert(me->runtime->vert_normals || me->totvert == 0);
@ -1186,7 +1188,7 @@ void BKE_mesh_strip_loose_faces(Mesh *me)
/* NOTE: We need to keep this for edge creation (for now?), and some old `readfile.c` code. */
MFace *f;
int a, b;
MFace *mfaces = (MFace *)CustomData_get_layer(&me->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&me->fdata, CD_MFACE, me->totface);
for (a = b = 0, f = mfaces; a < me->totface; a++, f++) {
if (f->v3) {
@ -1323,7 +1325,7 @@ void BKE_mesh_calc_edges_tessface(Mesh *mesh)
{
const int numFaces = mesh->totface;
EdgeSet *eh = BLI_edgeset_new_ex(__func__, BLI_EDGEHASH_SIZE_GUESS_FROM_POLYS(numFaces));
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
MFace *mf = mfaces;
for (int i = 0; i < numFaces; i++, mf++) {
@ -1347,8 +1349,8 @@ void BKE_mesh_calc_edges_tessface(Mesh *mesh)
CustomData_add_layer(&edgeData, CD_MEDGE, CD_SET_DEFAULT, nullptr, numEdges);
CustomData_add_layer(&edgeData, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, numEdges);
MEdge *med = (MEdge *)CustomData_get_layer(&edgeData, CD_MEDGE);
int *index = (int *)CustomData_get_layer(&edgeData, CD_ORIGINDEX);
MEdge *med = (MEdge *)CustomData_get_layer_for_write(&edgeData, CD_MEDGE, mesh->totedge);
int *index = (int *)CustomData_get_layer_for_write(&edgeData, CD_ORIGINDEX, mesh->totedge);
EdgeSetIterator *ehi = BLI_edgesetIterator_new(eh);
for (int i = 0; BLI_edgesetIterator_isDone(ehi) == false;

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

@ -340,7 +340,7 @@ static Mesh *mesh_wrapper_ensure_subdivision(Mesh *me)
if (use_clnors) {
float(*lnors)[3] = static_cast<float(*)[3]>(
CustomData_get_layer(&subdiv_mesh->ldata, CD_NORMAL));
CustomData_get_layer_for_write(&subdiv_mesh->ldata, CD_NORMAL, subdiv_mesh->totloop));
BLI_assert(lnors != nullptr);
BKE_mesh_set_custom_normals(subdiv_mesh, lnors);
CustomData_set_layer_flag(&me->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);

35
source/blender/blenkernel/intern/multires.cc
View File

@ -544,7 +544,8 @@ void multiresModifier_set_levels_from_disps(MultiresModifierData *mmd, Object *o
static void multires_set_tot_mdisps(Mesh *me, int lvl)
{
MDisps *mdisps = static_cast<MDisps *>(CustomData_get_layer(&me->ldata, CD_MDISPS));
MDisps *mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
int i;
if (mdisps) {
@ -663,8 +664,10 @@ static void multires_del_higher(MultiresModifierData *mmd, Object *ob, int lvl)
multires_set_tot_mdisps(me, mmd->totlvl);
multiresModifier_ensure_external_read(me, mmd);
mdisps = static_cast<MDisps *>(CustomData_get_layer(&me->ldata, CD_MDISPS));
gpm = static_cast<GridPaintMask *>(CustomData_get_layer(&me->ldata, CD_GRID_PAINT_MASK));
mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
gpm = static_cast<GridPaintMask *>(
CustomData_get_layer_for_write(&me->ldata, CD_GRID_PAINT_MASK, me->totloop));
multires_force_sculpt_rebuild(ob);
@ -728,7 +731,8 @@ void multiresModifier_del_levels(MultiresModifierData *mmd,
multires_set_tot_mdisps(me, mmd->totlvl);
multiresModifier_ensure_external_read(me, mmd);
MDisps *mdisps = static_cast<MDisps *>(CustomData_get_layer(&me->ldata, CD_MDISPS));
MDisps *mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
multires_force_sculpt_rebuild(ob);
@ -965,7 +969,8 @@ static void multiresModifier_disp_run(
CCGElem **gridData, **subGridData;
CCGKey key;
const MPoly *mpoly = BKE_mesh_polys(me);
MDisps *mdisps = static_cast<MDisps *>(CustomData_get_layer(&me->ldata, CD_MDISPS));
MDisps *mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
GridPaintMask *grid_paint_mask = nullptr;
int *gridOffset;
int i, gridSize, dGridSize, dSkip;
@ -973,8 +978,10 @@ static void multiresModifier_disp_run(
/* this happens in the dm made by bmesh_mdisps_space_set */
if (dm2 && CustomData_has_layer(&dm2->loopData, CD_MDISPS)) {
mpoly = static_cast<const MPoly *>(CustomData_get_layer(&dm2->polyData, CD_MPOLY));
mdisps = static_cast<MDisps *>(CustomData_get_layer(&dm2->loopData, CD_MDISPS));
mpoly = static_cast<const MPoly *>(
CustomData_get_layer_for_write(&dm2->polyData, CD_MPOLY, dm2->getNumPolys(dm)));
mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&dm2->loopData, CD_MDISPS, dm2->getNumLoops(dm)));
totloop = dm2->numLoopData;
totpoly = dm2->numPolyData;
}
@ -1006,7 +1013,7 @@ static void multiresModifier_disp_run(
/* multires paint masks */
if (key.has_mask) {
grid_paint_mask = static_cast<GridPaintMask *>(
CustomData_get_layer(&me->ldata, CD_GRID_PAINT_MASK));
CustomData_get_layer_for_write(&me->ldata, CD_GRID_PAINT_MASK, me->totloop));
}
/* when adding new faces in edit mode, need to allocate disps */
@ -1176,7 +1183,8 @@ void multires_modifier_update_hidden(DerivedMesh *dm)
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
BLI_bitmap **grid_hidden = ccgdm->gridHidden;
Mesh *me = static_cast<Mesh *>(ccgdm->multires.ob->data);
MDisps *mdisps = static_cast<MDisps *>(CustomData_get_layer(&me->ldata, CD_MDISPS));
MDisps *mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
int totlvl = ccgdm->multires.totlvl;
int lvl = ccgdm->multires.lvl;
@ -1395,7 +1403,8 @@ static void multires_sync_levels(Scene *scene, Object *ob_src, Object *ob_dst)
static void multires_apply_uniform_scale(Object *object, const float scale)
{
Mesh *mesh = (Mesh *)object->data;
MDisps *mdisps = static_cast<MDisps *>(CustomData_get_layer(&mesh->ldata, CD_MDISPS));
MDisps *mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&mesh->ldata, CD_MDISPS, mesh->totloop));
for (int i = 0; i < mesh->totloop; i++) {
MDisps *grid = &mdisps[i];
for (int j = 0; j < grid->totdisp; j++) {
@ -1479,7 +1488,8 @@ void multires_topology_changed(Mesh *me)
int i, grid = 0;
CustomData_external_read(&me->ldata, &me->id, CD_MASK_MDISPS, me->totloop);
mdisp = static_cast<MDisps *>(CustomData_get_layer(&me->ldata, CD_MDISPS));
mdisp = static_cast<MDisps *>(
CustomData_get_layer_for_write(&me->ldata, CD_MDISPS, me->totloop));
if (!mdisp) {
return;
@ -1514,7 +1524,8 @@ void multires_ensure_external_read(struct Mesh *mesh, int top_level)
return;
}
MDisps *mdisps = static_cast<MDisps *>(CustomData_get_layer(&mesh->ldata, CD_MDISPS));
MDisps *mdisps = static_cast<MDisps *>(
CustomData_get_layer_for_write(&mesh->ldata, CD_MDISPS, mesh->totloop));
if (mdisps == nullptr) {
mdisps = static_cast<MDisps *>(
CustomData_add_layer(&mesh->ldata, CD_MDISPS, CD_SET_DEFAULT, nullptr, mesh->totloop));

2
source/blender/blenkernel/intern/multires_reshape_subdivide.c
View File

@ -32,7 +32,7 @@ static void multires_subdivide_create_object_space_linear_grids(Mesh *mesh)
const MPoly *polys = BKE_mesh_polys(mesh);
const MLoop *loops = BKE_mesh_loops(mesh);
MDisps *mdisps = CustomData_get_layer(&mesh->ldata, CD_MDISPS);
MDisps *mdisps = CustomData_get_layer_for_write(&mesh->ldata, CD_MDISPS, mesh->totloop);
const int totpoly = mesh->totpoly;
for (int p = 0; p < totpoly; p++) {
const MPoly *poly = &polys[p];

11
source/blender/blenkernel/intern/multires_reshape_util.c
View File

@ -103,8 +103,10 @@ static void context_init_lookup(MultiresReshapeContext *reshape_context)
static void context_init_grid_pointers(MultiresReshapeContext *reshape_context)
{
Mesh *base_mesh = reshape_context->base_mesh;
reshape_context->mdisps = CustomData_get_layer(&base_mesh->ldata, CD_MDISPS);
reshape_context->grid_paint_masks = CustomData_get_layer(&base_mesh->ldata, CD_GRID_PAINT_MASK);
reshape_context->mdisps = CustomData_get_layer_for_write(
&base_mesh->ldata, CD_MDISPS, base_mesh->totloop);
reshape_context->grid_paint_masks = CustomData_get_layer_for_write(
&base_mesh->ldata, CD_GRID_PAINT_MASK, base_mesh->totloop);
}
static void context_init_commoon(MultiresReshapeContext *reshape_context)
@ -559,7 +561,7 @@ static void ensure_displacement_grid(MDisps *displacement_grid, const int level)
static void ensure_displacement_grids(Mesh *mesh, const int grid_level)
{
const int num_grids = mesh->totloop;
MDisps *mdisps = CustomData_get_layer(&mesh->ldata, CD_MDISPS);
MDisps *mdisps = CustomData_get_layer_for_write(&mesh->ldata, CD_MDISPS, mesh->totloop);
for (int grid_index = 0; grid_index < num_grids; grid_index++) {
ensure_displacement_grid(&mdisps[grid_index], grid_level);
}
@ -567,7 +569,8 @@ static void ensure_displacement_grids(Mesh *mesh, const int grid_level)
static void ensure_mask_grids(Mesh *mesh, const int level)
{
GridPaintMask *grid_paint_masks = CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK);
GridPaintMask *grid_paint_masks = CustomData_get_layer_for_write(
&mesh->ldata, CD_GRID_PAINT_MASK, mesh->totloop);
if (grid_paint_masks == NULL) {
return;
}

6
source/blender/blenkernel/intern/multires_unsubdivide.c
View File

@ -938,7 +938,8 @@ static void multires_unsubdivide_prepare_original_bmesh_for_extract(
bm_original_mesh, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, false);
/* Get the mapping data-layer. */
context->base_to_orig_vmap = CustomData_get_layer_named(&base_mesh->vdata, CD_PROP_INT32, vname);
context->base_to_orig_vmap = CustomData_get_layer_named_for_write(
&base_mesh->vdata, CD_PROP_INT32, vname, base_mesh->totvert);
/* Tag the base mesh vertices in the original mesh. */
for (int i = 0; i < base_mesh->totvert; i++) {
@ -1001,7 +1002,8 @@ static void multires_unsubdivide_extract_grids(MultiresUnsubdivideContext *conte
int *orig_to_base_vmap = MEM_calloc_arrayN(bm_original_mesh->totvert, sizeof(int), "orig vmap");
int *base_to_orig_vmap = MEM_calloc_arrayN(base_mesh->totvert, sizeof(int), "base vmap");
context->base_to_orig_vmap = CustomData_get_layer_named(&base_mesh->vdata, CD_PROP_INT32, vname);
context->base_to_orig_vmap = CustomData_get_layer_named_for_write(
&base_mesh->vdata, CD_PROP_INT32, vname, base_mesh->totvert);
for (int i = 0; i < base_mesh->totvert; i++) {
base_to_orig_vmap[i] = context->base_to_orig_vmap[i];
}

2
source/blender/blenkernel/intern/object_facemap.c
View File

@ -176,7 +176,7 @@ static void object_fmap_remove_object_mode(Object *ob, bFaceMap *fmap, bool purg
Mesh *me = ob->data;
if (CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
int *map = CustomData_get_layer(&me->pdata, CD_FACEMAP);
int *map = CustomData_get_layer_for_write(&me->pdata, CD_FACEMAP, me->totpoly);
int i;
if (map) {

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

@ -1709,7 +1709,8 @@ static void sculpt_update_object(
ss->multires.active = false;
ss->multires.modifier = nullptr;
ss->multires.level = 0;
ss->vmask = static_cast<float *>(CustomData_get_layer(&me->vdata, CD_PAINT_MASK));
ss->vmask = static_cast<float *>(
CustomData_get_layer_for_write(&me->vdata, CD_PAINT_MASK, me->totvert));
CustomDataLayer *layer;
eAttrDomain domain;
@ -1736,14 +1737,15 @@ static void sculpt_update_object(
/* Sculpt Face Sets. */
if (use_face_sets) {
ss->face_sets = static_cast<int *>(
CustomData_get_layer_named(&me->pdata, CD_PROP_INT32, ".sculpt_face_set"));
ss->face_sets = static_cast<int *>(CustomData_get_layer_named_for_write(
&me->pdata, CD_PROP_INT32, ".sculpt_face_set", me->totpoly));
}
else {
ss->face_sets = nullptr;
}
ss->hide_poly = (bool *)CustomData_get_layer_named(&me->pdata, CD_PROP_BOOL, ".hide_poly");
ss->hide_poly = (bool *)CustomData_get_layer_named_for_write(
&me->pdata, CD_PROP_BOOL, ".hide_poly", me->totpoly);
ss->subdiv_ccg = me_eval->runtime->subdiv_ccg;
@ -1962,14 +1964,14 @@ int *BKE_sculpt_face_sets_ensure(Mesh *mesh)
face_sets.finish();
}
return static_cast<int *>(
CustomData_get_layer_named(&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set"));
return static_cast<int *>(CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set", mesh->totpoly));
}
bool *BKE_sculpt_hide_poly_ensure(Mesh *mesh)
{
bool *hide_poly = static_cast<bool *>(
CustomData_get_layer_named(&mesh->pdata, CD_PROP_BOOL, ".hide_poly"));
bool *hide_poly = static_cast<bool *>(CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly));
if (hide_poly != nullptr) {
return hide_poly;
}

31
source/blender/blenkernel/intern/particle.cc
View File

@ -1888,7 +1888,8 @@ static float psys_interpolate_value_from_verts(
return values[index];
case PART_FROM_FACE:
case PART_FROM_VOLUME: {
MFace *mfaces = static_cast<MFace *>(CustomData_get_layer(&mesh->fdata, CD_MFACE));
MFace *mfaces = static_cast<MFace *>(
CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface));
MFace *mf = &mfaces[index];
return interpolate_particle_value(
values[mf->v1], values[mf->v2], values[mf->v3], values[mf->v4], fw, mf->v4);
@ -1981,9 +1982,10 @@ int psys_particle_dm_face_lookup(Mesh *mesh_final,
index_mf_to_mpoly_deformed = nullptr;
mtessface_final = static_cast<MFace *>(CustomData_get_layer(&mesh_final->fdata, CD_MFACE));
mtessface_final = static_cast<MFace *>(
CustomData_get_layer_for_write(&mesh_final->fdata, CD_MFACE, mesh_final->totface));
osface_final = static_cast<OrigSpaceFace *>(
CustomData_get_layer(&mesh_final->fdata, CD_ORIGSPACE));
CustomData_get_layer_for_write(&mesh_final->fdata, CD_ORIGSPACE, mesh_final->totface));
if (osface_final == nullptr) {
/* Assume we don't need osface_final data, and we get a direct 1-1 mapping... */
@ -2102,7 +2104,7 @@ static int psys_map_index_on_dm(Mesh *mesh,
/* modify the original weights to become
* weights for the derived mesh face */
OrigSpaceFace *osface = static_cast<OrigSpaceFace *>(
CustomData_get_layer(&mesh->fdata, CD_ORIGSPACE));
CustomData_get_layer_for_write(&mesh->fdata, CD_ORIGSPACE, mesh->totface));
const MFace *mfaces = static_cast<const MFace *>(
CustomData_get_layer(&mesh->fdata, CD_MFACE));
const MFace *mface = &mfaces[i];
@ -2187,10 +2189,12 @@ void psys_particle_on_dm(Mesh *mesh_final,
MFace *mface;
MTFace *mtface;
MFace *mfaces = static_cast<MFace *>(CustomData_get_layer(&mesh_final->fdata, CD_MFACE));
MFace *mfaces = static_cast<MFace *>(
CustomData_get_layer_for_write(&mesh_final->fdata, CD_MFACE, mesh_final->totface));
mface = &mfaces[mapindex];
const float(*vert_positions)[3] = BKE_mesh_vert_positions(mesh_final);
mtface = static_cast<MTFace *>(CustomData_get_layer(&mesh_final->fdata, CD_MTFACE));
mtface = static_cast<MTFace *>(
CustomData_get_layer_for_write(&mesh_final->fdata, CD_MTFACE, mesh_final->totface));
if (mtface) {
mtface += mapindex;
@ -3893,10 +3897,11 @@ static void psys_face_mat(Object *ob, Mesh *mesh, ParticleData *pa, float mat[4]
return;
}
MFace *mfaces = static_cast<MFace *>(CustomData_get_layer(&mesh->fdata, CD_MFACE));
MFace *mfaces = static_cast<MFace *>(
CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface));
mface = &mfaces[i];
const OrigSpaceFace *osface = static_cast<const OrigSpaceFace *>(
CustomData_get(&mesh->fdata, i, CD_ORIGSPACE));
CustomData_get_for_write(&mesh->fdata, i, CD_ORIGSPACE, mesh->totface));
if (orco &&
(orcodata = static_cast<const float(*)[3]>(CustomData_get_layer(&mesh->vdata, CD_ORCO)))) {
@ -4204,7 +4209,7 @@ static int get_particle_uv(Mesh *mesh,
float *texco,
bool from_vert)
{
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
MFace *mf;
const MTFace *tf;
int i;
@ -5108,8 +5113,8 @@ void psys_get_dupli_texture(ParticleSystem *psys,
const MTFace *mtface = static_cast<const MTFace *>(
CustomData_get_layer_n(mtf_data, CD_MTFACE, uv_idx));
if (mtface != nullptr) {
const MFace *mface = static_cast<const MFace *>(
CustomData_get(&psmd->mesh_final->fdata, cpa->num, CD_MFACE));
const MFace *mface = static_cast<const MFace *>(CustomData_get_for_write(
&psmd->mesh_final->fdata, cpa->num, CD_MFACE, psmd->mesh_final->totface));
mtface += cpa->num;
psys_interpolate_uvs(mtface, mface->v4, cpa->fuv, uv);
}
@ -5153,8 +5158,8 @@ void psys_get_dupli_texture(ParticleSystem *psys,
if (uv_idx >= 0) {
const MTFace *mtface = static_cast<const MTFace *>(
CustomData_get_layer_n(mtf_data, CD_MTFACE, uv_idx));
const MFace *mface = static_cast<const MFace *>(
CustomData_get(&psmd->mesh_final->fdata, num, CD_MFACE));
const MFace *mface = static_cast<const MFace *>(CustomData_get_for_write(
&psmd->mesh_final->fdata, num, CD_MFACE, psmd->mesh_final->totface));
mtface += num;
psys_interpolate_uvs(mtface, mface->v4, pa->fuv, uv);
}

17
source/blender/blenkernel/intern/particle_distribute.c
View File

@ -179,7 +179,7 @@ static void distribute_grid(Mesh *mesh, ParticleSystem *psys)
int amax = from == PART_FROM_FACE ? 3 : 1;
totface = mesh->totface;
mface = mface_array = CustomData_get_layer(&mesh->fdata, CD_MFACE);
mface = mface_array = CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
for (a = 0; a < amax; a++) {
if (a == 0) {
@ -462,7 +462,7 @@ static void distribute_from_verts_exec(ParticleTask *thread, ParticleData *pa, i
ParticleThreadContext *ctx = thread->ctx;
MFace *mface;
mface = CustomData_get_layer(&ctx->mesh->fdata, CD_MFACE);
mface = CustomData_get_layer_for_write(&ctx->mesh->fdata, CD_MFACE, ctx->mesh->totface);
int rng_skip_tot = PSYS_RND_DIST_SKIP; /* count how many rng_* calls won't need skipping */
@ -523,7 +523,7 @@ static void distribute_from_faces_exec(ParticleTask *thread, ParticleData *pa, i
int i;
int rng_skip_tot = PSYS_RND_DIST_SKIP; /* count how many rng_* calls won't need skipping */
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
MFace *mface;
pa->num = i = ctx->index[p];
@ -578,7 +578,7 @@ static void distribute_from_volume_exec(ParticleTask *thread, ParticleData *pa,
const float(*positions)[3] = BKE_mesh_vert_positions(mesh);
pa->num = i = ctx->index[p];
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
mface = &mfaces[i];
switch (distr) {
@ -630,7 +630,7 @@ static void distribute_from_volume_exec(ParticleTask *thread, ParticleData *pa,
min_d = FLT_MAX;
intersect = 0;
mface = CustomData_get_layer(&mesh->fdata, CD_MFACE);
mface = CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
for (i = 0; i < tot; i++, mface++) {
if (i == pa->num) {
continue;
@ -700,7 +700,7 @@ static void distribute_children_exec(ParticleTask *thread, ChildParticle *cpa, i
return;
}
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
mf = &mfaces[ctx->index[p]];
randu = BLI_rng_get_float(thread->rng);
@ -1053,7 +1053,7 @@ static int psys_thread_context_init_distribute(ParticleThreadContext *ctx,
orcodata = CustomData_get_layer(&mesh->vdata, CD_ORCO);
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
for (i = 0; i < totelem; i++) {
MFace *mf = &mfaces[i];
@ -1114,7 +1114,8 @@ static int psys_thread_context_init_distribute(ParticleThreadContext *ctx,
}
}
else { /* PART_FROM_FACE / PART_FROM_VOLUME */
MFace *mfaces = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mfaces = (MFace *)CustomData_get_layer_for_write(
&mesh->fdata, CD_MFACE, mesh->totface);
for (i = 0; i < totelem; i++) {
MFace *mf = &mfaces[i];
tweight = vweight[mf->v1] + vweight[mf->v2] + vweight[mf->v3];

28
source/blender/blenkernel/intern/pbvh.c
View File

@ -825,7 +825,8 @@ void BKE_pbvh_build_mesh(PBVH *pbvh,
pbvh->mesh = mesh;
pbvh->header.type = PBVH_FACES;
pbvh->mpoly = mpoly;
pbvh->hide_poly = (bool *)CustomData_get_layer_named(&mesh->pdata, CD_PROP_BOOL, ".hide_poly");
pbvh->hide_poly = (bool *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly);
pbvh->material_indices = (const int *)CustomData_get_layer_named(
&mesh->pdata, CD_PROP_INT32, "material_index");
pbvh->mloop = mloop;
@ -833,7 +834,8 @@ void BKE_pbvh_build_mesh(PBVH *pbvh,
pbvh->vert_positions = vert_positions;
BKE_mesh_vertex_normals_ensure(mesh);
pbvh->vert_normals = BKE_mesh_vertex_normals_for_write(mesh);
pbvh->hide_vert = (bool *)CustomData_get_layer_named(&mesh->vdata, CD_PROP_BOOL, ".hide_vert");
pbvh->hide_vert = (bool *)CustomData_get_layer_named_for_write(
&mesh->vdata, CD_PROP_BOOL, ".hide_vert", mesh->totvert);
pbvh->vert_bitmap = MEM_calloc_arrayN(totvert, sizeof(bool), "bvh->vert_bitmap");
pbvh->totvert = totvert;
@ -3369,7 +3371,7 @@ void pbvh_vertex_iter_init(PBVH *pbvh, PBVHNode *node, PBVHVertexIter *vi, int m
vi->vert_normals = pbvh->vert_normals;
vi->hide_vert = pbvh->hide_vert;
vi->vmask = CustomData_get_layer(pbvh->vdata, CD_PAINT_MASK);
vi->vmask = CustomData_get_layer_for_write(pbvh->vdata, CD_PAINT_MASK, pbvh->mesh->totvert);
}
}
@ -3456,7 +3458,8 @@ bool *BKE_pbvh_get_vert_hide_for_write(PBVH *pbvh)
if (pbvh->hide_vert) {
return pbvh->hide_vert;
}
pbvh->hide_vert = CustomData_get_layer_named(&pbvh->mesh->vdata, CD_PROP_BOOL, ".hide_vert");
pbvh->hide_vert = CustomData_get_layer_named_for_write(
&pbvh->mesh->vdata, CD_PROP_BOOL, ".hide_vert", pbvh->mesh->totvert);
if (pbvh->hide_vert) {
return pbvh->hide_vert;
}
@ -3478,8 +3481,10 @@ void BKE_pbvh_face_sets_set(PBVH *pbvh, int *face_sets)
void BKE_pbvh_update_hide_attributes_from_mesh(PBVH *pbvh)
{
if (pbvh->header.type == PBVH_FACES) {
pbvh->hide_vert = CustomData_get_layer_named(&pbvh->mesh->vdata, CD_PROP_BOOL, ".hide_vert");
pbvh->hide_poly = CustomData_get_layer_named(&pbvh->mesh->pdata, CD_PROP_BOOL, ".hide_poly");
pbvh->hide_vert = CustomData_get_layer_named_for_write(
&pbvh->mesh->vdata, CD_PROP_BOOL, ".hide_vert", pbvh->mesh->totvert);
pbvh->hide_poly = CustomData_get_layer_named_for_write(
&pbvh->mesh->pdata, CD_PROP_BOOL, ".hide_poly", pbvh->mesh->totpoly);
}
}
@ -3799,8 +3804,8 @@ void BKE_pbvh_sync_visibility_from_verts(PBVH *pbvh, Mesh *mesh)
const MPoly *mp = BKE_mesh_polys(mesh);
CCGKey key = pbvh->gridkey;
bool *hide_poly = (bool *)CustomData_get_layer_named(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly");
bool *hide_poly = (bool *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly);
bool delete_hide_poly = true;
for (int face_index = 0; face_index < mesh->totpoly; face_index++, mp++) {
@ -3818,14 +3823,15 @@ void BKE_pbvh_sync_visibility_from_verts(PBVH *pbvh, Mesh *mesh)
}
if (hidden && !hide_poly) {
hide_poly = (bool *)CustomData_get_layer_named(&mesh->pdata, CD_PROP_BOOL, ".hide_poly");
hide_poly = (bool *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly);
if (!hide_poly) {
CustomData_add_layer_named(
&mesh->pdata, CD_PROP_BOOL, CD_CONSTRUCT, NULL, mesh->totpoly, ".hide_poly");
hide_poly = (bool *)CustomData_get_layer_named(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly");
hide_poly = (bool *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly);
}
}

17
source/blender/blenkernel/intern/subdiv_mesh.cc
View File

@ -79,8 +79,8 @@ static void subdiv_mesh_ctx_cache_uv_layers(SubdivMeshContext *ctx)
Mesh *subdiv_mesh = ctx->subdiv_mesh;
ctx->num_uv_layers = CustomData_number_of_layers(&subdiv_mesh->ldata, CD_PROP_FLOAT2);
for (int layer_index = 0; layer_index < ctx->num_uv_layers; layer_index++) {
ctx->uv_layers[layer_index] = static_cast<float2 *>(
CustomData_get_layer_n(&subdiv_mesh->ldata, CD_PROP_FLOAT2, layer_index));
ctx->uv_layers[layer_index] = static_cast<float2 *>(CustomData_get_layer_n_for_write(
&subdiv_mesh->ldata, CD_PROP_FLOAT2, layer_index, subdiv_mesh->totloop));
}
}
@ -93,19 +93,20 @@ static void subdiv_mesh_ctx_cache_custom_data_layers(SubdivMeshContext *ctx)
ctx->subdiv_loops = BKE_mesh_loops_for_write(subdiv_mesh);
/* Pointers to original indices layers. */
ctx->vert_origindex = static_cast<int *>(
CustomData_get_layer(&subdiv_mesh->vdata, CD_ORIGINDEX));
CustomData_get_layer_for_write(&subdiv_mesh->vdata, CD_ORIGINDEX, subdiv_mesh->totvert));
ctx->edge_origindex = static_cast<int *>(
CustomData_get_layer(&subdiv_mesh->edata, CD_ORIGINDEX));
CustomData_get_layer_for_write(&subdiv_mesh->edata, CD_ORIGINDEX, subdiv_mesh->totedge));
ctx->loop_origindex = static_cast<int *>(
CustomData_get_layer(&subdiv_mesh->ldata, CD_ORIGINDEX));
CustomData_get_layer_for_write(&subdiv_mesh->ldata, CD_ORIGINDEX, subdiv_mesh->totloop));
ctx->poly_origindex = static_cast<int *>(
CustomData_get_layer(&subdiv_mesh->pdata, CD_ORIGINDEX));
CustomData_get_layer_for_write(&subdiv_mesh->pdata, CD_ORIGINDEX, subdiv_mesh->totpoly));
/* UV layers interpolation. */
subdiv_mesh_ctx_cache_uv_layers(ctx);
/* Orco interpolation. */
ctx->orco = static_cast<float(*)[3]>(CustomData_get_layer(&subdiv_mesh->vdata, CD_ORCO));
ctx->orco = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(&subdiv_mesh->vdata, CD_ORCO, subdiv_mesh->totvert));
ctx->cloth_orco = static_cast<float(*)[3]>(
CustomData_get_layer(&subdiv_mesh->vdata, CD_CLOTH_ORCO));
CustomData_get_layer_for_write(&subdiv_mesh->vdata, CD_CLOTH_ORCO, subdiv_mesh->totvert));
}
static void subdiv_mesh_prepare_accumulator(SubdivMeshContext *ctx, int num_vertices)

6
source/blender/blenkernel/intern/subsurf_ccg.c
View File

@ -390,8 +390,10 @@ static void set_subsurf_legacy_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *
const float(*dmloopuv)[2] = CustomData_get_layer_n(&dm->loopData, CD_PROP_FLOAT2, n);
/* need to update both CD_MTFACE & CD_PROP_FLOAT2, hrmf, we could get away with
* just tface except applying the modifier then looses subsurf UV */
MTFace *tface = CustomData_get_layer_n(&result->faceData, CD_MTFACE, n);
float(*mloopuv)[2] = CustomData_get_layer_n(&result->loopData, CD_PROP_FLOAT2, n);
MTFace *tface = CustomData_get_layer_n_for_write(
&result->faceData, CD_MTFACE, n, result->numTessFaceData);
float(*mloopuv)[2] = CustomData_get_layer_n_for_write(
&result->loopData, CD_PROP_FLOAT2, n, result->getNumLoops(dm));
if (!dmloopuv || (!tface && !mloopuv)) {
return;

2
source/blender/blenloader/intern/versioning_250.c
View File

@ -996,7 +996,7 @@ void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
if ((key = blo_do_versions_newlibadr(fd, lib, me->key)) && key->refkey) {
data = key->refkey->data;
tot = MIN2(me->totvert, key->refkey->totelem);
MVert *verts = (MVert *)CustomData_get_layer(&me->vdata, CD_MVERT);
MVert *verts = (MVert *)CustomData_get_layer_for_write(&me->vdata, CD_MVERT, me->totvert);
for (a = 0; a < tot; a++, data += 3) {
copy_v3_v3(verts[a].co_legacy, data);
}

31
source/blender/blenloader/intern/versioning_290.c
View File

@ -821,21 +821,22 @@ void blo_do_versions_290(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (const MPoly *mp = BKE_mesh_polys(me), *mp_end = mp + me->totpoly; mp < mp_end; mp++) {
if (mp->totloop == 2) {
bool changed;
BKE_mesh_validate_arrays(me,
BKE_mesh_vert_positions_for_write(me),
me->totvert,
BKE_mesh_edges_for_write(me),
me->totedge,
(MFace *)CustomData_get_layer(&me->fdata, CD_MFACE),
me->totface,
BKE_mesh_loops_for_write(me),
me->totloop,
BKE_mesh_polys_for_write(me),
me->totpoly,
BKE_mesh_deform_verts_for_write(me),
false,
true,
&changed);
BKE_mesh_validate_arrays(
me,
BKE_mesh_vert_positions_for_write(me),
me->totvert,
BKE_mesh_edges_for_write(me),
me->totedge,
(MFace *)CustomData_get_layer_for_write(&me->fdata, CD_MFACE, me->totface),
me->totface,
BKE_mesh_loops_for_write(me),
me->totloop,
BKE_mesh_polys_for_write(me),
me->totpoly,
BKE_mesh_deform_verts_for_write(me),
false,
true,
&changed);
break;
}
}

2
source/blender/blenloader/intern/versioning_defaults.cc
View File

@ -359,7 +359,7 @@ static void blo_update_defaults_scene(Main *bmain, Scene *scene)
{0.625, 0.75}, {0.375, 0.75}, {0.375, 0.25}, {0.625, 0.25}, {0.625, 0.50}, {0.375, 0.50},
};
float(*mloopuv)[2] = static_cast<float(*)[2]>(
CustomData_get_layer(&me->ldata, CD_PROP_FLOAT2));
CustomData_get_layer_for_write(&me->ldata, CD_PROP_FLOAT2, me->totloop));
memcpy(mloopuv, uv_values, sizeof(float[2]) * me->totloop);
}

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

@ -367,7 +367,7 @@ void mesh_render_data_update_normals(MeshRenderData *mr, const eMRDataType data_
mr->loop_normals = static_cast<float(*)[3]>(
MEM_mallocN(sizeof(*mr->loop_normals) * mr->loop_len, __func__));
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(&mr->me->ldata, CD_CUSTOMLOOPNORMAL));
CustomData_get_layer_for_write(&mr->me->ldata, CD_CUSTOMLOOPNORMAL, mr->me->totloop));
const bool *sharp_edges = static_cast<const bool *>(
CustomData_get_layer_named(&mr->me->edata, CD_PROP_BOOL, "sharp_edge"));
BKE_mesh_normals_loop_split(reinterpret_cast<const float(*)[3]>(mr->vert_positions),

6
source/blender/editors/mesh/editmesh_mask_extract.c
View File

@ -573,8 +573,10 @@ static int paint_mask_slice_exec(bContext *C, wmOperator *op)
if (ob->mode == OB_MODE_SCULPT) {
SculptSession *ss = ob->sculpt;
ss->face_sets = CustomData_get_layer_named(
&((Mesh *)ob->data)->pdata, CD_PROP_INT32, ".sculpt_face_set");
ss->face_sets = CustomData_get_layer_named_for_write(&((Mesh *)ob->data)->pdata,
CD_PROP_INT32,
".sculpt_face_set",
((Mesh *)ob->data)->totpoly);
if (ss->face_sets) {
/* Assign a new Face Set ID to the new faces created by the slice operation. */
const int next_face_set_id = ED_sculpt_face_sets_find_next_available_id(ob->data);

9
source/blender/editors/mesh/mesh_data.cc
View File

@ -232,7 +232,7 @@ void ED_mesh_uv_loop_reset_ex(Mesh *me, const int layernum)
/* Collect Mesh UVs */
BLI_assert(CustomData_has_layer(&me->ldata, CD_PROP_FLOAT2));
float2 *mloopuv = static_cast<float2 *>(
CustomData_get_layer_n(&me->ldata, CD_PROP_FLOAT2, layernum));
CustomData_get_layer_n_for_write(&me->ldata, CD_PROP_FLOAT2, layernum, me->totloop));
const MPoly *polys = BKE_mesh_polys(me);
for (int i = 0; i < me->totpoly; i++) {
@ -302,7 +302,8 @@ int ED_mesh_uv_add(
CustomData_add_layer_named(&me->ldata,
CD_PROP_FLOAT2,
CD_DUPLICATE,
CustomData_get_layer(&me->ldata, CD_PROP_FLOAT2),
const_cast<float2 *>(static_cast<const float2 *>(
CustomData_get_layer(&me->ldata, CD_PROP_FLOAT2))),
me->totloop,
unique_name);
@ -364,8 +365,8 @@ const bool *ED_mesh_uv_map_pin_layer_get(const Mesh *mesh, const int uv_index)
static bool *ensure_corner_boolean_attribute(Mesh &mesh, const blender::StringRefNull name)
{
bool *data = static_cast<bool *>(CustomData_duplicate_referenced_layer_named(
&mesh.ldata, CD_PROP_BOOL, name.c_str(), mesh.totloop));
bool *data = static_cast<bool *>(
CustomData_get_layer_named_for_write(&mesh.ldata, CD_PROP_BOOL, name.c_str(), mesh.totloop));
if (!data) {
data = static_cast<bool *>(CustomData_add_layer_named(
&mesh.ldata, CD_PROP_BOOL, CD_SET_DEFAULT, nullptr, mesh.totpoly, name.c_str()));

20
source/blender/editors/mesh/meshtools.cc
View File

@ -108,9 +108,10 @@ static void join_mesh_single(Depsgraph *depsgraph,
CustomData_copy_data_named(&me->vdata, vdata, 0, *vertofs, me->totvert);
/* vertex groups */
MDeformVert *dvert = (MDeformVert *)CustomData_get(vdata, *vertofs, CD_MDEFORMVERT);
const MDeformVert *dvert_src = (const MDeformVert *)CustomData_get(
&me->vdata, 0, CD_MDEFORMVERT);
MDeformVert *dvert = (MDeformVert *)CustomData_get_for_write(
vdata, *vertofs, CD_MDEFORMVERT, totvert);
const MDeformVert *dvert_src = (const MDeformVert *)CustomData_get_layer(&me->vdata,
CD_MDEFORMVERT);
/* Remap to correct new vgroup indices, if needed. */
if (dvert_src) {
@ -254,7 +255,7 @@ static void join_mesh_single(Depsgraph *depsgraph,
/* Apply matmap. In case we don't have material indices yet, create them if more than one
* material is the result of joining. */
int *material_indices = static_cast<int *>(
CustomData_get_layer_named(pdata, CD_PROP_INT32, "material_index"));
CustomData_get_layer_named_for_write(pdata, CD_PROP_INT32, "material_index", totpoly));
if (!material_indices && totcol > 1) {
material_indices = (int *)CustomData_add_layer_named(
pdata, CD_PROP_INT32, CD_SET_DEFAULT, nullptr, totpoly, "material_index");
@ -270,8 +271,9 @@ static void join_mesh_single(Depsgraph *depsgraph,
}
/* Face maps. */
int *fmap = (int *)CustomData_get(pdata, *polyofs, CD_FACEMAP);
const int *fmap_src = (const int *)CustomData_get(&me->pdata, 0, CD_FACEMAP);
int *fmap = (int *)CustomData_get_for_write(pdata, *polyofs, CD_FACEMAP, totpoly);
const int *fmap_src = (const int *)CustomData_get_for_write(
&me->pdata, 0, CD_FACEMAP, me->totpoly);
/* Remap to correct new face-map indices, if needed. */
if (fmap_src) {
@ -300,14 +302,14 @@ static void join_mesh_single(Depsgraph *depsgraph,
/* Face Sets IDs are a sparse sequence, so this function offsets all the IDs by face_set_offset and
* updates face_set_offset with the maximum ID value. This way, when used in multiple meshes, all
* of them will have different IDs for their Face Sets. */
static void mesh_join_offset_face_sets_ID(const Mesh *mesh, int *face_set_offset)
static void mesh_join_offset_face_sets_ID(Mesh *mesh, int *face_set_offset)
{
if (!mesh->totpoly) {
return;
}
int *face_sets = (int *)CustomData_get_layer_named(
&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set");
int *face_sets = (int *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set", mesh->totpoly);
if (!face_sets) {
return;
}

6
source/blender/editors/object/object_facemap_ops.c
View File

@ -52,7 +52,7 @@ void ED_object_facemap_face_add(Object *ob, bFaceMap *fmap, int facenum)
Mesh *me = ob->data;
/* if there's is no facemap layer then create one */
if ((facemap = CustomData_get_layer(&me->pdata, CD_FACEMAP)) == NULL) {
if ((facemap = CustomData_get_layer_for_write(&me->pdata, CD_FACEMAP, me->totpoly)) == NULL) {
facemap = CustomData_add_layer(&me->pdata, CD_FACEMAP, CD_SET_DEFAULT, NULL, me->totpoly);
}
@ -74,7 +74,7 @@ void ED_object_facemap_face_remove(Object *ob, bFaceMap *fmap, int facenum)
int *facemap;
Mesh *me = ob->data;
if ((facemap = CustomData_get_layer(&me->pdata, CD_FACEMAP)) == NULL) {
if ((facemap = CustomData_get_layer_for_write(&me->pdata, CD_FACEMAP, me->totpoly)) == NULL) {
return;
}
@ -117,7 +117,7 @@ static void object_fmap_remap_object_mode(Object *ob, const int *remap)
Mesh *me = ob->data;
if (CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
int *map = CustomData_get_layer(&me->pdata, CD_FACEMAP);
int *map = CustomData_get_layer_for_write(&me->pdata, CD_FACEMAP, me->totpoly);
if (map) {
for (int i = 0; i < me->totpoly; i++) {
if (map[i] != -1) {

2
source/blender/editors/object/object_modifier.cc
View File

@ -2900,7 +2900,7 @@ static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain,
arm->edbo = MEM_cnew<ListBase>("edbo armature");
MVertSkin *mvert_skin = static_cast<MVertSkin *>(
CustomData_get_layer(&me->vdata, CD_MVERT_SKIN));
CustomData_get_layer_for_write(&me->vdata, CD_MVERT_SKIN, me->totvert));
int *emap_mem;
MeshElemMap *emap;
BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me_edges.data(), me->totvert, me->totedge);

3
source/blender/editors/sculpt_paint/paint_hide.c
View File

@ -77,7 +77,8 @@ static void partialvis_update_mesh(Object *ob,
const int *vert_indices = BKE_pbvh_node_get_vert_indices(node);
paint_mask = CustomData_get_layer(&me->vdata, CD_PAINT_MASK);
bool *hide_vert = CustomData_get_layer_named(&me->vdata, CD_PROP_BOOL, ".hide_vert");
bool *hide_vert = CustomData_get_layer_named_for_write(
&me->vdata, CD_PROP_BOOL, ".hide_vert", me->totvert);
if (hide_vert == NULL) {
hide_vert = CustomData_add_layer_named(
&me->vdata, CD_PROP_BOOL, CD_SET_DEFAULT, NULL, me->totvert, ".hide_vert");

3
source/blender/editors/sculpt_paint/paint_mask.c
View File

@ -1408,7 +1408,8 @@ static void sculpt_gesture_trim_end(bContext *UNUSED(C), SculptGestureContext *s
SculptSession *ss = object->sculpt;
Mesh *mesh = (Mesh *)object->data;
ss->face_sets = CustomData_get_layer_named(&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set");
ss->face_sets = CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set", mesh->totpoly);
if (ss->face_sets) {
/* Assign a new Face Set ID to the new faces created by the trim operation. */
const int next_face_set_id = ED_sculpt_face_sets_find_next_available_id(object->data);

3
source/blender/editors/sculpt_paint/sculpt_dyntopo.c
View File

@ -173,7 +173,8 @@ static void SCULPT_dynamic_topology_disable_ex(
me->face_sets_color_default = 1;
/* Sync the visibility to vertices manually as the pmap is still not initialized. */
bool *hide_vert = (bool *)CustomData_get_layer_named(&me->vdata, CD_PROP_BOOL, ".hide_vert");
bool *hide_vert = (bool *)CustomData_get_layer_named_for_write(
&me->vdata, CD_PROP_BOOL, ".hide_vert", me->totvert);
if (hide_vert != NULL) {
memset(hide_vert, 0, sizeof(bool) * me->totvert);
}

4
source/blender/editors/sculpt_paint/sculpt_face_set.cc
View File

@ -74,8 +74,8 @@ int ED_sculpt_face_sets_find_next_available_id(struct Mesh *mesh)
void ED_sculpt_face_sets_initialize_none_to_id(struct Mesh *mesh, const int new_id)
{
int *face_sets = static_cast<int *>(
CustomData_get_layer_named(&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set"));
int *face_sets = static_cast<int *>(CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_INT32, ".sculpt_face_set", mesh->totpoly));
if (!face_sets) {
return;
}

8
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
View File

@ -421,12 +421,14 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *me, int id)
const float(*lnors)[3] = nullptr;
if (CustomData_has_layer(&me->ldata, CD_NORMAL)) {
lnors = (float(*)[3])CustomData_get_layer(&me->ldata, CD_NORMAL);
lnors = (const float(*)[3])CustomData_get_layer(&me->ldata, CD_NORMAL);
}
// Get other mesh data
const FreestyleEdge *fed = (FreestyleEdge *)CustomData_get_layer(&me->edata, CD_FREESTYLE_EDGE);
const FreestyleFace *ffa = (FreestyleFace *)CustomData_get_layer(&me->pdata, CD_FREESTYLE_FACE);
const FreestyleEdge *fed = (const FreestyleEdge *)CustomData_get_layer(&me->edata,
CD_FREESTYLE_EDGE);
const FreestyleFace *ffa = (const FreestyleFace *)CustomData_get_layer(&me->pdata,
CD_FREESTYLE_FACE);
// Compute view matrix
Object *ob_camera_eval = DEG_get_evaluated_object(_depsgraph, RE_GetCamera(_re));

6
source/blender/geometry/intern/mesh_split_edges.cc
View File

@ -49,10 +49,12 @@ static void add_new_vertices(Mesh &mesh, const Span<int> new_to_old_verts_map)
attribute.finish();
}
if (float3 *orco = static_cast<float3 *>(CustomData_get_layer(&mesh.vdata, CD_ORCO))) {
if (float3 *orco = static_cast<float3 *>(
CustomData_get_layer_for_write(&mesh.vdata, CD_ORCO, mesh.totvert))) {
copy_to_new_verts<float3>({orco, mesh.totvert}, new_to_old_verts_map);
}
if (int *orig_indices = static_cast<int *>(CustomData_get_layer(&mesh.vdata, CD_ORIGINDEX))) {
if (int *orig_indices = static_cast<int *>(
CustomData_get_layer_for_write(&mesh.vdata, CD_ORIGINDEX, mesh.totvert))) {
copy_to_new_verts<int>({orig_indices, mesh.totvert}, new_to_old_verts_map);
}
}

12
source/blender/gpu/intern/gpu_shader_builder_stubs.cc
View File

@ -208,18 +208,6 @@ bool CustomData_has_layer(const struct CustomData * /*data*/, int /*type*/)
return false;
}
void *CustomData_get_layer_named(const struct CustomData * /*data*/,
int /*type*/,
const char * /*name*/)
{
return nullptr;
}
void *CustomData_get_layer(const struct CustomData * /*data*/, int /*type*/)
{
return nullptr;
}
/** \} */
/* -------------------------------------------------------------------- */

18
source/blender/io/alembic/exporter/abc_writer_hair.cc
View File

@ -120,8 +120,9 @@ void ABCHairWriter::write_hair_sample(const HierarchyContext &context,
float inv_mat[4][4];
invert_m4_m4_safe(inv_mat, context.object->object_to_world);
MTFace *mtface = (MTFace *)CustomData_get_layer(&mesh->fdata, CD_MTFACE);
MFace *mface = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MTFace *mtface = (MTFace *)CustomData_get_layer_for_write(
&mesh->fdata, CD_MTFACE, mesh->totface);
const MFace *mface = (const MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
const float(*positions)[3] = BKE_mesh_vert_positions(mesh);
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh);
@ -153,7 +154,7 @@ void ABCHairWriter::write_hair_sample(const HierarchyContext &context,
if (num < mesh->totface) {
/* TODO(Sybren): check whether the NULL check here and if(mface) are actually required
*/
MFace *face = mface == nullptr ? nullptr : &mface[num];
const MFace *face = mface == nullptr ? nullptr : &mface[num];
MTFace *tface = mtface + num;
if (mface) {
@ -189,8 +190,8 @@ void ABCHairWriter::write_hair_sample(const HierarchyContext &context,
/* iterate over all faces to find a corresponding underlying UV */
for (int n = 0; n < mesh->totface; n++) {
MFace *face = &mface[n];
MTFace *tface = mtface + n;
const MFace *face = &mface[n];
const MTFace *tface = mtface + n;
uint vtx[4];
vtx[0] = face->v1;
vtx[1] = face->v2;
@ -244,8 +245,9 @@ void ABCHairWriter::write_hair_child_sample(const HierarchyContext &context,
float inv_mat[4][4];
invert_m4_m4_safe(inv_mat, context.object->object_to_world);
MFace *mface = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MTFace *mtface = (MTFace *)CustomData_get_layer(&mesh->fdata, CD_MTFACE);
const MFace *mface = (const MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
MTFace *mtface = (MTFace *)CustomData_get_layer_for_write(
&mesh->fdata, CD_MTFACE, mesh->totface);
const float(*positions)[3] = BKE_mesh_vert_positions(mesh);
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh);
@ -271,7 +273,7 @@ void ABCHairWriter::write_hair_child_sample(const HierarchyContext &context,
continue;
}
MFace *face = &mface[num];
const MFace *face = &mface[num];
MTFace *tface = mtface + num;
float r_uv[2], tmpnor[3], mapfw[4], vec[3];

2
source/blender/io/alembic/intern/abc_customdata.cc
View File

@ -535,7 +535,7 @@ void read_generated_coordinates(const ICompoundProperty &prop,
void *cd_data;
if (CustomData_has_layer(&mesh->vdata, CD_ORCO)) {
cd_data = CustomData_get_layer(&mesh->vdata, CD_ORCO);
cd_data = CustomData_get_layer_for_write(&mesh->vdata, CD_ORCO, mesh->totvert);
}
else {
cd_data = CustomData_add_layer(&mesh->vdata, CD_ORCO, CD_CONSTRUCT, nullptr, totvert);

3
source/blender/io/alembic/intern/abc_reader_mesh.cc
View File

@ -383,7 +383,8 @@ static void *add_customdata_cb(Mesh *mesh, const char *name, int data_type)
return nullptr;
}
void *cd_ptr = CustomData_get_layer_named(&mesh->ldata, cd_data_type, name);
void *cd_ptr = CustomData_get_layer_named_for_write(
&mesh->ldata, cd_data_type, name, mesh->totloop);
if (cd_ptr != nullptr) {
/* layer already exists, so just return it. */
return cd_ptr;

9
source/blender/io/collada/MeshImporter.cpp
View File

@ -719,8 +719,9 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
uvset_index++) {
/* get mtface by face index and uv set index */
COLLADAFW::IndexList &index_list = *index_list_array_uvcoord[uvset_index];
blender::float2 *mloopuv = static_cast<blender::float2 *>(CustomData_get_layer_named(
&me->ldata, CD_PROP_FLOAT2, index_list.getName().c_str()));
blender::float2 *mloopuv = static_cast<blender::float2 *>(
CustomData_get_layer_named_for_write(
&me->ldata, CD_PROP_FLOAT2, index_list.getName().c_str(), me->totloop));
if (mloopuv == nullptr) {
fprintf(stderr,
"Collada import: Mesh [%s] : Unknown reference to TEXCOORD [#%s].\n",
@ -762,8 +763,8 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh,
COLLADAFW::IndexList &color_index_list = *mp->getColorIndices(vcolor_index);
COLLADAFW::String colname = extract_vcolname(color_index_list.getName());
MLoopCol *mloopcol = (MLoopCol *)CustomData_get_layer_named(
&me->ldata, CD_PROP_BYTE_COLOR, colname.c_str());
MLoopCol *mloopcol = (MLoopCol *)CustomData_get_layer_named_for_write(
&me->ldata, CD_PROP_BYTE_COLOR, colname.c_str(), me->totloop);
if (mloopcol == nullptr) {
fprintf(stderr,
"Collada import: Mesh [%s] : Unknown reference to VCOLOR [#%s].\n",

2
source/blender/io/usd/intern/usd_reader_mesh.cc
View File

@ -204,7 +204,7 @@ static void *add_customdata_cb(Mesh *mesh, const char *name, const int data_type
}
loopdata = &mesh->ldata;
cd_ptr = CustomData_get_layer_named(loopdata, cd_data_type, name);
cd_ptr = CustomData_get_layer_named_for_write(loopdata, cd_data_type, name, mesh->totloop);
if (cd_ptr != nullptr) {
/* layer already exists, so just return it. */
return cd_ptr;

13
source/blender/makesrna/intern/rna_curves.c
View File

@ -77,8 +77,8 @@ static void rna_Curves_curve_offset_data_begin(CollectionPropertyIterator *iter,
static float (*get_curves_positions(Curves *curves))[3]
{
return (float(*)[3])CustomData_get_layer_named(
&curves->geometry.point_data, CD_PROP_FLOAT3, "position");
return (float(*)[3])CustomData_get_layer_named_for_write(
&curves->geometry.point_data, CD_PROP_FLOAT3, "position", curves->geometry.point_num);
}
static const float (*get_curves_positions_const(const Curves *curves))[3]
@ -152,9 +152,9 @@ static float rna_CurvePoint_radius_get(PointerRNA *ptr)
static void rna_CurvePoint_radius_set(PointerRNA *ptr, float value)
{
const Curves *curves = rna_curves(ptr);
float *radii = (float *)CustomData_get_layer_named(
&curves->geometry.point_data, CD_PROP_FLOAT, "radius");
Curves *curves = rna_curves(ptr);
float *radii = (float *)CustomData_get_layer_named_for_write(
&curves->geometry.point_data, CD_PROP_FLOAT, "radius", curves->geometry.point_num);
if (radii == NULL) {
return;
}
@ -212,8 +212,7 @@ static void rna_CurveSlice_points_begin(CollectionPropertyIterator *iter, Pointe
Curves *curves = rna_curves(ptr);
const int offset = rna_CurveSlice_first_point_index_get(ptr);
const int size = rna_CurveSlice_points_length_get(ptr);
float(*positions)[3] = (float(*)[3])CustomData_get_layer_named(
&curves->geometry.point_data, CD_PROP_FLOAT3, "position");
float(*positions)[3] = get_curves_positions(curves);
float(*co)[3] = positions + offset;
rna_iterator_array_begin(iter, co, sizeof(float[3]), size, 0, NULL);
}

68
source/blender/makesrna/intern/rna_mesh.c
View File

@ -469,7 +469,7 @@ static bool rna_MeshVertex_hide_get(PointerRNA *ptr)
static void rna_MeshVertex_hide_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *hide_vert = (bool *)CustomData_duplicate_referenced_layer_named(
bool *hide_vert = (bool *)CustomData_get_layer_named_for_write(
&mesh->vdata, CD_PROP_BOOL, ".hide_vert", mesh->totvert);
if (!hide_vert) {
if (!value) {
@ -495,7 +495,7 @@ static bool rna_MeshVertex_select_get(PointerRNA *ptr)
static void rna_MeshVertex_select_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *select_vert = (bool *)CustomData_duplicate_referenced_layer_named(
bool *select_vert = (bool *)CustomData_get_layer_named_for_write(
&mesh->vdata, CD_PROP_BOOL, ".select_vert", mesh->totvert);
if (!select_vert) {
if (!value) {
@ -564,13 +564,13 @@ static void rna_MeshLoop_normal_get(PointerRNA *ptr, float *values)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshLoop_index_get(ptr);
const float(*vec)[3] = CustomData_get(&me->ldata, index, CD_NORMAL);
const float(*layer)[3] = CustomData_get_layer(&me->ldata, CD_NORMAL);
if (!vec) {
if (!layer) {
zero_v3(values);
}
else {
copy_v3_v3(values, (const float *)vec);
copy_v3_v3(values, layer[index]);
}
}
@ -578,10 +578,10 @@ static void rna_MeshLoop_normal_set(PointerRNA *ptr, const float *values)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshLoop_index_get(ptr);
float(*vec)[3] = CustomData_get(&me->ldata, index, CD_NORMAL);
float(*layer)[3] = CustomData_get_layer_for_write(&me->ldata, CD_NORMAL, me->totloop);
if (vec) {
normalize_v3_v3(*vec, values);
if (layer) {
normalize_v3_v3(*layer, values + index);
}
}
@ -589,13 +589,13 @@ static void rna_MeshLoop_tangent_get(PointerRNA *ptr, float *values)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshLoop_index_get(ptr);
const float(*vec)[4] = CustomData_get(&me->ldata, index, CD_MLOOPTANGENT);
const float(*layer)[4] = CustomData_get_layer(&me->ldata, CD_MLOOPTANGENT);
if (!vec) {
if (!layer) {
zero_v3(values);
}
else {
copy_v3_v3(values, (const float *)vec);
copy_v3_v3(values, (const float *)(layer + index));
}
}
@ -603,21 +603,21 @@ static float rna_MeshLoop_bitangent_sign_get(PointerRNA *ptr)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshLoop_index_get(ptr);
const float(*vec)[4] = CustomData_get(&me->ldata, index, CD_MLOOPTANGENT);
const float(*vec)[4] = CustomData_get_layer(&me->ldata, CD_MLOOPTANGENT);
return (vec) ? (*vec)[3] : 0.0f;
return (vec) ? vec[index][3] : 0.0f;
}
static void rna_MeshLoop_bitangent_get(PointerRNA *ptr, float *values)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshLoop_index_get(ptr);
const float(*nor)[3] = CustomData_get(&me->ldata, index, CD_NORMAL);
const float(*vec)[4] = CustomData_get(&me->ldata, index, CD_MLOOPTANGENT);
const float(*nor)[3] = CustomData_get_layer(&me->ldata, CD_NORMAL);
const float(*vec)[4] = CustomData_get_layer(&me->ldata, CD_MLOOPTANGENT);
if (nor && vec) {
cross_v3_v3v3(values, (const float *)nor, (const float *)vec);
mul_v3_fl(values, (*vec)[3]);
cross_v3_v3v3(values, nor[index], vec[index]);
mul_v3_fl(values, vec[index][3]);
}
else {
zero_v3(values);
@ -645,7 +645,7 @@ static bool rna_MeshPolygon_hide_get(PointerRNA *ptr)
static void rna_MeshPolygon_hide_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *hide_poly = (bool *)CustomData_duplicate_referenced_layer_named(
bool *hide_poly = (bool *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".hide_poly", mesh->totpoly);
if (!hide_poly) {
if (!value) {
@ -671,7 +671,7 @@ static bool rna_MeshPolygon_select_get(PointerRNA *ptr)
static void rna_MeshPolygon_select_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *select_poly = (bool *)CustomData_duplicate_referenced_layer_named(
bool *select_poly = (bool *)CustomData_get_layer_named_for_write(
&mesh->pdata, CD_PROP_BOOL, ".select_poly", mesh->totpoly);
if (!select_poly) {
if (!value) {
@ -723,7 +723,7 @@ static void rna_MeshPolygon_flip(ID *id, MPoly *mp)
{
Mesh *me = (Mesh *)id;
MLoop *loops = BKE_mesh_loops_for_write(me);
BKE_mesh_polygon_flip(mp, loops, &me->ldata);
BKE_mesh_polygon_flip(mp, loops, &me->ldata, me->totloop);
BKE_mesh_tessface_clear(me);
BKE_mesh_runtime_clear_geometry(me);
}
@ -914,25 +914,25 @@ static bool rna_MEdge_freestyle_edge_mark_get(PointerRNA *ptr)
{
const Mesh *me = rna_mesh(ptr);
const int index = rna_MeshEdge_index_get(ptr);
const FreestyleEdge *fed = CustomData_get(&me->edata, index, CD_FREESTYLE_EDGE);
const FreestyleEdge *fed = CustomData_get_layer(&me->edata, CD_FREESTYLE_EDGE);
return fed && (fed->flag & FREESTYLE_EDGE_MARK) != 0;
return fed && (fed[index].flag & FREESTYLE_EDGE_MARK) != 0;
}
static void rna_MEdge_freestyle_edge_mark_set(PointerRNA *ptr, bool value)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshEdge_index_get(ptr);
FreestyleEdge *fed = CustomData_get(&me->edata, index, CD_FREESTYLE_EDGE);
FreestyleEdge *fed = CustomData_get_layer_for_write(&me->edata, CD_FREESTYLE_EDGE, me->totedge);
if (!fed) {
fed = CustomData_add_layer(&me->edata, CD_FREESTYLE_EDGE, CD_SET_DEFAULT, NULL, me->totedge);
}
if (value) {
fed->flag |= FREESTYLE_EDGE_MARK;
fed[index].flag |= FREESTYLE_EDGE_MARK;
}
else {
fed->flag &= ~FREESTYLE_EDGE_MARK;
fed[index].flag &= ~FREESTYLE_EDGE_MARK;
}
}
@ -940,25 +940,25 @@ static bool rna_MPoly_freestyle_face_mark_get(PointerRNA *ptr)
{
const Mesh *me = rna_mesh(ptr);
const int index = rna_MeshPolygon_index_get(ptr);
const FreestyleFace *ffa = CustomData_get(&me->pdata, index, CD_FREESTYLE_FACE);
const FreestyleFace *ffa = CustomData_get_layer(&me->pdata, CD_FREESTYLE_FACE);
return ffa && (ffa->flag & FREESTYLE_FACE_MARK) != 0;
return ffa && (ffa[index].flag & FREESTYLE_FACE_MARK) != 0;
}
static void rna_MPoly_freestyle_face_mark_set(PointerRNA *ptr, bool value)
{
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshPolygon_index_get(ptr);
FreestyleFace *ffa = CustomData_get(&me->pdata, index, CD_FREESTYLE_FACE);
FreestyleFace *ffa = CustomData_get_layer_for_write(&me->pdata, CD_FREESTYLE_FACE, me->totpoly);
if (!ffa) {
ffa = CustomData_add_layer(&me->pdata, CD_FREESTYLE_FACE, CD_SET_DEFAULT, NULL, me->totpoly);
}
if (value) {
ffa->flag |= FREESTYLE_FACE_MARK;
ffa[index].flag |= FREESTYLE_FACE_MARK;
}
else {
ffa->flag &= ~FREESTYLE_FACE_MARK;
ffa[index].flag &= ~FREESTYLE_FACE_MARK;
}
}
@ -1466,7 +1466,7 @@ static bool rna_MeshEdge_hide_get(PointerRNA *ptr)
static void rna_MeshEdge_hide_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *hide_edge = (bool *)CustomData_duplicate_referenced_layer_named(
bool *hide_edge = (bool *)CustomData_get_layer_named_for_write(
&mesh->edata, CD_PROP_BOOL, ".hide_edge", mesh->totedge);
if (!hide_edge) {
if (!value) {
@ -1492,7 +1492,7 @@ static bool rna_MeshEdge_select_get(PointerRNA *ptr)
static void rna_MeshEdge_select_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *select_edge = (bool *)CustomData_duplicate_referenced_layer_named(
bool *select_edge = (bool *)CustomData_get_layer_named_for_write(
&mesh->edata, CD_PROP_BOOL, ".select_edge", mesh->totedge);
if (!select_edge) {
if (!value) {
@ -1518,7 +1518,7 @@ static bool rna_MeshEdge_use_edge_sharp_get(PointerRNA *ptr)
static void rna_MeshEdge_use_edge_sharp_set(PointerRNA *ptr, bool value)
{
Mesh *mesh = rna_mesh(ptr);
bool *sharp_edge = (bool *)CustomData_duplicate_referenced_layer_named(
bool *sharp_edge = (bool *)CustomData_get_layer_named_for_write(
&mesh->edata, CD_PROP_BOOL, "sharp_edge", mesh->totedge);
if (!sharp_edge) {
if (!value) {
@ -1852,7 +1852,7 @@ static bool get_uv_index_and_layer(const PointerRNA *ptr,
/* We don't know from which attribute the RNA pointer is from, so we need to scan them all. */
const int uv_layers_num = CustomData_number_of_layers(&mesh->ldata, CD_PROP_FLOAT2);
for (int layer_i = 0; layer_i < uv_layers_num; layer_i++) {
const float(*layer_data)[2] = (float(*)[2])CustomData_get_layer_n(
const float(*layer_data)[2] = (const float(*)[2])CustomData_get_layer_n(
&mesh->ldata, CD_PROP_FLOAT2, layer_i);
const ptrdiff_t index = uv_coord - layer_data;
if (index >= 0 && index < mesh->totloop) {

2
source/blender/makesrna/intern/rna_mesh_api.c
View File

@ -60,7 +60,7 @@ static void rna_Mesh_calc_tangents(Mesh *mesh, ReportList *reports, const char *
float(*r_looptangents)[4];
if (CustomData_has_layer(&mesh->ldata, CD_MLOOPTANGENT)) {
r_looptangents = CustomData_get_layer(&mesh->ldata, CD_MLOOPTANGENT);
r_looptangents = CustomData_get_layer_for_write(&mesh->ldata, CD_MLOOPTANGENT, mesh->totloop);
memset(r_looptangents, 0, sizeof(float[4]) * mesh->totloop);
}
else {

6
source/blender/makesrna/intern/rna_pointcloud.c
View File

@ -35,7 +35,8 @@ static PointCloud *rna_pointcloud(const PointerRNA *ptr)
static float (*get_pointcloud_positions(PointCloud *pointcloud))[3]
{
return (float(*)[3])CustomData_get_layer_named(&pointcloud->pdata, CD_PROP_FLOAT3, "position");
return (float(*)[3])CustomData_get_layer_named_for_write(
&pointcloud->pdata, CD_PROP_FLOAT3, "position", pointcloud->totpoint);
}
static const float (*get_pointcloud_positions_const(const PointCloud *pointcloud))[3]
@ -110,7 +111,8 @@ static float rna_Point_radius_get(PointerRNA *ptr)
static void rna_Point_radius_set(PointerRNA *ptr, float value)
{
PointCloud *pointcloud = rna_pointcloud(ptr);
float *radii = (float *)CustomData_get_layer_named(&pointcloud->pdata, CD_PROP_FLOAT, "radius");
float *radii = (float *)CustomData_get_layer_named_for_write(
&pointcloud->pdata, CD_PROP_FLOAT, "radius", pointcloud->totpoint);
if (radii == NULL) {
return;
}

14
source/blender/modifiers/intern/MOD_array.cc
View File

@ -329,22 +329,26 @@ static void mesh_merge_transform(Mesh *result,
}
/* Set #CD_ORIGINDEX. */
index_orig = static_cast<int *>(CustomData_get_layer(&result->vdata, CD_ORIGINDEX));
index_orig = static_cast<int *>(
CustomData_get_layer_for_write(&result->vdata, CD_ORIGINDEX, result->totvert));
if (index_orig) {
copy_vn_i(index_orig + cap_verts_index, cap_nverts, ORIGINDEX_NONE);
}
index_orig = static_cast<int *>(CustomData_get_layer(&result->edata, CD_ORIGINDEX));
index_orig = static_cast<int *>(
CustomData_get_layer_for_write(&result->edata, CD_ORIGINDEX, result->totedge));
if (index_orig) {
copy_vn_i(index_orig + cap_edges_index, cap_nedges, ORIGINDEX_NONE);
}
index_orig = static_cast<int *>(CustomData_get_layer(&result->pdata, CD_ORIGINDEX));
index_orig = static_cast<int *>(
CustomData_get_layer_for_write(&result->pdata, CD_ORIGINDEX, result->totpoly));
if (index_orig) {
copy_vn_i(index_orig + cap_polys_index, cap_npolys, ORIGINDEX_NONE);
}
index_orig = static_cast<int *>(CustomData_get_layer(&result->ldata, CD_ORIGINDEX));
index_orig = static_cast<int *>(
CustomData_get_layer_for_write(&result->ldata, CD_ORIGINDEX, result->totloop));
if (index_orig) {
copy_vn_i(index_orig + cap_loops_index, cap_nloops, ORIGINDEX_NONE);
}
@ -663,7 +667,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
const int totuv = CustomData_number_of_layers(&result->ldata, CD_PROP_FLOAT2);
for (i = 0; i < totuv; i++) {
blender::float2 *dmloopuv = static_cast<blender::float2 *>(
CustomData_get_layer_n(&result->ldata, CD_PROP_FLOAT2, i));
CustomData_get_layer_n_for_write(&result->ldata, CD_PROP_FLOAT2, i, result->totloop));
dmloopuv += chunk_nloops;
for (c = 1; c < count; c++) {
const float uv_offset[2] = {

3
source/blender/modifiers/intern/MOD_cloth.c
View File

@ -113,7 +113,8 @@ static void deformVerts(ModifierData *md,
clmd->sim_parms->shapekey_rest);
if (kb && kb->data != NULL) {
float(*layerorco)[3];
if (!(layerorco = CustomData_get_layer(&mesh_src->vdata, CD_CLOTH_ORCO))) {
if (!(layerorco = CustomData_get_layer_for_write(
&mesh_src->vdata, CD_CLOTH_ORCO, mesh_src->totvert))) {
layerorco = CustomData_add_layer(
&mesh_src->vdata, CD_CLOTH_ORCO, CD_SET_DEFAULT, NULL, mesh_src->totvert);
}

3
source/blender/modifiers/intern/MOD_displace.cc
View File

@ -307,7 +307,8 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
BKE_mesh_calc_normals_split(mesh);
}
float(*clnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(ldata, CD_NORMAL));
float(*clnors)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(ldata, CD_NORMAL, mesh->totloop));
vert_clnors = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(*vert_clnors), __func__));
BKE_mesh_normals_loop_to_vertex(

40
source/blender/modifiers/intern/MOD_explode.c
View File

@ -100,7 +100,7 @@ static void createFacepa(ExplodeModifierData *emd, ParticleSystemModifierData *p
const bool invert_vgroup = (emd->flag & eExplodeFlag_INVERT_VGROUP) != 0;
float(*positions)[3] = BKE_mesh_vert_positions_for_write(mesh);
mface = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
mface = (MFace *)CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
totvert = mesh->totvert;
totface = mesh->totface;
totpart = psmd->psys->totpart;
@ -215,7 +215,7 @@ static const short add_faces[24] = {
static MFace *get_dface(Mesh *mesh, Mesh *split, int cur, int i, MFace *mf)
{
MFace *mfaces = CustomData_get_layer(&split->fdata, CD_MFACE);
MFace *mfaces = CustomData_get_layer_for_write(&split->fdata, CD_MFACE, split->totface);
MFace *df = &mfaces[cur];
CustomData_copy_data(&mesh->fdata, &split->fdata, i, cur, 1);
*df = *mf;
@ -284,11 +284,11 @@ static void remap_uvs_3_6_9_12(
int l;
for (l = 0; l < layers_num; l++) {
mf = CustomData_get_layer_n(&split->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&split->fdata, CD_MTFACE, l, split->totface);
df1 = mf + cur;
df2 = df1 + 1;
df3 = df1 + 2;
mf = CustomData_get_layer_n(&mesh->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&mesh->fdata, CD_MTFACE, l, mesh->totface);
mf += i;
copy_v2_v2(df1->uv[0], mf->uv[c0]);
@ -344,10 +344,10 @@ static void remap_uvs_5_10(
int l;
for (l = 0; l < layers_num; l++) {
mf = CustomData_get_layer_n(&split->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&split->fdata, CD_MTFACE, l, split->totface);
df1 = mf + cur;
df2 = df1 + 1;
mf = CustomData_get_layer_n(&mesh->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&mesh->fdata, CD_MTFACE, l, mesh->totface);
mf += i;
copy_v2_v2(df1->uv[0], mf->uv[c0]);
@ -416,12 +416,12 @@ static void remap_uvs_15(
int l;
for (l = 0; l < layers_num; l++) {
mf = CustomData_get_layer_n(&split->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&split->fdata, CD_MTFACE, l, split->totface);
df1 = mf + cur;
df2 = df1 + 1;
df3 = df1 + 2;
df4 = df1 + 3;
mf = CustomData_get_layer_n(&mesh->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&mesh->fdata, CD_MTFACE, l, mesh->totface);
mf += i;
copy_v2_v2(df1->uv[0], mf->uv[c0]);
@ -492,11 +492,11 @@ static void remap_uvs_7_11_13_14(
int l;
for (l = 0; l < layers_num; l++) {
mf = CustomData_get_layer_n(&split->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&split->fdata, CD_MTFACE, l, split->totface);
df1 = mf + cur;
df2 = df1 + 1;
df3 = df1 + 2;
mf = CustomData_get_layer_n(&mesh->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&mesh->fdata, CD_MTFACE, l, mesh->totface);
mf += i;
copy_v2_v2(df1->uv[0], mf->uv[c0]);
@ -552,10 +552,10 @@ static void remap_uvs_19_21_22(
int l;
for (l = 0; l < layers_num; l++) {
mf = CustomData_get_layer_n(&split->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&split->fdata, CD_MTFACE, l, split->totface);
df1 = mf + cur;
df2 = df1 + 1;
mf = CustomData_get_layer_n(&mesh->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&mesh->fdata, CD_MTFACE, l, mesh->totface);
mf += i;
copy_v2_v2(df1->uv[0], mf->uv[c0]);
@ -614,10 +614,10 @@ static void remap_uvs_23(
int l;
for (l = 0; l < layers_num; l++) {
mf = CustomData_get_layer_n(&split->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&split->fdata, CD_MTFACE, l, split->totface);
df1 = mf + cur;
df2 = df1 + 1;
mf = CustomData_get_layer_n(&mesh->fdata, CD_MTFACE, l);
mf = CustomData_get_layer_n_for_write(&mesh->fdata, CD_MTFACE, l, mesh->totface);
mf += i;
copy_v2_v2(df1->uv[0], mf->uv[c0]);
@ -639,7 +639,7 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
{
Mesh *split_m;
MFace *mf = NULL, *df1 = NULL;
MFace *mface = CustomData_get_layer(&mesh->fdata, CD_MFACE);
MFace *mface = CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
float *dupve;
EdgeHash *edgehash;
EdgeHashIterator *ehi;
@ -869,7 +869,7 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
curdupface += add_faces[*fs] + 1;
}
MFace *split_mface = CustomData_get_layer(&split_m->fdata, CD_MFACE);
MFace *split_mface = CustomData_get_layer_for_write(&split_m->fdata, CD_MFACE, split_m->totface);
for (i = 0; i < curdupface; i++) {
mf = &split_mface[i];
BKE_mesh_mface_index_validate(mf, &split_m->fdata, i, ((mf->flag & ME_FACE_SEL) ? 4 : 3));
@ -909,7 +909,7 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
totface = mesh->totface;
totvert = mesh->totvert;
mface = CustomData_get_layer(&mesh->fdata, CD_MFACE);
mface = CustomData_get_layer_for_write(&mesh->fdata, CD_MFACE, mesh->totface);
totpart = psmd->psys->totpart;
sim.depsgraph = ctx->depsgraph;
@ -971,7 +971,8 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
/* the final duplicated vertices */
explode = BKE_mesh_new_nomain_from_template(mesh, totdup, 0, totface - delface, 0, 0);
MTFace *mtface = CustomData_get_layer_named(&explode->fdata, CD_MTFACE, emd->uvname);
MTFace *mtface = CustomData_get_layer_named_for_write(
&explode->fdata, CD_MTFACE, emd->uvname, explode->totface);
/* getting back to object space */
invert_m4_m4(imat, ctx->object->object_to_world);
@ -1029,7 +1030,8 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
BLI_edgehashIterator_free(ehi);
/* Map new vertices to faces. */
MFace *explode_mface = CustomData_get_layer(&explode->fdata, CD_MFACE);
MFace *explode_mface = CustomData_get_layer_for_write(
&explode->fdata, CD_MFACE, explode->totface);
for (i = 0, u = 0; i < totface; i++) {
MFace source;
int orig_v4;

3
source/blender/modifiers/intern/MOD_multires.cc
View File

@ -261,7 +261,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
result = multires_as_mesh(mmd, ctx, mesh, subdiv);
if (use_clnors) {
float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&result->ldata, CD_NORMAL));
float(*lnors)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(&result->ldata, CD_NORMAL, result->totloop));
BLI_assert(lnors != nullptr);
BKE_mesh_set_custom_normals(result, lnors);
CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);

28
source/blender/modifiers/intern/MOD_normal_edit.cc
View File

@ -177,12 +177,13 @@ static void mix_normals(const float mix_factor,
static bool polygons_check_flip(MLoop *mloop,
float (*nos)[3],
CustomData *ldata,
const int totloop,
const MPoly *mpoly,
float (*poly_normals)[3],
const int polys_num)
{
const MPoly *mp;
MDisps *mdisp = static_cast<MDisps *>(CustomData_get_layer(ldata, CD_MDISPS));
MDisps *mdisp = static_cast<MDisps *>(CustomData_get_layer_for_write(ldata, CD_MDISPS, totloop));
int i;
bool flipped = false;
@ -325,9 +326,13 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
loops_num);
}
if (do_polynors_fix &&
polygons_check_flip(
mloop, nos, &mesh->ldata, mpoly, BKE_mesh_poly_normals_for_write(mesh), polys_num)) {
if (do_polynors_fix && polygons_check_flip(mloop,
nos,
&mesh->ldata,
mesh->totloop,
mpoly,
BKE_mesh_poly_normals_for_write(mesh),
polys_num)) {
/* We need to recompute vertex normals! */
BKE_mesh_normals_tag_dirty(mesh);
}
@ -444,9 +449,13 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
loops_num);
}
if (do_polynors_fix &&
polygons_check_flip(
mloop, nos, &mesh->ldata, mpoly, BKE_mesh_poly_normals_for_write(mesh), polys_num)) {
if (do_polynors_fix && polygons_check_flip(mloop,
nos,
&mesh->ldata,
mesh->totloop,
mpoly,
BKE_mesh_poly_normals_for_write(mesh),
polys_num)) {
BKE_mesh_normals_tag_dirty(mesh);
}
@ -553,10 +562,11 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
bke::SpanAttributeWriter<bool> sharp_edges = attributes.lookup_or_add_for_write_span<bool>(
"sharp_edge", ATTR_DOMAIN_EDGE);
short(*clnors)[2] = static_cast<short(*)[2]>(CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL));
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer_for_write(ldata, CD_CUSTOMLOOPNORMAL, loops_num));
if (use_current_clnors) {
clnors = static_cast<short(*)[2]>(
CustomData_duplicate_referenced_layer(ldata, CD_CUSTOMLOOPNORMAL, loops_num));
CustomData_get_layer_for_write(ldata, CD_CUSTOMLOOPNORMAL, loops_num));
loop_normals = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(loops_num), sizeof(*loop_normals), __func__));

8
source/blender/modifiers/intern/MOD_particleinstance.c
View File

@ -322,10 +322,10 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
MPoly *mpoly = BKE_mesh_polys_for_write(result);
MLoop *mloop = BKE_mesh_loops_for_write(result);
MLoopCol *mloopcols_index = CustomData_get_layer_named(
&result->ldata, CD_PROP_BYTE_COLOR, pimd->index_layer_name);
MLoopCol *mloopcols_value = CustomData_get_layer_named(
&result->ldata, CD_PROP_BYTE_COLOR, pimd->value_layer_name);
MLoopCol *mloopcols_index = CustomData_get_layer_named_for_write(
&result->ldata, CD_PROP_BYTE_COLOR, pimd->index_layer_name, result->totloop);
MLoopCol *mloopcols_value = CustomData_get_layer_named_for_write(
&result->ldata, CD_PROP_BYTE_COLOR, pimd->value_layer_name, result->totloop);
int *vert_part_index = NULL;
float *vert_part_value = NULL;
if (mloopcols_index != NULL) {

7
source/blender/modifiers/intern/MOD_screw.cc
View File

@ -394,7 +394,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
CustomData_add_layer(&result->pdata, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, int(maxPolys));
}
int *origindex = static_cast<int *>(CustomData_get_layer(&result->pdata, CD_ORIGINDEX));
int *origindex = static_cast<int *>(
CustomData_get_layer_for_write(&result->pdata, CD_ORIGINDEX, result->totpoly));
CustomData_copy_data(&mesh->vdata, &result->vdata, 0, 0, int(totvert));
@ -406,8 +407,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
if (mloopuv_layers_tot) {
uint uv_lay;
for (uv_lay = 0; uv_lay < mloopuv_layers_tot; uv_lay++) {
mloopuv_layers[uv_lay] = static_cast<blender::float2 *>(
CustomData_get_layer_n(&result->ldata, CD_PROP_FLOAT2, int(uv_lay)));
mloopuv_layers[uv_lay] = static_cast<blender::float2 *>(CustomData_get_layer_n_for_write(
&result->ldata, CD_PROP_FLOAT2, int(uv_lay), result->totloop));
}
if (ltmd->flag & MOD_SCREW_UV_STRETCH_V) {

5
source/blender/modifiers/intern/MOD_skin.c
View File

@ -922,7 +922,8 @@ static Mesh *subdivide_base(const Mesh *orig)
float(*out_vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *outedge = BKE_mesh_edges_for_write(result);
MVertSkin *outnode = CustomData_get_layer(&result->vdata, CD_MVERT_SKIN);
MVertSkin *outnode = CustomData_get_layer_for_write(
&result->vdata, CD_MVERT_SKIN, result->totvert);
MDeformVert *outdvert = NULL;
if (origdvert) {
outdvert = BKE_mesh_deform_verts_for_write(result);
@ -1909,7 +1910,7 @@ static void skin_set_orig_indices(Mesh *mesh)
static Mesh *base_skin(Mesh *origmesh, SkinModifierData *smd, eSkinErrorFlag *r_error)
{
Mesh *result;
MVertSkin *nodes;
const MVertSkin *nodes;
BMesh *bm;
EMat *emat;
SkinNode *skin_nodes;

2
source/blender/modifiers/intern/MOD_solidify_extrude.c
View File

@ -1042,7 +1042,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
}
/* add faces & edges */
origindex_edge = CustomData_get_layer(&result->edata, CD_ORIGINDEX);
origindex_edge = CustomData_get_layer_for_write(&result->edata, CD_ORIGINDEX, result->totedge);
orig_ed = (origindex_edge) ? &origindex_edge[(edges_num * stride) + newEdges] : NULL;
MEdge *ed = &medge[(edges_num * stride) + newEdges]; /* start after copied edges */
for (i = 0; i < rimVerts; i++, ed++) {

9
source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
View File

@ -1966,10 +1966,13 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
MPoly *mpoly = BKE_mesh_polys_for_write(result);
MLoop *mloop = BKE_mesh_loops_for_write(result);
int *origindex_edge = CustomData_get_layer(&result->edata, CD_ORIGINDEX);
int *origindex_poly = CustomData_get_layer(&result->pdata, CD_ORIGINDEX);
int *origindex_edge = CustomData_get_layer_for_write(
&result->edata, CD_ORIGINDEX, result->totedge);
int *origindex_poly = CustomData_get_layer_for_write(
&result->pdata, CD_ORIGINDEX, result->totpoly);
float *result_edge_bweight = CustomData_get_layer(&result->edata, CD_BWEIGHT);
float *result_edge_bweight = CustomData_get_layer_for_write(
&result->edata, CD_BWEIGHT, result->totedge);
if (bevel_convex != 0.0f || orig_vert_bweight != NULL) {
result_edge_bweight = CustomData_add_layer(
&result->edata, CD_BWEIGHT, CD_SET_DEFAULT, NULL, result->totedge);

3
source/blender/modifiers/intern/MOD_subsurf.cc
View File

@ -265,7 +265,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
}
if (use_clnors) {
float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&result->ldata, CD_NORMAL));
float(*lnors)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(&result->ldata, CD_NORMAL, result->totloop));
BLI_assert(lnors != nullptr);
BKE_mesh_set_custom_normals(result, lnors);
CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);

3
source/blender/modifiers/intern/MOD_triangulate.cc
View File

@ -74,7 +74,8 @@ static Mesh *triangulate_mesh(Mesh *mesh,
BM_mesh_free(bm);
if (keep_clnors) {
float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&result->ldata, CD_NORMAL));
float(*lnors)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_for_write(&result->ldata, CD_NORMAL, result->totloop));
BLI_assert(lnors != nullptr);
BKE_mesh_set_custom_normals(result, lnors);

5
source/blender/modifiers/intern/MOD_uvproject.cc
View File

@ -184,9 +184,8 @@ static Mesh *uvprojectModifier_do(UVProjectModifierData *umd,
polys_num = mesh->totpoly;
loops_num = mesh->totloop;
/* make sure we are not modifying the original UV map */
float(*mloop_uv)[2] = static_cast<float(*)[2]>(CustomData_duplicate_referenced_layer_named(
&mesh->ldata, CD_PROP_FLOAT2, uvname, loops_num));
float(*mloop_uv)[2] = static_cast<float(*)[2]>(
CustomData_get_layer_named_for_write(&mesh->ldata, CD_PROP_FLOAT2, uvname, loops_num));
coords = BKE_mesh_vert_coords_alloc(mesh, &verts_num);

5
source/blender/modifiers/intern/MOD_uvwarp.cc
View File

@ -197,9 +197,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
polys_num = mesh->totpoly;
loops_num = mesh->totloop;
/* make sure we are not modifying the original UV map */
float(*mloopuv)[2] = static_cast<float(*)[2]>(CustomData_duplicate_referenced_layer_named(
&mesh->ldata, CD_PROP_FLOAT2, uvname, loops_num));
float(*mloopuv)[2] = static_cast<float(*)[2]>(
CustomData_get_layer_named_for_write(&mesh->ldata, CD_PROP_FLOAT2, uvname, loops_num));
MOD_get_vgroup(ctx->object, mesh, umd->vgroup_name, &dvert, &defgrp_index);
UVWarpData data{};

2
source/blender/modifiers/intern/MOD_weighted_normal.cc
View File

@ -614,7 +614,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
const float split_angle = mesh->smoothresh;
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(&result->ldata, CD_CUSTOMLOOPNORMAL));
CustomData_get_layer_for_write(&result->ldata, CD_CUSTOMLOOPNORMAL, mesh->totloop));
/* Keep info whether we had clnors,
* it helps when generating clnor spaces and default normals. */

3
source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc
View File

@ -143,7 +143,8 @@ static MutableSpan<int> get_orig_index_layer(Mesh &mesh, const eAttrDomain domai
{
const bke::AttributeAccessor attributes = mesh.attributes();
CustomData &custom_data = get_customdata(mesh, domain);
if (int *orig_indices = static_cast<int *>(CustomData_get_layer(&custom_data, CD_ORIGINDEX))) {
if (int *orig_indices = static_cast<int *>(CustomData_get_layer_for_write(
&custom_data, CD_ORIGINDEX, attributes.domain_size(domain)))) {
return {orig_indices, attributes.domain_size(domain)};
}
return {};

2
source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
View File

@ -70,7 +70,7 @@ static void write_vertex_creases(Mesh &mesh, const VArray<float> &crease_varray)
float *crease;
if (CustomData_has_layer(&mesh.vdata, CD_CREASE)) {
crease = static_cast<float *>(
CustomData_duplicate_referenced_layer(&mesh.vdata, CD_CREASE, mesh.totvert));
CustomData_get_layer_for_write(&mesh.vdata, CD_CREASE, mesh.totvert));
}
else {
crease = static_cast<float *>(