blender
/
blender
136
406
Fork 589
Code Issues 6.3k Pull Requests 765 Projects 19 Wiki Activity

Mesh: Replace auto smooth with node group #108014

Merged
Hans Goudey merged 149 commits from HooglyBoogly/blender:refactor-mesh-corner-normals-lazy into main 2023-10-20 16:54:20 +02:00
Conversation 15 Commits 149 Files Changed 98 +239 -292
12 changed files with 239 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 55e1ef2c23 - Show all commits

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

@ -410,8 +410,6 @@ float (*BKE_mesh_vertex_normals_for_write(struct Mesh *mesh))[3];
*/ */
float (*BKE_mesh_poly_normals_for_write(struct Mesh *mesh))[3]; float (*BKE_mesh_poly_normals_for_write(struct Mesh *mesh))[3];
float (*BKE_mesh_corner_normals_for_write(struct Mesh *mesh))[3];
/** /**
* Mark the mesh's vertex normals non-dirty, for when they are calculated or assigned manually. * Mark the mesh's vertex normals non-dirty, for when they are calculated or assigned manually.
*/ */

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

@ -559,8 +559,6 @@ static void mesh_calc_modifier_final_normals(const Mesh *mesh_input,
* which deals with drawing differently. */ * which deals with drawing differently. */
BKE_mesh_ensure_normals_for_display(mesh_final); BKE_mesh_ensure_normals_for_display(mesh_final);
} }
} }
} }

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

@ -1,3 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2014 Blender Foundation. All rights reserved. */
/** \file /** \file
* \ingroup bke * \ingroup bke
@ -269,18 +271,19 @@ static void data_transfer_dtdata_type_preprocess(Mesh *me_src,
const float split_angle_dst = me_dst->smoothresh; const float split_angle_dst = me_dst->smoothresh;
/* This should be ensured by cddata_masks we pass to code generating/giving us me_src now. */ /* This should be ensured by cddata_masks we pass to code generating/giving us me_src now. */
BLI_assert(CustomData_get_layer(&me_src->ldata, CD_NORMAL) != NULL); BLI_assert(CustomData_get_layer(&me_src->ldata, CD_NORMAL) != nullptr);
(void)me_src; (void)me_src;
float(*loop_nors_dst)[3]; float(*loop_nors_dst)[3];
short(*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL); short(*custom_nors_dst)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL));
/* Cache loop nors into a temp CDLayer. */ /* Cache loop nors into a temp CDLayer. */
loop_nors_dst = CustomData_get_layer(ldata_dst, CD_NORMAL); loop_nors_dst = static_cast<float(*)[3]>(CustomData_get_layer(ldata_dst, CD_NORMAL));
const bool do_loop_nors_dst = (loop_nors_dst == NULL); const bool do_loop_nors_dst = (loop_nors_dst == nullptr);
if (do_loop_nors_dst) { if (do_loop_nors_dst) {
loop_nors_dst = CustomData_add_layer( loop_nors_dst = static_cast<float(*)[3]>(
ldata_dst, CD_NORMAL, CD_SET_DEFAULT, NULL, num_loops_dst); CustomData_add_layer(ldata_dst, CD_NORMAL, CD_SET_DEFAULT, nullptr, num_loops_dst));
CustomData_set_layer_flag(ldata_dst, CD_NORMAL, CD_FLAG_TEMPORARY); CustomData_set_layer_flag(ldata_dst, CD_NORMAL, CD_FLAG_TEMPORARY);
} }
if (dirty_nors_dst || do_loop_nors_dst) { if (dirty_nors_dst || do_loop_nors_dst) {
@ -297,8 +300,8 @@ static void data_transfer_dtdata_type_preprocess(Mesh *me_src,
num_polys_dst, num_polys_dst,
use_split_nors_dst, use_split_nors_dst,
split_angle_dst, split_angle_dst,
NULL, nullptr,
NULL, nullptr,
custom_nors_dst); custom_nors_dst);
} }
} }
@ -328,12 +331,14 @@ static void data_transfer_dtdata_type_postprocess(Object *UNUSED(ob_src),
CustomData *ldata_dst = &me_dst->ldata; CustomData *ldata_dst = &me_dst->ldata;
const float(*poly_nors_dst)[3] = BKE_mesh_poly_normals_ensure(me_dst); const float(*poly_nors_dst)[3] = BKE_mesh_poly_normals_ensure(me_dst);
float(*loop_nors_dst)[3] = CustomData_get_layer(ldata_dst, CD_NORMAL); float(*loop_nors_dst)[3] = static_cast<float(*)[3]>(
short(*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL); CustomData_get_layer(ldata_dst, CD_NORMAL));
short(*custom_nors_dst)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL));
if (!custom_nors_dst) { if (!custom_nors_dst) {
custom_nors_dst = CustomData_add_layer( custom_nors_dst = static_cast<short(*)[2]>(CustomData_add_layer(
ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, NULL, num_loops_dst); ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, nullptr, num_loops_dst));
} }
/* Note loop_nors_dst contains our custom normals as transferred from source... */ /* Note loop_nors_dst contains our custom normals as transferred from source... */
@ -362,7 +367,7 @@ static MeshRemapIslandsCalc data_transfer_get_loop_islands_generator(const int c
default: default:
break; break;
} }
return NULL; return nullptr;
} }
float data_transfer_interp_float_do(const int mix_mode, float data_transfer_interp_float_do(const int mix_mode,
@ -420,9 +425,9 @@ void data_transfer_layersmapping_add_item(ListBase *r_map,
cd_datatransfer_interp interp, cd_datatransfer_interp interp,
void *interp_data) void *interp_data)
{ {
CustomDataTransferLayerMap *item = MEM_mallocN(sizeof(*item), __func__); CustomDataTransferLayerMap *item = MEM_new<CustomDataTransferLayerMap>(__func__);
BLI_assert(data_dst != NULL); BLI_assert(data_dst != nullptr);
item->data_type = cddata_type; item->data_type = cddata_type;
item->mix_mode = mix_mode; item->mix_mode = mix_mode;
@ -485,7 +490,7 @@ static void data_transfer_layersmapping_add_item_cd(ListBase *r_map,
* \note * \note
* All those layer mapping handlers return false *only* if they were given invalid parameters. * All those layer mapping handlers return false *only* if they were given invalid parameters.
* This means that even if they do nothing, they will return true if all given parameters were OK. * This means that even if they do nothing, they will return true if all given parameters were OK.
* Also, r_map may be NULL, in which case they will 'only' create/delete destination layers * Also, r_map may be nullptr, in which case they will 'only' create/delete destination layers
* according to given parameters. * according to given parameters.
*/ */
static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map, static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map,
@ -506,10 +511,10 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
void *interp_data) void *interp_data)
{ {
const void *data_src; const void *data_src;
void *data_dst = NULL; void *data_dst = nullptr;
int idx_src = num_layers_src; int idx_src = num_layers_src;
int idx_dst, tot_dst = CustomData_number_of_layers(cd_dst, cddata_type); int idx_dst, tot_dst = CustomData_number_of_layers(cd_dst, cddata_type);
bool *data_dst_to_delete = NULL; bool *data_dst_to_delete = nullptr;
if (!use_layers_src) { if (!use_layers_src) {
/* No source at all, we can only delete all dest if requested... */ /* No source at all, we can only delete all dest if requested... */
@ -536,7 +541,7 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
if (use_create) { if (use_create) {
/* Create as much data layers as necessary! */ /* Create as much data layers as necessary! */
for (; idx_dst < idx_src; idx_dst++) { for (; idx_dst < idx_src; idx_dst++) {
CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
} }
} }
else { else {
@ -579,9 +584,9 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
case DT_LAYERS_NAME_DST: case DT_LAYERS_NAME_DST:
if (use_delete) { if (use_delete) {
if (tot_dst) { if (tot_dst) {
data_dst_to_delete = MEM_mallocN(sizeof(*data_dst_to_delete) * (size_t)tot_dst, data_dst_to_delete = static_cast<bool *>(
__func__); MEM_mallocN(sizeof(*data_dst_to_delete) * size_t(tot_dst), __func__));
memset(data_dst_to_delete, true, sizeof(*data_dst_to_delete) * (size_t)tot_dst); memset(data_dst_to_delete, true, sizeof(*data_dst_to_delete) * size_t(tot_dst));
} }
} }
@ -598,7 +603,7 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) { if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) {
if (use_create) { if (use_create) {
CustomData_add_layer_named( CustomData_add_layer_named(
cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst, name); cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst, name);
idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name); idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name);
} }
else { else {
@ -671,7 +676,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
{ {
int idx_src, idx_dst; int idx_src, idx_dst;
const void *data_src; const void *data_src;
void *data_dst = NULL; void *data_dst = nullptr;
if (CustomData_layertype_is_singleton(cddata_type)) { if (CustomData_layertype_is_singleton(cddata_type)) {
if (!(data_src = CustomData_get_layer(cd_src, cddata_type))) { if (!(data_src = CustomData_get_layer(cd_src, cddata_type))) {
@ -686,7 +691,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (!use_create) { if (!use_create) {
return true; return true;
} }
data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
} }
else if (use_dupref_dst && r_map) { else if (use_dupref_dst && r_map) {
/* If dest is a evaluated mesh (from modifier), /* If dest is a evaluated mesh (from modifier),
@ -739,7 +744,8 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (!use_create) { if (!use_create) {
return true; return true;
} }
data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); data_dst = CustomData_add_layer(
cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
} }
else { else {
/* If dest is a evaluated mesh (from modifier), /* If dest is a evaluated mesh (from modifier),
@ -762,7 +768,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
} }
/* Create as much data layers as necessary! */ /* Create as much data layers as necessary! */
for (; num <= idx_dst; num++) { for (; num <= idx_dst; num++) {
CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst);
} }
} }
/* If dest is a evaluated mesh (from modifier), /* If dest is a evaluated mesh (from modifier),
@ -781,7 +787,8 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (!use_create) { if (!use_create) {
return true; return true;
} }
CustomData_add_layer_named(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst, name); CustomData_add_layer_named(
cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst, name);
idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name); idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name);
} }
/* If dest is a evaluated mesh (from modifier), /* If dest is a evaluated mesh (from modifier),
@ -816,9 +823,9 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
} }
else if (fromlayers == DT_LAYERS_ALL_SRC) { else if (fromlayers == DT_LAYERS_ALL_SRC) {
int num_src = CustomData_number_of_layers(cd_src, cddata_type); int num_src = CustomData_number_of_layers(cd_src, cddata_type);
bool *use_layers_src = num_src ? bool *use_layers_src = num_src ? static_cast<bool *>(MEM_mallocN(
MEM_mallocN(sizeof(*use_layers_src) * (size_t)num_src, __func__) : sizeof(*use_layers_src) * size_t(num_src), __func__)) :
NULL; nullptr;
bool ret; bool ret;
if (use_layers_src) { if (use_layers_src) {
@ -873,8 +880,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
{ {
CustomData *cd_src, *cd_dst; CustomData *cd_src, *cd_dst;
cd_datatransfer_interp interp = NULL; cd_datatransfer_interp interp = nullptr;
void *interp_data = NULL; void *interp_data = nullptr;
if (elem_type == ME_VERT) { if (elem_type == ME_VERT) {
if (!(cddata_type & CD_FAKE)) { if (!(cddata_type & CD_FAKE)) {
@ -955,8 +962,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
return true; return true;
} }
if (r_map && ELEM(cddata_type, CD_FAKE_SHARP, CD_FAKE_SEAM)) { if (r_map && ELEM(cddata_type, CD_FAKE_SHARP, CD_FAKE_SEAM)) {
const size_t elem_size = sizeof(*((MEdge *)NULL)); const size_t elem_size = sizeof(*((MEdge *)nullptr));
const size_t data_size = sizeof(((MEdge *)NULL)->flag); const size_t data_size = sizeof(((MEdge *)nullptr)->flag);
const size_t data_offset = offsetof(MEdge, flag); const size_t data_offset = offsetof(MEdge, flag);
const uint64_t data_flag = (cddata_type == CD_FAKE_SHARP) ? ME_SHARP : ME_SEAM; const uint64_t data_flag = (cddata_type == CD_FAKE_SHARP) ? ME_SHARP : ME_SEAM;
@ -973,7 +980,7 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
data_size, data_size,
data_offset, data_offset,
data_flag, data_flag,
NULL, nullptr,
interp_data); interp_data);
return true; return true;
} }
@ -1049,8 +1056,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
return true; return true;
} }
if (r_map && cddata_type == CD_FAKE_SHARP) { if (r_map && cddata_type == CD_FAKE_SHARP) {
const size_t elem_size = sizeof(*((MPoly *)NULL)); const size_t elem_size = sizeof(*((MPoly *)nullptr));
const size_t data_size = sizeof(((MPoly *)NULL)->flag); const size_t data_size = sizeof(((MPoly *)nullptr)->flag);
const size_t data_offset = offsetof(MPoly, flag); const size_t data_offset = offsetof(MPoly, flag);
const uint64_t data_flag = ME_SMOOTH; const uint64_t data_flag = ME_SMOOTH;
@ -1067,7 +1074,7 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
data_size, data_size,
data_offset, data_offset,
data_flag, data_flag,
NULL, nullptr,
interp_data); interp_data);
return true; return true;
} }
@ -1096,7 +1103,7 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH)); BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH));
me_dst = ob_dst->data; me_dst = static_cast<Mesh *>(ob_dst->data);
/* Get source evaluated mesh. */ /* Get source evaluated mesh. */
BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask); BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask);
@ -1130,7 +1137,7 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
if (DT_DATATYPE_IS_VERT(dtdata_type)) { if (DT_DATATYPE_IS_VERT(dtdata_type)) {
const int num_elem_dst = me_dst->totvert; const int num_elem_dst = me_dst->totvert;
data_transfer_layersmapping_generate(NULL, data_transfer_layersmapping_generate(nullptr,
ob_src, ob_src,
ob_dst, ob_dst,
me_src, me_src,
@ -1139,18 +1146,18 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type, cddata_type,
0, 0,
0.0f, 0.0f,
NULL, nullptr,
num_elem_dst, num_elem_dst,
use_create, use_create,
use_delete, use_delete,
fromlayers, fromlayers,
tolayers, tolayers,
NULL); nullptr);
} }
if (DT_DATATYPE_IS_EDGE(dtdata_type)) { if (DT_DATATYPE_IS_EDGE(dtdata_type)) {
const int num_elem_dst = me_dst->totedge; const int num_elem_dst = me_dst->totedge;
data_transfer_layersmapping_generate(NULL, data_transfer_layersmapping_generate(nullptr,
ob_src, ob_src,
ob_dst, ob_dst,
me_src, me_src,
@ -1159,18 +1166,18 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type, cddata_type,
0, 0,
0.0f, 0.0f,
NULL, nullptr,
num_elem_dst, num_elem_dst,
use_create, use_create,
use_delete, use_delete,
fromlayers, fromlayers,
tolayers, tolayers,
NULL); nullptr);
} }
if (DT_DATATYPE_IS_LOOP(dtdata_type)) { if (DT_DATATYPE_IS_LOOP(dtdata_type)) {
const int num_elem_dst = me_dst->totloop; const int num_elem_dst = me_dst->totloop;
data_transfer_layersmapping_generate(NULL, data_transfer_layersmapping_generate(nullptr,
ob_src, ob_src,
ob_dst, ob_dst,
me_src, me_src,
@ -1179,18 +1186,18 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type, cddata_type,
0, 0,
0.0f, 0.0f,
NULL, nullptr,
num_elem_dst, num_elem_dst,
use_create, use_create,
use_delete, use_delete,
fromlayers, fromlayers,
tolayers, tolayers,
NULL); nullptr);
} }
if (DT_DATATYPE_IS_POLY(dtdata_type)) { if (DT_DATATYPE_IS_POLY(dtdata_type)) {
const int num_elem_dst = me_dst->totpoly; const int num_elem_dst = me_dst->totpoly;
data_transfer_layersmapping_generate(NULL, data_transfer_layersmapping_generate(nullptr,
ob_src, ob_src,
ob_dst, ob_dst,
me_src, me_src,
@ -1199,13 +1206,13 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type, cddata_type,
0, 0,
0.0f, 0.0f,
NULL, nullptr,
num_elem_dst, num_elem_dst,
use_create, use_create,
use_delete, use_delete,
fromlayers, fromlayers,
tolayers, tolayers,
NULL); nullptr);
} }
} }
} }
@ -1246,13 +1253,13 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
/* Assumed always true if not using an evaluated mesh as destination. */ /* Assumed always true if not using an evaluated mesh as destination. */
bool dirty_nors_dst = true; bool dirty_nors_dst = true;
const MDeformVert *mdef = NULL; const MDeformVert *mdef = nullptr;
int vg_idx = -1; int vg_idx = -1;
float *weights[DATAMAX] = {NULL}; float *weights[DATAMAX] = {nullptr};
MeshPairRemap geom_map[DATAMAX] = {{0}}; MeshPairRemap geom_map[DATAMAX] = {{0}};
bool geom_map_init[DATAMAX] = {0}; bool geom_map_init[DATAMAX] = {0};
ListBase lay_map = {NULL}; ListBase lay_map = {nullptr};
bool changed = false; bool changed = false;
bool is_modifier = false; bool is_modifier = false;
@ -1270,11 +1277,11 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
is_modifier = true; is_modifier = true;
} }
else { else {
me_dst = ob_dst->data; me_dst = static_cast<Mesh *>(ob_dst->data);
} }
if (vgroup_name) { if (vgroup_name) {
mdef = CustomData_get_layer(&me_dst->vdata, CD_MDEFORMVERT); mdef = static_cast<const MDeformVert *>(CustomData_get_layer(&me_dst->vdata, CD_MDEFORMVERT));
if (mdef) { if (mdef) {
vg_idx = BKE_id_defgroup_name_index(&me_dst->id, vgroup_name); vg_idx = BKE_id_defgroup_name_index(&me_dst->id, vgroup_name);
} }
@ -1287,7 +1294,7 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
if (is_modifier) { if (is_modifier) {
me_src = BKE_modifier_get_evaluated_mesh_from_evaluated_object(ob_src); me_src = BKE_modifier_get_evaluated_mesh_from_evaluated_object(ob_src);
if (me_src == NULL || if (me_src == nullptr ||
!CustomData_MeshMasks_are_matching(&ob_src->runtime.last_data_mask, &me_src_mask)) { !CustomData_MeshMasks_are_matching(&ob_src->runtime.last_data_mask, &me_src_mask)) {
CLOG_WARN(&LOG, "Data Transfer: source mesh data is not ready - dependency cycle?"); CLOG_WARN(&LOG, "Data Transfer: source mesh data is not ready - dependency cycle?");
return changed; return changed;
@ -1302,7 +1309,7 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
BKE_mesh_wrapper_ensure_mdata(me_src); BKE_mesh_wrapper_ensure_mdata(me_src);
if (auto_transform) { if (auto_transform) {
if (space_transform == NULL) { if (space_transform == nullptr) {
space_transform = &auto_space_transform; space_transform = &auto_space_transform;
} }
@ -1384,7 +1391,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
} }
if (mdef && vg_idx != -1 && !weights[VDATA]) { if (mdef && vg_idx != -1 && !weights[VDATA]) {
weights[VDATA] = MEM_mallocN(sizeof(*(weights[VDATA])) * (size_t)num_verts_dst, __func__); weights[VDATA] = static_cast<float *>(
MEM_mallocN(sizeof(*(weights[VDATA])) * size_t(num_verts_dst), __func__));
BKE_defvert_extract_vgroup_to_vertweights( BKE_defvert_extract_vgroup_to_vertweights(
mdef, vg_idx, num_verts_dst, invert_vgroup, weights[VDATA]); mdef, vg_idx, num_verts_dst, invert_vgroup, weights[VDATA]);
} }
@ -1407,9 +1415,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) { space_transform)) {
CustomDataTransferLayerMap *lay_mapit; CustomDataTransferLayerMap *lay_mapit;
changed |= (lay_map.first != NULL); changed |= (lay_map.first != nullptr);
for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit;
lay_mapit = lay_mapit->next) {
CustomData_data_transfer(&geom_map[VDATA], lay_mapit); CustomData_data_transfer(&geom_map[VDATA], lay_mapit);
} }
@ -1463,7 +1472,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
} }
if (mdef && vg_idx != -1 && !weights[EDATA]) { if (mdef && vg_idx != -1 && !weights[EDATA]) {
weights[EDATA] = MEM_mallocN(sizeof(*weights[EDATA]) * (size_t)num_edges_dst, __func__); weights[EDATA] = static_cast<float *>(
MEM_mallocN(sizeof(*weights[EDATA]) * size_t(num_edges_dst), __func__));
BKE_defvert_extract_vgroup_to_edgeweights( BKE_defvert_extract_vgroup_to_edgeweights(
mdef, vg_idx, num_verts_dst, edges_dst, num_edges_dst, invert_vgroup, weights[EDATA]); mdef, vg_idx, num_verts_dst, edges_dst, num_edges_dst, invert_vgroup, weights[EDATA]);
} }
@ -1486,9 +1496,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) { space_transform)) {
CustomDataTransferLayerMap *lay_mapit; CustomDataTransferLayerMap *lay_mapit;
changed |= (lay_map.first != NULL); changed |= (lay_map.first != nullptr);
for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit;
lay_mapit = lay_mapit->next) {
CustomData_data_transfer(&geom_map[EDATA], lay_mapit); CustomData_data_transfer(&geom_map[EDATA], lay_mapit);
} }
@ -1558,7 +1569,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
} }
if (mdef && vg_idx != -1 && !weights[LDATA]) { if (mdef && vg_idx != -1 && !weights[LDATA]) {
weights[LDATA] = MEM_mallocN(sizeof(*weights[LDATA]) * (size_t)num_loops_dst, __func__); weights[LDATA] = static_cast<float *>(
MEM_mallocN(sizeof(*weights[LDATA]) * size_t(num_loops_dst), __func__));
BKE_defvert_extract_vgroup_to_loopweights( BKE_defvert_extract_vgroup_to_loopweights(
mdef, vg_idx, num_verts_dst, loops_dst, num_loops_dst, invert_vgroup, weights[LDATA]); mdef, vg_idx, num_verts_dst, loops_dst, num_loops_dst, invert_vgroup, weights[LDATA]);
} }
@ -1581,9 +1593,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) { space_transform)) {
CustomDataTransferLayerMap *lay_mapit; CustomDataTransferLayerMap *lay_mapit;
changed |= (lay_map.first != NULL); changed |= (lay_map.first != nullptr);
for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit;
lay_mapit = lay_mapit->next) {
CustomData_data_transfer(&geom_map[LDATA], lay_mapit); CustomData_data_transfer(&geom_map[LDATA], lay_mapit);
} }
@ -1638,7 +1651,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
} }
if (mdef && vg_idx != -1 && !weights[PDATA]) { if (mdef && vg_idx != -1 && !weights[PDATA]) {
weights[PDATA] = MEM_mallocN(sizeof(*weights[PDATA]) * (size_t)num_polys_dst, __func__); weights[PDATA] = static_cast<float *>(
MEM_mallocN(sizeof(*weights[PDATA]) * size_t(num_polys_dst), __func__));
BKE_defvert_extract_vgroup_to_polyweights(mdef, BKE_defvert_extract_vgroup_to_polyweights(mdef,
vg_idx, vg_idx,
num_verts_dst, num_verts_dst,
@ -1668,9 +1682,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) { space_transform)) {
CustomDataTransferLayerMap *lay_mapit; CustomDataTransferLayerMap *lay_mapit;
changed |= (lay_map.first != NULL); changed |= (lay_map.first != nullptr);
for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit;
lay_mapit = lay_mapit->next) {
CustomData_data_transfer(&geom_map[PDATA], lay_mapit); CustomData_data_transfer(&geom_map[PDATA], lay_mapit);
} }
@ -1722,7 +1737,7 @@ bool BKE_object_data_transfer_mesh(struct Depsgraph *depsgraph,
scene, scene,
ob_src, ob_src,
ob_dst, ob_dst,
NULL, nullptr,
data_types, data_types,
use_create, use_create,
map_vert_mode, map_vert_mode,

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

@ -1763,43 +1763,6 @@ void BKE_mesh_vert_coords_apply_with_mat4(Mesh *mesh,
BKE_mesh_tag_coords_changed(mesh); BKE_mesh_tag_coords_changed(mesh);
} }
static void calc_normals_split(Mesh *mesh,
MLoopNorSpaceArray *r_lnors_spacearr,
float (*r_corner_normals)[3])
{
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);
const Span<MVert> verts = mesh->verts();
const Span<MEdge> edges = mesh->edges();
const Span<MPoly> polys = mesh->polys();
const Span<MLoop> loops = mesh->loops();
BKE_mesh_normals_loop_split(verts.data(),
BKE_mesh_vertex_normals_ensure(mesh),
verts.size(),
edges.data(),
edges.size(),
loops.data(),
r_corner_normals,
loops.size(),
polys.data(),
BKE_mesh_poly_normals_ensure(mesh),
polys.size(),
true,
split_angle,
nullptr,
r_lnors_spacearr,
clnors);
}
void BKE_mesh_calc_normals_split(Mesh *mesh)
{
BKE_mesh_calc_normals_split_ex(mesh, nullptr, ensure_corner_normal_layer(*mesh));
}
/* **** Depsgraph evaluation **** */ /* **** Depsgraph evaluation **** */
void BKE_mesh_eval_geometry(Depsgraph *depsgraph, Mesh *mesh) void BKE_mesh_eval_geometry(Depsgraph *depsgraph, Mesh *mesh)

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

@ -128,18 +128,6 @@ float (*BKE_mesh_poly_normals_for_write(Mesh *mesh))[3]
return mesh->runtime->poly_normals; return mesh->runtime->poly_normals;
} }
float (*BKE_mesh_corner_normals_for_write(Mesh *mesh))[3]
{
if (mesh->runtime->corner_normals == nullptr) {
mesh->runtime->corner_normals = (float(*)[3])MEM_malloc_arrayN(
mesh->totloop, sizeof(float[3]), __func__);
}
BLI_assert(MEM_allocN_len(mesh->runtime->corner_normals) >= sizeof(float[3]) * mesh->totloop);
return mesh->runtime->corner_normals;
}
void BKE_mesh_vertex_normals_clear_dirty(Mesh *mesh) void BKE_mesh_vertex_normals_clear_dirty(Mesh *mesh)
{ {
mesh->runtime->vert_normals_dirty = false; mesh->runtime->vert_normals_dirty = false;
@ -554,9 +542,13 @@ const float (*BKE_mesh_corner_normals_ensure(const Mesh *mesh))[3]
const Span<MPoly> polys = mesh_mutable.polys(); const Span<MPoly> polys = mesh_mutable.polys();
const Span<MLoop> loops = mesh_mutable.loops(); const Span<MLoop> loops = mesh_mutable.loops();
corner_normals = BKE_mesh_corner_normals_for_write(&mesh_mutable); if (mesh_mutable.runtime->corner_normals == nullptr) {
const short(*custom_nors_dst)[2] = (const short(*)[2])CustomData_get_layer( mesh_mutable.runtime->corner_normals = (float(*)[3])MEM_malloc_arrayN(
&mesh->ldata, CD_CUSTOMLOOPNORMAL); mesh_mutable.totloop, sizeof(float[3]), __func__);
}
const short(*custom_normals)[2] = (const short(*)[2])CustomData_get_layer(&mesh->ldata,
CD_CUSTOMLOOPNORMAL);
BKE_mesh_normals_loop_split(verts.data(), BKE_mesh_normals_loop_split(verts.data(),
vert_normals, vert_normals,
@ -569,10 +561,10 @@ const float (*BKE_mesh_corner_normals_ensure(const Mesh *mesh))[3]
polys.data(), polys.data(),
poly_normals, poly_normals,
polys.size(), polys.size(),
use_split_normals, true,
split_angle, mesh->smoothresh,
r_lnors_spacearr, nullptr,
clnors, custom_normals,
nullptr); nullptr);
BKE_mesh_corner_normals_clear_dirty(&mesh_mutable); BKE_mesh_corner_normals_clear_dirty(&mesh_mutable);

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

@ -340,9 +340,6 @@ static Mesh *mesh_wrapper_ensure_subdivision(Mesh *me)
const float(*lnors)[3] = BKE_mesh_corner_normals_ensure(subdiv_mesh); const float(*lnors)[3] = BKE_mesh_corner_normals_ensure(subdiv_mesh);
BKE_mesh_set_custom_normals(subdiv_mesh, lnors); BKE_mesh_set_custom_normals(subdiv_mesh, lnors);
} }
else if (runtime_data->calc_loop_normals) {
BKE_mesh_corner_normals_ensure(subdiv_mesh);
}
if (subdiv != runtime_data->subdiv) { if (subdiv != runtime_data->subdiv) {
BKE_subdiv_free(subdiv); BKE_subdiv_free(subdiv);

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

@ -364,26 +364,7 @@ void mesh_render_data_update_normals(MeshRenderData *mr, const eMRDataType data_
mr->poly_normals = BKE_mesh_poly_normals_ensure(mr->me); mr->poly_normals = BKE_mesh_poly_normals_ensure(mr->me);
} }
if (((data_flag & MR_DATA_LOOP_NOR) && is_auto_smooth) || (data_flag & MR_DATA_TAN_LOOP_NOR)) { if (((data_flag & MR_DATA_LOOP_NOR) && is_auto_smooth) || (data_flag & MR_DATA_TAN_LOOP_NOR)) {
mr->loop_normals = static_cast<float(*)[3]>( mr->loop_normals = BKE_mesh_corner_normals_ensure(mr->me);
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));
BKE_mesh_normals_loop_split(mr->mvert,
mr->vert_normals,
mr->vert_len,
mr->medge,
mr->edge_len,
mr->mloop,
mr->loop_normals,
mr->loop_len,
mr->mpoly,
mr->poly_normals,
mr->poly_len,
is_auto_smooth,
split_angle,
nullptr,
nullptr,
clnors);
} }
} }
else { else {
@ -403,8 +384,8 @@ void mesh_render_data_update_normals(MeshRenderData *mr, const eMRDataType data_
poly_normals = mr->bm_poly_normals; poly_normals = mr->bm_poly_normals;
} }
mr->loop_normals = static_cast<float(*)[3]>( mr->bm_loop_normals = static_cast<float(*)[3]>(
MEM_mallocN(sizeof(*mr->loop_normals) * mr->loop_len, __func__)); MEM_mallocN(sizeof(*mr->bm_loop_normals) * mr->loop_len, __func__));
const int clnors_offset = CustomData_get_offset(&mr->bm->ldata, CD_CUSTOMLOOPNORMAL); const int clnors_offset = CustomData_get_offset(&mr->bm->ldata, CD_CUSTOMLOOPNORMAL);
BM_loops_calc_normal_vcos(mr->bm, BM_loops_calc_normal_vcos(mr->bm,
vert_coords, vert_coords,
@ -412,11 +393,12 @@ void mesh_render_data_update_normals(MeshRenderData *mr, const eMRDataType data_
poly_normals, poly_normals,
is_auto_smooth, is_auto_smooth,
split_angle, split_angle,
mr->loop_normals, mr->bm_loop_normals,
nullptr, nullptr,
nullptr, nullptr,
clnors_offset, clnors_offset,
false); false);
mr->loop_normals = mr->bm_loop_normals;
} }
} }
} }
@ -601,7 +583,7 @@ MeshRenderData *mesh_render_data_create(Object *object,
void mesh_render_data_free(MeshRenderData *mr) void mesh_render_data_free(MeshRenderData *mr)
{ {
MEM_SAFE_FREE(mr->loop_normals); MEM_SAFE_FREE(mr->bm_loop_normals);
/* Loose geometry are owned by #MeshBufferCache. */ /* Loose geometry are owned by #MeshBufferCache. */
mr->ledges = nullptr; mr->ledges = nullptr;

3
source/blender/draw/intern/mesh_extractors/extract_mesh.hh
View File

@ -91,7 +91,8 @@ struct MeshRenderData {
const bool *select_vert; const bool *select_vert;
const bool *select_edge; const bool *select_edge;
const bool *select_poly; const bool *select_poly;
float (*loop_normals)[3]; const float (*loop_normals)[3];
float (*bm_loop_normals)[3];
int *lverts, *ledges; int *lverts, *ledges;
const char *active_color_name; const char *active_color_name;

8
source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
View File

@ -379,10 +379,10 @@ void OBJMesh::store_normal_coords_and_indices()
normal_to_index.reserve(export_mesh_->totpoly); normal_to_index.reserve(export_mesh_->totpoly);
loop_to_normal_index_.resize(export_mesh_->totloop); loop_to_normal_index_.resize(export_mesh_->totloop);
loop_to_normal_index_.fill(-1); loop_to_normal_index_.fill(-1);
const float(*lnors)[3] = static_cast<const float(*)[3]>( /* TODO: Only retrieve when necessary. */
CustomData_get_layer(&export_mesh_eval_->ldata, CD_NORMAL)); const float(*lnors)[3] = BKE_mesh_corner_normals_ensure(export_mesh_);
for (int poly_index = 0; poly_index < export_mesh_eval_->totpoly; ++poly_index) { for (int poly_index = 0; poly_index < export_mesh_->totpoly; ++poly_index) {
const MPoly &mpoly = polys[poly_index]; const MPoly &mpoly = mesh_polys_[poly_index];
bool need_per_loop_normals = lnors != nullptr || (mpoly.flag & ME_SMOOTH); bool need_per_loop_normals = lnors != nullptr || (mpoly.flag & ME_SMOOTH);
if (need_per_loop_normals) { if (need_per_loop_normals) {
for (int loop_of_poly = 0; loop_of_poly < mpoly.totloop; ++loop_of_poly) { for (int loop_of_poly = 0; loop_of_poly < mpoly.totloop; ++loop_of_poly) {

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

@ -126,10 +126,10 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
need_transform_relation = true; need_transform_relation = true;
} }
if (dmd->texture != NULL) { if (dmd->texture != nullptr) {
DEG_add_generic_id_relation(ctx->node, &dmd->texture->id, "Displace Modifier"); DEG_add_generic_id_relation(ctx->node, &dmd->texture->id, "Displace Modifier");
if (dmd->map_object != NULL && dmd->texmapping == MOD_DISP_MAP_OBJECT) { if (dmd->map_object != nullptr && dmd->texmapping == MOD_DISP_MAP_OBJECT) {
MOD_depsgraph_update_object_bone_relation( MOD_depsgraph_update_object_bone_relation(
ctx->node, dmd->map_object, dmd->map_bone, "Displace Modifier"); ctx->node, dmd->map_object, dmd->map_bone, "Displace Modifier");
need_transform_relation = true; need_transform_relation = true;
@ -273,11 +273,11 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
int defgrp_index; int defgrp_index;
float(*tex_co)[3]; float(*tex_co)[3];
float weight = 1.0f; /* init value unused but some compilers may complain */ float weight = 1.0f; /* init value unused but some compilers may complain */
float(*vert_clnors)[3] = NULL; float(*vert_clnors)[3] = nullptr;
float local_mat[4][4] = {{0}}; float local_mat[4][4] = {{0}};
const bool use_global_direction = dmd->space == MOD_DISP_SPACE_GLOBAL; const bool use_global_direction = dmd->space == MOD_DISP_SPACE_GLOBAL;
if (dmd->texture == NULL && dmd->direction == MOD_DISP_DIR_RGB_XYZ) { if (dmd->texture == nullptr && dmd->direction == MOD_DISP_DIR_RGB_XYZ) {
return; return;
} }
if (dmd->strength == 0.0f) { if (dmd->strength == 0.0f) {
@ -287,34 +287,32 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
mvert = BKE_mesh_verts_for_write(mesh); mvert = BKE_mesh_verts_for_write(mesh);
MOD_get_vgroup(ob, mesh, dmd->defgrp_name, &dvert, &defgrp_index); MOD_get_vgroup(ob, mesh, dmd->defgrp_name, &dvert, &defgrp_index);
if (defgrp_index >= 0 && dvert == NULL) { if (defgrp_index >= 0 && dvert == nullptr) {
/* There is a vertex group, but it has no vertices. */ /* There is a vertex group, but it has no vertices. */
return; return;
} }
Tex *tex_target = dmd->texture; Tex *tex_target = dmd->texture;
if (tex_target != NULL) { if (tex_target != nullptr) {
tex_co = MEM_calloc_arrayN((size_t)verts_num, sizeof(*tex_co), "displaceModifier_do tex_co"); tex_co = static_cast<float(*)[3]>(
MEM_calloc_arrayN(size_t(verts_num), sizeof(*tex_co), "displaceModifier_do tex_co"));
MOD_get_texture_coords((MappingInfoModifierData *)dmd, ctx, ob, mesh, vertexCos, tex_co); MOD_get_texture_coords((MappingInfoModifierData *)dmd, ctx, ob, mesh, vertexCos, tex_co);
MOD_init_texture((MappingInfoModifierData *)dmd, ctx); MOD_init_texture((MappingInfoModifierData *)dmd, ctx);
} }
else { else {
tex_co = NULL; tex_co = nullptr;
} }
if (direction == MOD_DISP_DIR_CLNOR) { if (direction == MOD_DISP_DIR_CLNOR) {
CustomData *ldata = &mesh->ldata; if (CustomData_has_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL)) {
vert_clnors = static_cast<float(*)[3]>(
if (CustomData_has_layer(ldata, CD_CUSTOMLOOPNORMAL)) { MEM_malloc_arrayN(verts_num, sizeof(*vert_clnors), __func__));
if (!CustomData_has_layer(ldata, CD_NORMAL)) { BKE_mesh_normals_loop_to_vertex(verts_num,
BKE_mesh_calc_normals_split(mesh); BKE_mesh_loops(mesh),
} mesh->totloop,
BKE_mesh_corner_normals_ensure(mesh),
float(*clnors)[3] = CustomData_get_layer(ldata, CD_NORMAL); vert_clnors);
vert_clnors = MEM_malloc_arrayN(verts_num, sizeof(*vert_clnors), __func__);
BKE_mesh_normals_loop_to_vertex(
verts_num, BKE_mesh_loops(mesh), mesh->totloop, (const float(*)[3])clnors, vert_clnors);
} }
else { else {
direction = MOD_DISP_DIR_NOR; direction = MOD_DISP_DIR_NOR;
@ -325,7 +323,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
copy_m4_m4(local_mat, ob->object_to_world); copy_m4_m4(local_mat, ob->object_to_world);
} }
DisplaceUserdata data = {NULL}; DisplaceUserdata data = {nullptr};
data.scene = DEG_get_evaluated_scene(ctx->depsgraph); data.scene = DEG_get_evaluated_scene(ctx->depsgraph);
data.dmd = dmd; data.dmd = dmd;
data.dvert = dvert; data.dvert = dvert;
@ -342,7 +340,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
data.vert_normals = BKE_mesh_vertex_normals_ensure(mesh); data.vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
} }
data.vert_clnors = vert_clnors; data.vert_clnors = vert_clnors;
if (tex_target != NULL) { if (tex_target != nullptr) {
data.pool = BKE_image_pool_new(); data.pool = BKE_image_pool_new();
BKE_texture_fetch_images_for_pool(tex_target, data.pool); BKE_texture_fetch_images_for_pool(tex_target, data.pool);
} }
@ -351,7 +349,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
settings.use_threading = (verts_num > 512); settings.use_threading = (verts_num > 512);
BLI_task_parallel_range(0, verts_num, &data, displaceModifier_do_task, &settings); BLI_task_parallel_range(0, verts_num, &data, displaceModifier_do_task, &settings);
if (data.pool != NULL) { if (data.pool != nullptr) {
BKE_image_pool_free(data.pool); BKE_image_pool_free(data.pool);
} }
@ -370,12 +368,12 @@ static void deformVerts(ModifierData *md,
float (*vertexCos)[3], float (*vertexCos)[3],
int verts_num) int verts_num)
{ {
Mesh *mesh_src = MOD_deform_mesh_eval_get(ctx->object, NULL, mesh, NULL, verts_num, false); Mesh *mesh_src = MOD_deform_mesh_eval_get(ctx->object, nullptr, mesh, nullptr, verts_num, false);
displaceModifier_do((DisplaceModifierData *)md, ctx, mesh_src, vertexCos, verts_num); displaceModifier_do((DisplaceModifierData *)md, ctx, mesh_src, vertexCos, verts_num);
if (!ELEM(mesh_src, NULL, mesh)) { if (!ELEM(mesh_src, nullptr, mesh)) {
BKE_id_free(NULL, mesh_src); BKE_id_free(nullptr, mesh_src);
} }
} }
@ -386,17 +384,18 @@ static void deformVertsEM(ModifierData *md,
float (*vertexCos)[3], float (*vertexCos)[3],
int verts_num) int verts_num)
{ {
Mesh *mesh_src = MOD_deform_mesh_eval_get(ctx->object, editData, mesh, NULL, verts_num, false); Mesh *mesh_src = MOD_deform_mesh_eval_get(
ctx->object, editData, mesh, nullptr, verts_num, false);
/* TODO(@campbellbarton): use edit-mode data only (remove this line). */ /* TODO(@campbellbarton): use edit-mode data only (remove this line). */
if (mesh_src != NULL) { if (mesh_src != nullptr) {
BKE_mesh_wrapper_ensure_mdata(mesh_src); BKE_mesh_wrapper_ensure_mdata(mesh_src);
} }
displaceModifier_do((DisplaceModifierData *)md, ctx, mesh_src, vertexCos, verts_num); displaceModifier_do((DisplaceModifierData *)md, ctx, mesh_src, vertexCos, verts_num);
if (!ELEM(mesh_src, NULL, mesh)) { if (!ELEM(mesh_src, nullptr, mesh)) {
BKE_id_free(NULL, mesh_src); BKE_id_free(nullptr, mesh_src);
} }
} }
@ -416,7 +415,7 @@ static void panel_draw(const bContext *C, Panel *panel)
uiLayoutSetPropSep(layout, true); uiLayoutSetPropSep(layout, true);
uiTemplateID(layout, C, ptr, "texture", "texture.new", NULL, NULL, 0, ICON_NONE, NULL); uiTemplateID(layout, C, ptr, "texture", "texture.new", nullptr, nullptr, 0, ICON_NONE, nullptr);
col = uiLayoutColumn(layout, false); col = uiLayoutColumn(layout, false);
uiLayoutSetActive(col, has_texture); uiLayoutSetActive(col, has_texture);
@ -437,7 +436,7 @@ static void panel_draw(const bContext *C, Panel *panel)
} }
} }
else if (texture_coords == MOD_DISP_MAP_UV && RNA_enum_get(&ob_ptr, "type") == OB_MESH) { else if (texture_coords == MOD_DISP_MAP_UV && RNA_enum_get(&ob_ptr, "type") == OB_MESH) {
uiItemPointerR(col, ptr, "uv_layer", &obj_data_ptr, "uv_layers", NULL, ICON_NONE); uiItemPointerR(col, ptr, "uv_layer", &obj_data_ptr, "uv_layers", nullptr, ICON_NONE);
} }
uiItemS(layout); uiItemS(layout);
@ -449,16 +448,16 @@ static void panel_draw(const bContext *C, Panel *panel)
MOD_DISP_DIR_Y, MOD_DISP_DIR_Y,
MOD_DISP_DIR_Z, MOD_DISP_DIR_Z,
MOD_DISP_DIR_RGB_XYZ)) { MOD_DISP_DIR_RGB_XYZ)) {
uiItemR(col, ptr, "space", 0, NULL, ICON_NONE); uiItemR(col, ptr, "space", 0, nullptr, ICON_NONE);
} }
uiItemS(layout); uiItemS(layout);
col = uiLayoutColumn(layout, false); col = uiLayoutColumn(layout, false);
uiItemR(col, ptr, "strength", 0, NULL, ICON_NONE); uiItemR(col, ptr, "strength", 0, nullptr, ICON_NONE);
uiItemR(col, ptr, "mid_level", 0, NULL, ICON_NONE); uiItemR(col, ptr, "mid_level", 0, nullptr, ICON_NONE);
modifier_vgroup_ui(col, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", NULL); modifier_vgroup_ui(col, ptr, &ob_ptr, "vertex_group", "invert_vertex_group", nullptr);
modifier_panel_end(layout, ptr); modifier_panel_end(layout, ptr);
} }
@ -480,23 +479,23 @@ ModifierTypeInfo modifierType_Displace = {
/* copyData */ BKE_modifier_copydata_generic, /* copyData */ BKE_modifier_copydata_generic,
/* deformVerts */ deformVerts, /* deformVerts */ deformVerts,
/* deformMatrices */ NULL, /* deformMatrices */ nullptr,
/* deformVertsEM */ deformVertsEM, /* deformVertsEM */ deformVertsEM,
/* deformMatricesEM */ NULL, /* deformMatricesEM */ nullptr,
/* modifyMesh */ NULL, /* modifyMesh */ nullptr,
/* modifyGeometrySet */ NULL, /* modifyGeometrySet */ nullptr,
/* initData */ initData, /* initData */ initData,
/* requiredDataMask */ requiredDataMask, /* requiredDataMask */ requiredDataMask,
/* freeData */ NULL, /* freeData */ nullptr,
/* isDisabled */ isDisabled, /* isDisabled */ isDisabled,
/* updateDepsgraph */ updateDepsgraph, /* updateDepsgraph */ updateDepsgraph,
/* dependsOnTime */ dependsOnTime, /* dependsOnTime */ dependsOnTime,
/* dependsOnNormals */ dependsOnNormals, /* dependsOnNormals */ dependsOnNormals,
/* foreachIDLink */ foreachIDLink, /* foreachIDLink */ foreachIDLink,
/* foreachTexLink */ foreachTexLink, /* foreachTexLink */ foreachTexLink,
/* freeRuntimeData */ NULL, /* freeRuntimeData */ nullptr,
/* panelRegister */ panelRegister, /* panelRegister */ panelRegister,
/* blendWrite */ NULL, /* blendWrite */ nullptr,
/* blendRead */ NULL, /* blendRead */ nullptr,
}; };

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

@ -45,40 +45,39 @@ static Mesh *triangulate_mesh(Mesh *mesh,
BMesh *bm; BMesh *bm;
int edges_num, i; int edges_num, i;
MEdge *me; MEdge *me;
CustomData_MeshMasks cd_mask_extra = { CustomData_MeshMasks cd_mask_extra{};
.vmask = CD_MASK_ORIGINDEX, .emask = CD_MASK_ORIGINDEX, .pmask = CD_MASK_ORIGINDEX}; cd_mask_extra.vmask = CD_MASK_ORIGINDEX;
cd_mask_extra.emask = CD_MASK_ORIGINDEX;
cd_mask_extra.pmask = CD_MASK_ORIGINDEX;
bool keep_clnors = (flag & MOD_TRIANGULATE_KEEP_CUSTOMLOOP_NORMALS) != 0; bool keep_clnors = (flag & MOD_TRIANGULATE_KEEP_CUSTOMLOOP_NORMALS) != 0;
if (keep_clnors) { if (keep_clnors) {
BKE_mesh_calc_normals_split(mesh); CustomData_add_layer(&mesh->ldata,
/* We need that one to 'survive' to/from BMesh conversions. */ CD_NORMAL,
CustomData_clear_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY); CD_DUPLICATE,
cd_mask_extra.lmask |= CD_MASK_NORMAL; const_cast<float(*)[3]>(BKE_mesh_corner_normals_ensure(mesh)),
mesh->totloop);
} }
bm = BKE_mesh_to_bmesh_ex(mesh, BMeshCreateParams bmesh_create_params{};
&((struct BMeshCreateParams){0}), BMeshFromMeshParams bmesh_from_mesh_params{};
&((struct BMeshFromMeshParams){ bmesh_from_mesh_params.calc_face_normal = true;
.calc_face_normal = true, bmesh_from_mesh_params.calc_vert_normal = false;
.calc_vert_normal = false, bmesh_from_mesh_params.cd_mask_extra = cd_mask_extra;
.cd_mask_extra = cd_mask_extra,
}));
BM_mesh_triangulate(bm, quad_method, ngon_method, min_vertices, false, NULL, NULL, NULL); bm = BKE_mesh_to_bmesh_ex(mesh, &bmesh_create_params, &bmesh_from_mesh_params);
BM_mesh_triangulate(
bm, quad_method, ngon_method, min_vertices, false, nullptr, nullptr, nullptr);
result = BKE_mesh_from_bmesh_for_eval_nomain(bm, &cd_mask_extra, mesh); result = BKE_mesh_from_bmesh_for_eval_nomain(bm, &cd_mask_extra, mesh);
BM_mesh_free(bm); BM_mesh_free(bm);
if (keep_clnors) { if (keep_clnors) {
float(*lnors)[3] = CustomData_get_layer(&result->ldata, CD_NORMAL); float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&result->ldata, CD_NORMAL));
BLI_assert(lnors != NULL);
BKE_mesh_set_custom_normals(result, lnors); BKE_mesh_set_custom_normals(result, lnors);
CustomData_free_layers(&result->ldata, CD_NORMAL, result->totloop);
/* Do some cleanup, we do not want those temp data to stay around. */
CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
CustomData_set_layer_flag(&result->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
} }
edges_num = result->totedge; edges_num = result->totedge;
@ -125,10 +124,10 @@ static void panel_draw(const bContext *UNUSED(C), Panel *panel)
uiLayoutSetPropSep(layout, true); uiLayoutSetPropSep(layout, true);
uiItemR(layout, ptr, "quad_method", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "quad_method", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "ngon_method", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "ngon_method", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "min_vertices", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "min_vertices", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "keep_custom_normals", 0, NULL, ICON_NONE); uiItemR(layout, ptr, "keep_custom_normals", 0, nullptr, ICON_NONE);
modifier_panel_end(layout, ptr); modifier_panel_end(layout, ptr);
} }
@ -151,24 +150,24 @@ ModifierTypeInfo modifierType_Triangulate = {
/* copyData */ BKE_modifier_copydata_generic, /* copyData */ BKE_modifier_copydata_generic,
/* deformVerts */ NULL, /* deformVerts */ nullptr,
/* deformMatrices */ NULL, /* deformMatrices */ nullptr,
/* deformVertsEM */ NULL, /* deformVertsEM */ nullptr,
/* deformMatricesEM */ NULL, /* deformMatricesEM */ nullptr,
/* modifyMesh */ modifyMesh, /* modifyMesh */ modifyMesh,
/* modifyGeometrySet */ NULL, /* modifyGeometrySet */ nullptr,
/* initData */ initData, /* initData */ initData,
/* requiredDataMask */ NULL, // requiredDataMask, /* requiredDataMask */ nullptr, // requiredDataMask,
/* freeData */ NULL, /* freeData */ nullptr,
/* isDisabled */ NULL, /* isDisabled */ nullptr,
/* updateDepsgraph */ NULL, /* updateDepsgraph */ nullptr,
/* dependsOnTime */ NULL, /* dependsOnTime */ nullptr,
/* dependsOnNormals */ NULL, /* dependsOnNormals */ nullptr,
/* foreachIDLink */ NULL, /* foreachIDLink */ nullptr,
/* foreachTexLink */ NULL, /* foreachTexLink */ nullptr,
/* freeRuntimeData */ NULL, /* freeRuntimeData */ nullptr,
/* panelRegister */ panelRegister, /* panelRegister */ panelRegister,
/* blendWrite */ NULL, /* blendWrite */ nullptr,
/* blendRead */ NULL, /* blendRead */ nullptr,
}; };

91
source/blender/render/intern/multires_bake.cc
View File

@ -1,3 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2012 Blender Foundation. All rights reserved. */
/** \file /** \file
* \ingroup render * \ingroup render
@ -381,14 +383,14 @@ static void *do_multires_bake_thread(void *data_v)
while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) { while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) {
const MLoopTri *lt = &data->mlooptri[tri_index]; const MLoopTri *lt = &data->mlooptri[tri_index];
const short mat_nr = data->material_indices == NULL ? 0 : data->material_indices[lt->poly]; const short mat_nr = data->material_indices == nullptr ? 0 : data->material_indices[lt->poly];
const MLoopUV *mloopuv = data->mloopuv; const MLoopUV *mloopuv = data->mloopuv;
if (multiresbake_test_break(bkr)) { if (multiresbake_test_break(bkr)) {
break; break;
} }
Image *tri_image = mat_nr < bkr->ob_image.len ? bkr->ob_image.array[mat_nr] : NULL; Image *tri_image = mat_nr < bkr->ob_image.len ? bkr->ob_image.array[mat_nr] : nullptr;
if (tri_image != handle->image) { if (tri_image != handle->image) {
continue; continue;
} }
@ -418,14 +420,14 @@ static void *do_multires_bake_thread(void *data_v)
} }
if (bkr->progress) { if (bkr->progress) {
*bkr->progress = ((float)bkr->baked_objects + *bkr->progress = (float(bkr->baked_objects) +
(float)bkr->baked_faces / handle->queue->tot_tri) / float(bkr->baked_faces) / handle->queue->tot_tri) /
bkr->tot_obj; bkr->tot_obj;
} }
BLI_spin_unlock(&handle->queue->spin); BLI_spin_unlock(&handle->queue->spin);
} }
return NULL; return nullptr;
} }
/* some of arrays inside ccgdm are lazy-initialized, which will generally /* some of arrays inside ccgdm are lazy-initialized, which will generally
@ -473,13 +475,13 @@ static void do_multires_bake(MultiresBakeRender *bkr,
MVert *mvert = dm->getVertArray(dm); MVert *mvert = dm->getVertArray(dm);
MPoly *mpoly = dm->getPolyArray(dm); MPoly *mpoly = dm->getPolyArray(dm);
MLoop *mloop = dm->getLoopArray(dm); MLoop *mloop = dm->getLoopArray(dm);
MLoopUV *mloopuv = dm->getLoopDataArray(dm, CD_MLOOPUV); MLoopUV *mloopuv = static_cast<MLoopUV *>(dm->getLoopDataArray(dm, CD_MLOOPUV));
float *pvtangent = NULL; float *pvtangent = nullptr;
ListBase threads; ListBase threads;
int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count(); int i, tot_thread = bkr->threads > 0 ? bkr->threads : BLI_system_thread_count();
void *bake_data = NULL; void *bake_data = nullptr;
Mesh *temp_mesh = BKE_mesh_new_nomain( Mesh *temp_mesh = BKE_mesh_new_nomain(
dm->getNumVerts(dm), dm->getNumEdges(dm), 0, dm->getNumLoops(dm), dm->getNumPolys(dm)); dm->getNumVerts(dm), dm->getNumEdges(dm), 0, dm->getNumLoops(dm), dm->getNumPolys(dm));
@ -509,19 +511,19 @@ static void do_multires_bake(MultiresBakeRender *bkr,
dm->getNumLoopTri(dm), dm->getNumLoopTri(dm),
&dm->loopData, &dm->loopData,
true, true,
NULL, nullptr,
0, 0,
vert_normals, vert_normals,
poly_normals, poly_normals,
(const float(*)[3])dm->getLoopDataArray(dm, CD_NORMAL), BKE_mesh_corner_normals_ensure(temp_mesh),
(const float(*)[3])dm->getVertDataArray(dm, CD_ORCO), /* may be nullptr */ (const float(*)[3])dm->getVertDataArray(dm, CD_ORCO), /* May be nullptr. */
/* result */ /* result */
&dm->loopData, &dm->loopData,
dm->getNumLoops(dm), dm->getNumLoops(dm),
&dm->tangent_mask); &dm->tangent_mask);
} }
pvtangent = DM_get_loop_data_layer(dm, CD_TANGENT); pvtangent = static_cast<float *>(DM_get_loop_data_layer(dm, CD_TANGENT));
} }
/* all threads shares the same custom bake data */ /* all threads shares the same custom bake data */
@ -533,7 +535,7 @@ static void do_multires_bake(MultiresBakeRender *bkr,
BLI_threadpool_init(&threads, do_multires_bake_thread, tot_thread); BLI_threadpool_init(&threads, do_multires_bake_thread, tot_thread);
} }
handles = MEM_callocN(tot_thread * sizeof(MultiresBakeThread), "do_multires_bake handles"); handles = MEM_cnew_array<MultiresBakeThread>(tot_thread, "do_multires_bake handles");
init_ccgdm_arrays(bkr->hires_dm); init_ccgdm_arrays(bkr->hires_dm);
@ -551,8 +553,8 @@ static void do_multires_bake(MultiresBakeRender *bkr,
handle->queue = &queue; handle->queue = &queue;
handle->data.mpoly = mpoly; handle->data.mpoly = mpoly;
handle->data.material_indices = CustomData_get_layer_named( handle->data.material_indices = static_cast<const int *>(
&dm->polyData, CD_PROP_INT32, "material_index"); CustomData_get_layer_named(&dm->polyData, CD_PROP_INT32, "material_index"));
handle->data.mvert = mvert; handle->data.mvert = mvert;
handle->data.vert_normals = vert_normals; handle->data.vert_normals = vert_normals;
handle->data.mloopuv = mloopuv; handle->data.mloopuv = mloopuv;
@ -607,7 +609,7 @@ static void do_multires_bake(MultiresBakeRender *bkr,
MEM_freeN(handles); MEM_freeN(handles);
BKE_id_free(NULL, temp_mesh); BKE_id_free(nullptr, temp_mesh);
} }
/* mode = 0: interpolate normals, /* mode = 0: interpolate normals,
@ -619,10 +621,10 @@ static void interp_bilinear_grid(
float u, v; float u, v;
float data[4][3]; float data[4][3];
x0 = (int)crn_x; x0 = int(crn_x);
x1 = x0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (x0 + 1); x1 = x0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (x0 + 1);
y0 = (int)crn_y; y0 = int(crn_y);
y1 = y0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (y0 + 1); y1 = y0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (y0 + 1);
u = crn_x - x0; u = crn_x - x0;
@ -702,11 +704,11 @@ static void get_ccgdm_data(DerivedMesh *lodm,
CLAMP(crn_x, 0.0f, grid_size); CLAMP(crn_x, 0.0f, grid_size);
CLAMP(crn_y, 0.0f, grid_size); CLAMP(crn_y, 0.0f, grid_size);
if (n != NULL) { if (n != nullptr) {
interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 0, n); interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 0, n);
} }
if (co != NULL) { if (co != nullptr) {
interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co); interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);
} }
} }
@ -770,19 +772,19 @@ static void *init_heights_data(MultiresBakeRender *bkr, ImBuf *ibuf)
{ {
MHeightBakeData *height_data; MHeightBakeData *height_data;
DerivedMesh *lodm = bkr->lores_dm; DerivedMesh *lodm = bkr->lores_dm;
BakeImBufuserData *userdata = ibuf->userdata; BakeImBufuserData *userdata = static_cast<BakeImBufuserData *>(ibuf->userdata);
if (userdata->displacement_buffer == NULL) { if (userdata->displacement_buffer == nullptr) {
userdata->displacement_buffer = MEM_callocN(sizeof(float) * ibuf->x * ibuf->y, userdata->displacement_buffer = MEM_cnew_array<float>(ibuf->x * ibuf->y,
"MultiresBake heights"); "MultiresBake heights");
} }
height_data = MEM_callocN(sizeof(MHeightBakeData), "MultiresBake heightData"); height_data = MEM_cnew<MHeightBakeData>("MultiresBake heightData");
height_data->heights = userdata->displacement_buffer; height_data->heights = userdata->displacement_buffer;
if (!bkr->use_lores_mesh) { if (!bkr->use_lores_mesh) {
SubsurfModifierData smd = {{NULL}}; SubsurfModifierData smd = {{nullptr}};
int ss_lvl = bkr->tot_lvl - bkr->lvl; int ss_lvl = bkr->tot_lvl - bkr->lvl;
CLAMP(ss_lvl, 0, 6); CLAMP(ss_lvl, 0, 6);
@ -793,12 +795,13 @@ static void *init_heights_data(MultiresBakeRender *bkr, ImBuf *ibuf)
smd.quality = 3; smd.quality = 3;
height_data->ssdm = subsurf_make_derived_from_derived( height_data->ssdm = subsurf_make_derived_from_derived(
bkr->lores_dm, &smd, bkr->scene, NULL, 0); bkr->lores_dm, &smd, bkr->scene, nullptr, SubsurfFlags(0));
init_ccgdm_arrays(height_data->ssdm); init_ccgdm_arrays(height_data->ssdm);
} }
} }
height_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX); height_data->orig_index_mp_to_orig = static_cast<const int *>(
lodm->getPolyDataArray(lodm, CD_ORIGINDEX));
return (void *)height_data; return (void *)height_data;
} }
@ -835,7 +838,7 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index; const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MLoop *mloop = lores_dm->getLoopArray(lores_dm); MLoop *mloop = lores_dm->getLoopArray(lores_dm);
MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly; MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV); MLoopUV *mloopuv = static_cast<MLoopUV *>(lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV));
MHeightBakeData *height_data = (MHeightBakeData *)bake_data; MHeightBakeData *height_data = (MHeightBakeData *)bake_data;
MultiresBakeThread *thread_data = (MultiresBakeThread *)thread_data_v; MultiresBakeThread *thread_data = (MultiresBakeThread *)thread_data_v;
float uv[2], *st0, *st1, *st2, *st3; float uv[2], *st0, *st1, *st2, *st3;
@ -861,7 +864,7 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
clamp_v2(uv, 0.0f, 1.0f); clamp_v2(uv, 0.0f, 1.0f);
get_ccgdm_data( get_ccgdm_data(
lores_dm, hires_dm, height_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], p1, NULL); lores_dm, hires_dm, height_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], p1, nullptr);
if (height_data->ssdm) { if (height_data->ssdm) {
get_ccgdm_data(lores_dm, get_ccgdm_data(lores_dm,
@ -912,9 +915,10 @@ static void *init_normal_data(MultiresBakeRender *bkr, ImBuf *UNUSED(ibuf))
MNormalBakeData *normal_data; MNormalBakeData *normal_data;
DerivedMesh *lodm = bkr->lores_dm; DerivedMesh *lodm = bkr->lores_dm;
normal_data = MEM_callocN(sizeof(MNormalBakeData), "MultiresBake normalData"); normal_data = MEM_cnew<MNormalBakeData>("MultiresBake normalData");
normal_data->orig_index_mp_to_orig = lodm->getPolyDataArray(lodm, CD_ORIGINDEX); normal_data->orig_index_mp_to_orig = static_cast<const int *>(
lodm->getPolyDataArray(lodm, CD_ORIGINDEX));
return (void *)normal_data; return (void *)normal_data;
} }
@ -948,7 +952,7 @@ static void apply_tangmat_callback(DerivedMesh *lores_dm,
{ {
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index; const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly; MPoly *mpoly = lores_dm->getPolyArray(lores_dm) + lt->poly;
MLoopUV *mloopuv = lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV); MLoopUV *mloopuv = static_cast<MLoopUV *>(lores_dm->getLoopDataArray(lores_dm, CD_MLOOPUV));
MNormalBakeData *normal_data = (MNormalBakeData *)bake_data; MNormalBakeData *normal_data = (MNormalBakeData *)bake_data;
float uv[2], *st0, *st1, *st2, *st3; float uv[2], *st0, *st1, *st2, *st3;
int pixel = ibuf->x * y + x; int pixel = ibuf->x * y + x;
@ -973,7 +977,7 @@ static void apply_tangmat_callback(DerivedMesh *lores_dm,
clamp_v2(uv, 0.0f, 1.0f); clamp_v2(uv, 0.0f, 1.0f);
get_ccgdm_data( get_ccgdm_data(
lores_dm, hires_dm, normal_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], NULL, n); lores_dm, hires_dm, normal_data->orig_index_mp_to_orig, lvl, lt, uv[0], uv[1], nullptr, n);
mul_v3_m3v3(vec, tangmat, n); mul_v3_m3v3(vec, tangmat, n);
normalize_v3_length(vec, 0.5); normalize_v3_length(vec, 0.5);
@ -1433,7 +1437,7 @@ static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
{ {
LinkData *link; LinkData *link;
for (link = bkr->image.first; link; link = link->next) { for (link = static_cast<LinkData *>(bkr->image.first); link; link = link->next) {
Image *ima = (Image *)link->data; Image *ima = (Image *)link->data;
LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) { LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
@ -1441,12 +1445,11 @@ static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
BKE_imageuser_default(&iuser); BKE_imageuser_default(&iuser);
iuser.tile = tile->tile_number; iuser.tile = tile->tile_number;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, NULL); ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, nullptr);
if (ibuf->x > 0 && ibuf->y > 0) { if (ibuf->x > 0 && ibuf->y > 0) {
BakeImBufuserData *userdata = MEM_callocN(sizeof(BakeImBufuserData), BakeImBufuserData *userdata = MEM_cnew<BakeImBufuserData>("MultiresBake userdata");
"MultiresBake userdata"); userdata->mask_buffer = MEM_cnew_array<char>(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
userdata->mask_buffer = MEM_callocN(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
ibuf->userdata = userdata; ibuf->userdata = userdata;
switch (bkr->mode) { switch (bkr->mode) {
@ -1481,7 +1484,7 @@ static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
} }
} }
BKE_image_release_ibuf(ima, ibuf, NULL); BKE_image_release_ibuf(ima, ibuf, nullptr);
} }
ima->id.tag |= LIB_TAG_DOIT; ima->id.tag |= LIB_TAG_DOIT;
@ -1493,7 +1496,7 @@ static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
LinkData *link; LinkData *link;
bool use_displacement_buffer = bkr->mode == RE_BAKE_DISPLACEMENT; bool use_displacement_buffer = bkr->mode == RE_BAKE_DISPLACEMENT;
for (link = bkr->image.first; link; link = link->next) { for (link = static_cast<LinkData *>(bkr->image.first); link; link = link->next) {
Image *ima = (Image *)link->data; Image *ima = (Image *)link->data;
LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) { LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
@ -1501,7 +1504,7 @@ static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
BKE_imageuser_default(&iuser); BKE_imageuser_default(&iuser);
iuser.tile = tile->tile_number; iuser.tile = tile->tile_number;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, NULL); ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &iuser, nullptr);
BakeImBufuserData *userdata = (BakeImBufuserData *)ibuf->userdata; BakeImBufuserData *userdata = (BakeImBufuserData *)ibuf->userdata;
if (ibuf->x <= 0 || ibuf->y <= 0) { if (ibuf->x <= 0 || ibuf->y <= 0) {
@ -1545,10 +1548,10 @@ static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
MEM_freeN(userdata->mask_buffer); MEM_freeN(userdata->mask_buffer);
MEM_freeN(userdata); MEM_freeN(userdata);
ibuf->userdata = NULL; ibuf->userdata = nullptr;
} }
BKE_image_release_ibuf(ima, ibuf, NULL); BKE_image_release_ibuf(ima, ibuf, nullptr);
DEG_id_tag_update(&ima->id, 0); DEG_id_tag_update(&ima->id, 0);
} }
} }