blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 753 Projects 19 Wiki Activity

Cleanup: move some files that use normals to C++ 

Doing this to help with T102858.
This commit is contained in:
Jacques Lucke 2022-12-02 12:34:26 +01:00
parent 88c6d824e7
commit 3d5a4fbcc2
13 changed files with 629 additions and 579 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/blenkernel/CMakeLists.txt
View File

@ -118,7 +118,7 @@ set(SRC
intern/curves_utils.cc
intern/customdata.cc
intern/customdata_file.c
intern/data_transfer.c
intern/data_transfer.cc
intern/deform.c
intern/displist.cc
intern/dynamicpaint.c
@ -164,7 +164,7 @@ set(SRC
intern/instances.cc
intern/ipo.c
intern/kelvinlet.c
intern/key.c
intern/key.cc
intern/keyconfig.c
intern/lattice.c
intern/lattice_deform.c
@ -203,7 +203,7 @@ set(SRC
intern/mesh_mapping.cc
intern/mesh_merge.c
intern/mesh_merge_customdata.cc
intern/mesh_mirror.c
intern/mesh_mirror.cc
intern/mesh_normals.cc
intern/mesh_remap.cc
intern/mesh_remesh_voxel.cc

155
source/blender/blenkernel/intern/data_transfer.c → source/blender/blenkernel/intern/data_transfer.cc
View File

@ -271,18 +271,19 @@ static void data_transfer_dtdata_type_preprocess(Mesh *me_src,
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. */
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;
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. */
loop_nors_dst = CustomData_get_layer(ldata_dst, CD_NORMAL);
const bool do_loop_nors_dst = (loop_nors_dst == NULL);
loop_nors_dst = static_cast<float(*)[3]>(CustomData_get_layer(ldata_dst, CD_NORMAL));
const bool do_loop_nors_dst = (loop_nors_dst == nullptr);
if (do_loop_nors_dst) {
loop_nors_dst = CustomData_add_layer(
ldata_dst, CD_NORMAL, CD_SET_DEFAULT, NULL, num_loops_dst);
loop_nors_dst = static_cast<float(*)[3]>(
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);
}
if (dirty_nors_dst || do_loop_nors_dst) {
@ -299,8 +300,8 @@ static void data_transfer_dtdata_type_preprocess(Mesh *me_src,
num_polys_dst,
use_split_nors_dst,
split_angle_dst,
NULL,
NULL,
nullptr,
nullptr,
custom_nors_dst);
}
}
@ -330,12 +331,14 @@ static void data_transfer_dtdata_type_postprocess(Object *UNUSED(ob_src),
CustomData *ldata_dst = &me_dst->ldata;
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);
short(*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL);
float(*loop_nors_dst)[3] = static_cast<float(*)[3]>(
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) {
custom_nors_dst = CustomData_add_layer(
ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, NULL, num_loops_dst);
custom_nors_dst = static_cast<short(*)[2]>(CustomData_add_layer(
ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, nullptr, num_loops_dst));
}
/* Note loop_nors_dst contains our custom normals as transferred from source... */
@ -364,7 +367,7 @@ static MeshRemapIslandsCalc data_transfer_get_loop_islands_generator(const int c
default:
break;
}
return NULL;
return nullptr;
}
float data_transfer_interp_float_do(const int mix_mode,
@ -422,9 +425,9 @@ void data_transfer_layersmapping_add_item(ListBase *r_map,
cd_datatransfer_interp interp,
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->mix_mode = mix_mode;
@ -487,7 +490,7 @@ static void data_transfer_layersmapping_add_item_cd(ListBase *r_map,
* \note
* 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.
* 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.
*/
static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map,
@ -508,10 +511,10 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
void *interp_data)
{
const void *data_src;
void *data_dst = NULL;
void *data_dst = nullptr;
int idx_src = num_layers_src;
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) {
/* No source at all, we can only delete all dest if requested... */
@ -538,7 +541,7 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
if (use_create) {
/* Create as much data layers as necessary! */
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 {
@ -581,8 +584,8 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
case DT_LAYERS_NAME_DST:
if (use_delete) {
if (tot_dst) {
data_dst_to_delete = MEM_mallocN(sizeof(*data_dst_to_delete) * (size_t)tot_dst,
__func__);
data_dst_to_delete = static_cast<bool *>(
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);
}
}
@ -600,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 (use_create) {
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);
}
else {
@ -673,7 +676,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
{
int idx_src, idx_dst;
const void *data_src;
void *data_dst = NULL;
void *data_dst = nullptr;
if (CustomData_layertype_is_singleton(cddata_type)) {
if (!(data_src = CustomData_get_layer(cd_src, cddata_type))) {
@ -688,7 +691,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (!use_create) {
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) {
/* If dest is a evaluated mesh (from modifier),
@ -741,7 +744,8 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (!use_create) {
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 dest is a evaluated mesh (from modifier),
@ -764,7 +768,7 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
}
/* Create as much data layers as necessary! */
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),
@ -783,7 +787,8 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
if (!use_create) {
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);
}
/* If dest is a evaluated mesh (from modifier),
@ -818,9 +823,9 @@ static bool data_transfer_layersmapping_cdlayers(ListBase *r_map,
}
else if (fromlayers == DT_LAYERS_ALL_SRC) {
int num_src = CustomData_number_of_layers(cd_src, cddata_type);
bool *use_layers_src = num_src ?
MEM_mallocN(sizeof(*use_layers_src) * (size_t)num_src, __func__) :
NULL;
bool *use_layers_src = num_src ? static_cast<bool *>(MEM_mallocN(
sizeof(*use_layers_src) * (size_t)num_src, __func__)) :
nullptr;
bool ret;
if (use_layers_src) {
@ -875,8 +880,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
{
CustomData *cd_src, *cd_dst;
cd_datatransfer_interp interp = NULL;
void *interp_data = NULL;
cd_datatransfer_interp interp = nullptr;
void *interp_data = nullptr;
if (elem_type == ME_VERT) {
if (!(cddata_type & CD_FAKE)) {
@ -957,8 +962,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
return true;
}
if (r_map && ELEM(cddata_type, CD_FAKE_SHARP, CD_FAKE_SEAM)) {
const size_t elem_size = sizeof(*((MEdge *)NULL));
const size_t data_size = sizeof(((MEdge *)NULL)->flag);
const size_t elem_size = sizeof(*((MEdge *)nullptr));
const size_t data_size = sizeof(((MEdge *)nullptr)->flag);
const size_t data_offset = offsetof(MEdge, flag);
const uint64_t data_flag = (cddata_type == CD_FAKE_SHARP) ? ME_SHARP : ME_SEAM;
@ -975,7 +980,7 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
data_size,
data_offset,
data_flag,
NULL,
nullptr,
interp_data);
return true;
}
@ -1051,8 +1056,8 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
return true;
}
if (r_map && cddata_type == CD_FAKE_SHARP) {
const size_t elem_size = sizeof(*((MPoly *)NULL));
const size_t data_size = sizeof(((MPoly *)NULL)->flag);
const size_t elem_size = sizeof(*((MPoly *)nullptr));
const size_t data_size = sizeof(((MPoly *)nullptr)->flag);
const size_t data_offset = offsetof(MPoly, flag);
const uint64_t data_flag = ME_SMOOTH;
@ -1069,7 +1074,7 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
data_size,
data_offset,
data_flag,
NULL,
nullptr,
interp_data);
return true;
}
@ -1098,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));
me_dst = ob_dst->data;
me_dst = static_cast<Mesh *>(ob_dst->data);
/* Get source evaluated mesh. */
BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask);
@ -1132,7 +1137,7 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
if (DT_DATATYPE_IS_VERT(dtdata_type)) {
const int num_elem_dst = me_dst->totvert;
data_transfer_layersmapping_generate(NULL,
data_transfer_layersmapping_generate(nullptr,
ob_src,
ob_dst,
me_src,
@ -1141,18 +1146,18 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type,
0,
0.0f,
NULL,
nullptr,
num_elem_dst,
use_create,
use_delete,
fromlayers,
tolayers,
NULL);
nullptr);
}
if (DT_DATATYPE_IS_EDGE(dtdata_type)) {
const int num_elem_dst = me_dst->totedge;
data_transfer_layersmapping_generate(NULL,
data_transfer_layersmapping_generate(nullptr,
ob_src,
ob_dst,
me_src,
@ -1161,18 +1166,18 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type,
0,
0.0f,
NULL,
nullptr,
num_elem_dst,
use_create,
use_delete,
fromlayers,
tolayers,
NULL);
nullptr);
}
if (DT_DATATYPE_IS_LOOP(dtdata_type)) {
const int num_elem_dst = me_dst->totloop;
data_transfer_layersmapping_generate(NULL,
data_transfer_layersmapping_generate(nullptr,
ob_src,
ob_dst,
me_src,
@ -1181,18 +1186,18 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type,
0,
0.0f,
NULL,
nullptr,
num_elem_dst,
use_create,
use_delete,
fromlayers,
tolayers,
NULL);
nullptr);
}
if (DT_DATATYPE_IS_POLY(dtdata_type)) {
const int num_elem_dst = me_dst->totpoly;
data_transfer_layersmapping_generate(NULL,
data_transfer_layersmapping_generate(nullptr,
ob_src,
ob_dst,
me_src,
@ -1201,13 +1206,13 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
cddata_type,
0,
0.0f,
NULL,
nullptr,
num_elem_dst,
use_create,
use_delete,
fromlayers,
tolayers,
NULL);
nullptr);
}
}
}
@ -1248,13 +1253,13 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
/* Assumed always true if not using an evaluated mesh as destination. */
bool dirty_nors_dst = true;
const MDeformVert *mdef = NULL;
const MDeformVert *mdef = nullptr;
int vg_idx = -1;
float *weights[DATAMAX] = {NULL};
float *weights[DATAMAX] = {nullptr};
MeshPairRemap geom_map[DATAMAX] = {{0}};
bool geom_map_init[DATAMAX] = {0};
ListBase lay_map = {NULL};
ListBase lay_map = {nullptr};
bool changed = false;
bool is_modifier = false;
@ -1272,11 +1277,11 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
is_modifier = true;
}
else {
me_dst = ob_dst->data;
me_dst = static_cast<Mesh *>(ob_dst->data);
}
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) {
vg_idx = BKE_id_defgroup_name_index(&me_dst->id, vgroup_name);
}
@ -1289,7 +1294,7 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
if (is_modifier) {
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)) {
CLOG_WARN(&LOG, "Data Transfer: source mesh data is not ready - dependency cycle?");
return changed;
@ -1304,7 +1309,7 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
BKE_mesh_wrapper_ensure_mdata(me_src);
if (auto_transform) {
if (space_transform == NULL) {
if (space_transform == nullptr) {
space_transform = &auto_space_transform;
}
@ -1386,7 +1391,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
}
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(
mdef, vg_idx, num_verts_dst, invert_vgroup, weights[VDATA]);
}
@ -1409,9 +1415,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) {
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);
}
@ -1465,7 +1472,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
}
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(
mdef, vg_idx, num_verts_dst, edges_dst, num_edges_dst, invert_vgroup, weights[EDATA]);
}
@ -1488,9 +1496,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) {
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);
}
@ -1560,7 +1569,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
}
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(
mdef, vg_idx, num_verts_dst, loops_dst, num_loops_dst, invert_vgroup, weights[LDATA]);
}
@ -1583,9 +1593,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) {
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);
}
@ -1640,7 +1651,8 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
}
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,
vg_idx,
num_verts_dst,
@ -1670,9 +1682,10 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
space_transform)) {
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);
}
@ -1724,7 +1737,7 @@ bool BKE_object_data_transfer_mesh(struct Depsgraph *depsgraph,
scene,
ob_src,
ob_dst,
NULL,
nullptr,
data_types,
use_create,
map_vert_mode,

349
source/blender/blenkernel/intern/key.c → source/blender/blenkernel/intern/key.cc
View File

@ -61,7 +61,9 @@ static void shapekey_copy_data(Main *UNUSED(bmain),
BLI_duplicatelist(&key_dst->block, &key_src->block);
KeyBlock *kb_dst, *kb_src;
for (kb_src = key_src->block.first, kb_dst = key_dst->block.first; kb_dst;
for (kb_src = static_cast<KeyBlock *>(key_src->block.first),
kb_dst = static_cast<KeyBlock *>(key_dst->block.first);
kb_dst;
kb_src = kb_src->next, kb_dst = kb_dst->next) {
if (kb_dst->data) {
kb_dst->data = MEM_dupallocN(kb_dst->data);
@ -77,7 +79,7 @@ static void shapekey_free_data(ID *id)
Key *key = (Key *)id;
KeyBlock *kb;
while ((kb = BLI_pophead(&key->block))) {
while ((kb = static_cast<KeyBlock *>(BLI_pophead(&key->block)))) {
if (kb->data) {
MEM_freeN(kb->data);
}
@ -95,7 +97,7 @@ static ID **shapekey_owner_pointer_get(ID *id)
{
Key *key = (Key *)id;
BLI_assert(key->from != NULL);
BLI_assert(key->from != nullptr);
BLI_assert(BKE_key_from_id(key->from) == key);
return &key->from;
@ -120,10 +122,10 @@ static void shapekey_blend_write(BlendWriter *writer, ID *id, const void *id_add
/* Do not store actual geometry data in case this is a library override ID. */
if (ID_IS_OVERRIDE_LIBRARY(key) && !is_undo) {
tmp_kb.totelem = 0;
tmp_kb.data = NULL;
tmp_kb.data = nullptr;
}
BLO_write_struct_at_address(writer, KeyBlock, kb, &tmp_kb);
if (tmp_kb.data != NULL) {
if (tmp_kb.data != nullptr) {
BLO_write_raw(writer, tmp_kb.totelem * key->elemsize, tmp_kb.data);
}
}
@ -137,7 +139,7 @@ static void shapekey_blend_write(BlendWriter *writer, ID *id, const void *id_add
static void switch_endian_keyblock(Key *key, KeyBlock *kb)
{
int elemsize = key->elemsize;
char *data = kb->data;
char *data = static_cast<char *>(kb->data);
for (int a = 0; a < kb->totelem; a++) {
const char *cp = key->elemstr;
@ -196,35 +198,35 @@ static void shapekey_blend_read_expand(BlendExpander *expander, ID *id)
}
IDTypeInfo IDType_ID_KE = {
.id_code = ID_KE,
.id_filter = FILTER_ID_KE,
.main_listbase_index = INDEX_ID_KE,
.struct_size = sizeof(Key),
.name = "Key",
.name_plural = "shape_keys",
.translation_context = BLT_I18NCONTEXT_ID_SHAPEKEY,
.flags = IDTYPE_FLAGS_NO_LIBLINKING,
.asset_type_info = NULL,
/* id_code */ ID_KE,
/* id_filter */ FILTER_ID_KE,
/* main_listbase_index */ INDEX_ID_KE,
/* struct_size */ sizeof(Key),
/* name */ "Key",
/* name_plural */ "shape_keys",
/* translation_context */ BLT_I18NCONTEXT_ID_SHAPEKEY,
/* flags */ IDTYPE_FLAGS_NO_LIBLINKING,
/* asset_type_info */ nullptr,
.init_data = NULL,
.copy_data = shapekey_copy_data,
.free_data = shapekey_free_data,
.make_local = NULL,
.foreach_id = shapekey_foreach_id,
.foreach_cache = NULL,
.foreach_path = NULL,
/* init_data */ nullptr,
/* copy_data */ shapekey_copy_data,
/* free_data */ shapekey_free_data,
/* make_local */ nullptr,
/* foreach_id */ shapekey_foreach_id,
/* foreach_cache */ nullptr,
/* foreach_path */ nullptr,
/* A bit weird, due to shape-keys not being strictly speaking embedded data... But they also
* share a lot with those (non linkable, only ever used by one owner ID, etc.). */
.owner_pointer_get = shapekey_owner_pointer_get,
/* owner_pointer_get */ shapekey_owner_pointer_get,
.blend_write = shapekey_blend_write,
.blend_read_data = shapekey_blend_read_data,
.blend_read_lib = shapekey_blend_read_lib,
.blend_read_expand = shapekey_blend_read_expand,
/* blend_write */ shapekey_blend_write,
/* blend_read_data */ shapekey_blend_read_data,
/* blend_read_lib */ shapekey_blend_read_lib,
/* blend_read_expand */ shapekey_blend_read_expand,
.blend_read_undo_preserve = NULL,
/* blend_read_undo_preserve */ nullptr,
.lib_override_apply_post = NULL,
/* lib_override_apply_post */ nullptr,
};
#define KEY_MODE_DUMMY 0 /* use where mode isn't checked for */
@ -246,7 +248,7 @@ void BKE_key_free_nolib(Key *key)
{
KeyBlock *kb;
while ((kb = BLI_pophead(&key->block))) {
while ((kb = static_cast<KeyBlock *>(BLI_pophead(&key->block)))) {
if (kb->data) {
MEM_freeN(kb->data);
}
@ -259,7 +261,7 @@ Key *BKE_key_add(Main *bmain, ID *id) /* common function */
Key *key;
char *el;
key = BKE_id_new(bmain, ID_KE, "Key");
key = static_cast<Key *>(BKE_id_new(bmain, ID_KE, "Key"));
key->type = KEY_NORMAL;
key->from = id;
@ -312,7 +314,7 @@ void BKE_key_sort(Key *key)
KeyBlock *kb2;
/* locate the key which is out of position */
for (kb = key->block.first; kb; kb = kb->next) {
for (kb = static_cast<KeyBlock *>(key->block.first); kb; kb = kb->next) {
if ((kb->next) && (kb->pos > kb->next->pos)) {
break;
}
@ -324,7 +326,7 @@ void BKE_key_sort(Key *key)
BLI_remlink(&key->block, kb);
/* find the right location and insert before */
for (kb2 = key->block.first; kb2; kb2 = kb2->next) {
for (kb2 = static_cast<KeyBlock *>(key->block.first); kb2; kb2 = kb2->next) {
if (kb2->pos > kb->pos) {
BLI_insertlinkafter(&key->block, kb2->prev, kb);
break;
@ -333,7 +335,7 @@ void BKE_key_sort(Key *key)
}
/* new rule; first key is refkey, this to match drawing channels... */
key->refkey = key->block.first;
key->refkey = static_cast<KeyBlock *>(key->block.first);
}
/**************** do the key ****************/
@ -458,8 +460,8 @@ static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float t[4], int cycl)
float d, dpos, ofs = 0, lastpos;
short bsplinetype;
firstkey = lb->first;
k1 = lb->last;
firstkey = static_cast<KeyBlock *>(lb->first);
k1 = static_cast<KeyBlock *>(lb->last);
lastpos = k1->pos;
dpos = lastpos - firstkey->pos;
@ -475,18 +477,18 @@ static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float t[4], int cycl)
/* if (fac < 0.0 || fac > 1.0) return 1; */
if (k1->next == NULL) {
if (k1->next == nullptr) {
return 1;
}
if (cycl) { /* pre-sort */
k[2] = k1->next;
k[3] = k[2]->next;
if (k[3] == NULL) {
if (k[3] == nullptr) {
k[3] = k1;
}
while (k1) {
if (k1->next == NULL) {
if (k1->next == nullptr) {
k[0] = k1;
}
k1 = k1->next;
@ -511,7 +513,7 @@ static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float t[4], int cycl)
k[2] = k1->next;
t[2] = k[2]->pos;
k[3] = k[2]->next;
if (k[3] == NULL) {
if (k[3] == nullptr) {
k[3] = k[2];
}
t[3] = k[3]->pos;
@ -519,7 +521,7 @@ static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float t[4], int cycl)
}
while (t[2] < fac) { /* find correct location */
if (k1->next == NULL) {
if (k1->next == nullptr) {
if (cycl) {
k1 = firstkey;
ofs += dpos;
@ -631,7 +633,8 @@ static char *key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **
if (me->edit_mesh && me->edit_mesh->bm->totvert == kb->totelem) {
a = 0;
co = MEM_mallocN(sizeof(float[3]) * me->edit_mesh->bm->totvert, "key_block_get_data");
co = static_cast<float(*)[3]>(
MEM_mallocN(sizeof(float[3]) * me->edit_mesh->bm->totvert, "key_block_get_data"));
BM_ITER_MESH (eve, &iter, me->edit_mesh->bm, BM_VERTS_OF_MESH) {
copy_v3_v3(co[a], eve->co);
@ -644,14 +647,14 @@ static char *key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **
}
}
*freedata = NULL;
return kb->data;
*freedata = nullptr;
return static_cast<char *>(kb->data);
}
/* currently only the first value of 'ofs' may be set. */
static bool key_pointer_size(const Key *key, const int mode, int *poinsize, int *ofs, int *step)
{
if (key->from == NULL) {
if (key->from == nullptr) {
return false;
}
@ -834,7 +837,7 @@ static void cp_cu_key(Curve *cu,
Nurb *nu;
int a, step, a1, a2;
for (a = 0, nu = cu->nurb.first; nu; nu = nu->next, a += step) {
for (a = 0, nu = static_cast<Nurb *>(cu->nurb.first); nu; nu = nu->next, a += step) {
if (nu->bp) {
step = KEYELEM_ELEM_LEN_BPOINT * nu->pntsu * nu->pntsv;
@ -842,7 +845,7 @@ static void cp_cu_key(Curve *cu,
a2 = min_ii(a + step, end);
if (a1 < a2) {
cp_key(a1, a2, tot, out, key, actkb, kb, NULL, KEY_MODE_BPOINT);
cp_key(a1, a2, tot, out, key, actkb, kb, nullptr, KEY_MODE_BPOINT);
}
}
else if (nu->bezt) {
@ -853,7 +856,7 @@ static void cp_cu_key(Curve *cu,
a2 = min_ii(a + step, end);
if (a1 < a2) {
cp_key(a1, a2, tot, out, key, actkb, kb, NULL, KEY_MODE_BEZTRIPLE);
cp_key(a1, a2, tot, out, key, actkb, kb, nullptr, KEY_MODE_BEZTRIPLE);
}
}
else {
@ -896,11 +899,12 @@ static void key_evaluate_relative(const int start,
elemsize = key->elemsize * step;
/* step 1 init */
cp_key(start, end, tot, basispoin, key, actkb, key->refkey, NULL, mode);
cp_key(start, end, tot, basispoin, key, actkb, key->refkey, nullptr, mode);
/* step 2: do it */
for (kb = key->block.first, keyblock_index = 0; kb; kb = kb->next, keyblock_index++) {
for (kb = static_cast<KeyBlock *>(key->block.first), keyblock_index = 0; kb;
kb = kb->next, keyblock_index++) {
if (kb != key->refkey) {
float icuval = kb->curval;
@ -908,12 +912,12 @@ static void key_evaluate_relative(const int start,
if (!(kb->flag & KEYBLOCK_MUTE) && icuval != 0.0f && kb->totelem == tot) {
KeyBlock *refb;
float weight,
*weights = per_keyblock_weights ? per_keyblock_weights[keyblock_index] : NULL;
char *freefrom = NULL;
*weights = per_keyblock_weights ? per_keyblock_weights[keyblock_index] : nullptr;
char *freefrom = nullptr;
/* reference now can be any block */
refb = BLI_findlink(&key->block, kb->relative);
if (refb == NULL) {
refb = static_cast<KeyBlock *>(BLI_findlink(&key->block, kb->relative));
if (refb == nullptr) {
continue;
}
@ -922,7 +926,7 @@ static void key_evaluate_relative(const int start,
/* For meshes, use the original values instead of the bmesh values to
* maintain a constant offset. */
reffrom = refb->data;
reffrom = static_cast<char *>(refb->data);
poin += start * poinsize;
reffrom += key->elemsize * start; /* key elemsize yes! */
@ -1167,11 +1171,11 @@ static void do_key(const int start,
break;
case IPO_BEZTRIPLE:
flerp(KEYELEM_FLOAT_LEN_BEZTRIPLE,
(void *)poin,
(void *)k1,
(void *)k2,
(void *)k3,
(void *)k4,
(float *)poin,
(float *)k1,
(float *)k2,
(float *)k3,
(float *)k4,
t);
break;
default:
@ -1263,20 +1267,20 @@ static void do_key(const int start,
static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cache)
{
const MDeformVert *dvert = NULL;
BMEditMesh *em = NULL;
const MDeformVert *dvert = nullptr;
BMEditMesh *em = nullptr;
BMIter iter;
BMVert *eve;
int totvert = 0, defgrp_index = 0;
/* no vgroup string set? */
if (vgroup[0] == 0) {
return NULL;
return nullptr;
}
/* gather dvert and totvert */
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
Mesh *me = static_cast<Mesh *>(ob->data);
dvert = BKE_mesh_deform_verts(me);
totvert = me->totvert;
@ -1285,13 +1289,13 @@ static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cac
}
}
else if (ob->type == OB_LATTICE) {
Lattice *lt = ob->data;
Lattice *lt = static_cast<Lattice *>(ob->data);
dvert = lt->dvert;
totvert = lt->pntsu * lt->pntsv * lt->pntsw;
}
if (dvert == NULL) {
return NULL;
if (dvert == nullptr) {
return nullptr;
}
/* find the group (weak loop-in-loop) */
@ -1300,10 +1304,10 @@ static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cac
float *weights;
if (cache) {
if (cache->defgroup_weights == NULL) {
if (cache->defgroup_weights == nullptr) {
int num_defgroup = BKE_object_defgroup_count(ob);
cache->defgroup_weights = MEM_callocN(sizeof(*cache->defgroup_weights) * num_defgroup,
"cached defgroup weights");
cache->defgroup_weights = static_cast<float **>(MEM_callocN(
sizeof(*cache->defgroup_weights) * num_defgroup, "cached defgroup weights"));
cache->num_defgroup_weights = num_defgroup;
}
@ -1312,13 +1316,13 @@ static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cac
}
}
weights = MEM_mallocN(totvert * sizeof(float), "weights");
weights = static_cast<float *>(MEM_mallocN(totvert * sizeof(float), "weights"));
if (em) {
int i;
const int cd_dvert_offset = CustomData_get_offset(&em->bm->vdata, CD_MDEFORMVERT);
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
dvert = static_cast<const MDeformVert *>(BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset));
weights[i] = BKE_defvert_find_weight(dvert, defgrp_index);
}
}
@ -1334,7 +1338,7 @@ static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cac
return weights;
}
return NULL;
return nullptr;
}
static float **keyblock_get_per_block_weights(Object *ob, Key *key, WeightsArrayCache *cache)
@ -1343,10 +1347,10 @@ static float **keyblock_get_per_block_weights(Object *ob, Key *key, WeightsArray
float **per_keyblock_weights;
int keyblock_index;
per_keyblock_weights = MEM_mallocN(sizeof(*per_keyblock_weights) * key->totkey,
"per keyblock weights");
per_keyblock_weights = static_cast<float **>(
MEM_mallocN(sizeof(*per_keyblock_weights) * key->totkey, "per keyblock weights"));
for (keyblock = key->block.first, keyblock_index = 0; keyblock;
for (keyblock = static_cast<KeyBlock *>(key->block.first), keyblock_index = 0; keyblock;
keyblock = keyblock->next, keyblock_index++) {
per_keyblock_weights[keyblock_index] = get_weights_array(ob, keyblock->vgroup, cache);
}
@ -1369,7 +1373,7 @@ static void keyblock_free_per_block_weights(Key *key,
}
MEM_freeN(cache->defgroup_weights);
}
cache->defgroup_weights = NULL;
cache->defgroup_weights = nullptr;
}
else {
for (a = 0; a < key->totkey; a++) {
@ -1389,7 +1393,7 @@ static void do_mesh_key(Object *ob, Key *key, char *out, const int tot)
int flag = 0;
if (key->type == KEY_RELATIVE) {
WeightsArrayCache cache = {0, NULL};
WeightsArrayCache cache = {0, nullptr};
float **per_keyblock_weights;
per_keyblock_weights = keyblock_get_per_block_weights(ob, key, &cache);
key_evaluate_relative(
@ -1405,7 +1409,7 @@ static void do_mesh_key(Object *ob, Key *key, char *out, const int tot)
do_key(0, tot, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
}
else {
cp_key(0, tot, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
cp_key(0, tot, tot, (char *)out, key, actkb, k[2], nullptr, KEY_MODE_DUMMY);
}
}
}
@ -1416,7 +1420,7 @@ static void do_cu_key(
Nurb *nu;
int a, step;
for (a = 0, nu = cu->nurb.first; nu; nu = nu->next, a += step) {
for (a = 0, nu = static_cast<Nurb *>(cu->nurb.first); nu; nu = nu->next, a += step) {
if (nu->bp) {
step = KEYELEM_ELEM_LEN_BPOINT * nu->pntsu * nu->pntsv;
do_key(a, a + step, tot, out, key, actkb, k, t, KEY_MODE_BPOINT);
@ -1436,14 +1440,14 @@ static void do_rel_cu_key(Curve *cu, Key *key, KeyBlock *actkb, char *out, const
Nurb *nu;
int a, step;
for (a = 0, nu = cu->nurb.first; nu; nu = nu->next, a += step) {
for (a = 0, nu = static_cast<Nurb *>(cu->nurb.first); nu; nu = nu->next, a += step) {
if (nu->bp) {
step = KEYELEM_ELEM_LEN_BPOINT * nu->pntsu * nu->pntsv;
key_evaluate_relative(a, a + step, tot, out, key, actkb, NULL, KEY_MODE_BPOINT);
key_evaluate_relative(a, a + step, tot, out, key, actkb, nullptr, KEY_MODE_BPOINT);
}
else if (nu->bezt) {
step = KEYELEM_ELEM_LEN_BEZTRIPLE * nu->pntsu;
key_evaluate_relative(a, a + step, tot, out, key, actkb, NULL, KEY_MODE_BEZTRIPLE);
key_evaluate_relative(a, a + step, tot, out, key, actkb, nullptr, KEY_MODE_BEZTRIPLE);
}
else {
step = 0;
@ -1453,7 +1457,7 @@ static void do_rel_cu_key(Curve *cu, Key *key, KeyBlock *actkb, char *out, const
static void do_curve_key(Object *ob, Key *key, char *out, const int tot)
{
Curve *cu = ob->data;
Curve *cu = static_cast<Curve *>(ob->data);
KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
float t[4];
int flag = 0;
@ -1477,17 +1481,17 @@ static void do_curve_key(Object *ob, Key *key, char *out, const int tot)
static void do_latt_key(Object *ob, Key *key, char *out, const int tot)
{
Lattice *lt = ob->data;
Lattice *lt = static_cast<Lattice *>(ob->data);
KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
float t[4];
int flag;
if (key->type == KEY_RELATIVE) {
float **per_keyblock_weights;
per_keyblock_weights = keyblock_get_per_block_weights(ob, key, NULL);
per_keyblock_weights = keyblock_get_per_block_weights(ob, key, nullptr);
key_evaluate_relative(
0, tot, tot, (char *)out, key, actkb, per_keyblock_weights, KEY_MODE_DUMMY);
keyblock_free_per_block_weights(key, per_keyblock_weights, NULL);
keyblock_free_per_block_weights(key, per_keyblock_weights, nullptr);
}
else {
const float ctime_scaled = key->ctime / 100.0f;
@ -1498,7 +1502,7 @@ static void do_latt_key(Object *ob, Key *key, char *out, const int tot)
do_key(0, tot, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
}
else {
cp_key(0, tot, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
cp_key(0, tot, tot, (char *)out, key, actkb, k[2], nullptr, KEY_MODE_DUMMY);
}
}
@ -1521,25 +1525,25 @@ float *BKE_key_evaluate_object_ex(
char *out;
int tot = 0, size = 0;
if (key == NULL || BLI_listbase_is_empty(&key->block)) {
return NULL;
if (key == nullptr || BLI_listbase_is_empty(&key->block)) {
return nullptr;
}
/* compute size of output array */
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
Mesh *me = static_cast<Mesh *>(ob->data);
tot = me->totvert;
size = tot * sizeof(float[KEYELEM_FLOAT_LEN_COORD]);
}
else if (ob->type == OB_LATTICE) {
Lattice *lt = ob->data;
Lattice *lt = static_cast<Lattice *>(ob->data);
tot = lt->pntsu * lt->pntsv * lt->pntsw;
size = tot * sizeof(float[KEYELEM_FLOAT_LEN_COORD]);
}
else if (ELEM(ob->type, OB_CURVES_LEGACY, OB_SURF)) {
Curve *cu = ob->data;
Curve *cu = static_cast<Curve *>(ob->data);
tot = BKE_keyblock_curve_element_count(&cu->nurb);
size = tot * sizeof(float[KEYELEM_ELEM_SIZE_CURVE]);
@ -1547,16 +1551,16 @@ float *BKE_key_evaluate_object_ex(
/* if nothing to interpolate, cancel */
if (tot == 0 || size == 0) {
return NULL;
return nullptr;
}
/* allocate array */
if (arr == NULL) {
out = MEM_callocN(size, "BKE_key_evaluate_object out");
if (arr == nullptr) {
out = static_cast<char *>(MEM_callocN(size, "BKE_key_evaluate_object out"));
}
else {
if (arr_size != size) {
return NULL;
return nullptr;
}
out = (char *)arr;
@ -1564,19 +1568,19 @@ float *BKE_key_evaluate_object_ex(
if (ob->shapeflag & OB_SHAPE_LOCK) {
/* shape locked, copy the locked shape instead of blending */
KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
KeyBlock *kb = static_cast<KeyBlock *>(BLI_findlink(&key->block, ob->shapenr - 1));
if (kb && (kb->flag & KEYBLOCK_MUTE)) {
kb = key->refkey;
}
if (kb == NULL) {
kb = key->block.first;
if (kb == nullptr) {
kb = static_cast<KeyBlock *>(key->block.first);
ob->shapenr = 1;
}
if (OB_TYPE_SUPPORT_VGROUP(ob->type)) {
float *weights = get_weights_array(ob, kb->vgroup, NULL);
float *weights = get_weights_array(ob, kb->vgroup, nullptr);
cp_key(0, tot, tot, out, key, actkb, kb, weights, 0);
@ -1585,7 +1589,7 @@ float *BKE_key_evaluate_object_ex(
}
}
else if (ELEM(ob->type, OB_CURVES_LEGACY, OB_SURF)) {
cp_cu_key(ob->data, key, actkb, kb, 0, tot, out, tot);
cp_cu_key(static_cast<Curve *>(ob->data), key, actkb, kb, 0, tot, out, tot);
}
}
else {
@ -1603,7 +1607,7 @@ float *BKE_key_evaluate_object_ex(
}
}
if (obdata != NULL) {
if (obdata != nullptr) {
switch (GS(obdata->name)) {
case ID_ME: {
Mesh *mesh = (Mesh *)obdata;
@ -1637,14 +1641,15 @@ float *BKE_key_evaluate_object_ex(
float *BKE_key_evaluate_object(Object *ob, int *r_totelem)
{
return BKE_key_evaluate_object_ex(ob, r_totelem, NULL, 0, NULL);
return BKE_key_evaluate_object_ex(ob, r_totelem, nullptr, 0, nullptr);
}
int BKE_keyblock_element_count_from_shape(const Key *key, const int shape_index)
{
int result = 0;
int index = 0;
for (const KeyBlock *kb = key->block.first; kb; kb = kb->next, index++) {
for (const KeyBlock *kb = static_cast<const KeyBlock *>(key->block.first); kb;
kb = kb->next, index++) {
if (ELEM(shape_index, -1, index)) {
result += kb->totelem;
}
@ -1678,7 +1683,8 @@ void BKE_keyblock_data_get_from_shape(const Key *key, float (*arr)[3], const int
{
uint8_t *elements = (uint8_t *)arr;
int index = 0;
for (const KeyBlock *kb = key->block.first; kb; kb = kb->next, index++) {
for (const KeyBlock *kb = static_cast<const KeyBlock *>(key->block.first); kb;
kb = kb->next, index++) {
if (ELEM(shape_index, -1, index)) {
const int block_elem_len = kb->totelem * key->elemsize;
memcpy(elements, kb->data, block_elem_len);
@ -1705,7 +1711,7 @@ void BKE_keyblock_data_set_with_mat4(Key *key,
const float(*elements)[3] = coords;
int index = 0;
for (KeyBlock *kb = key->block.first; kb; kb = kb->next, index++) {
for (KeyBlock *kb = static_cast<KeyBlock *>(key->block.first); kb; kb = kb->next, index++) {
if (ELEM(shape_index, -1, index)) {
const int block_elem_len = kb->totelem;
float(*block_data)[3] = (float(*)[3])kb->data;
@ -1722,10 +1728,10 @@ void BKE_keyblock_data_set_with_mat4(Key *key,
void BKE_keyblock_curve_data_set_with_mat4(
Key *key, const ListBase *nurb, const int shape_index, const void *data, const float mat[4][4])
{
const uint8_t *elements = data;
const uint8_t *elements = static_cast<const uint8_t *>(data);
int index = 0;
for (KeyBlock *kb = key->block.first; kb; kb = kb->next, index++) {
for (KeyBlock *kb = static_cast<KeyBlock *>(key->block.first); kb; kb = kb->next, index++) {
if (ELEM(shape_index, -1, index)) {
const int block_elem_size = kb->totelem * key->elemsize;
BKE_keyblock_curve_data_transform(nurb, mat, elements, kb->data);
@ -1736,9 +1742,9 @@ void BKE_keyblock_curve_data_set_with_mat4(
void BKE_keyblock_data_set(Key *key, const int shape_index, const void *data)
{
const uint8_t *elements = data;
const uint8_t *elements = static_cast<const uint8_t *>(data);
int index = 0;
for (KeyBlock *kb = key->block.first; kb; kb = kb->next, index++) {
for (KeyBlock *kb = static_cast<KeyBlock *>(key->block.first); kb; kb = kb->next, index++) {
if (ELEM(shape_index, -1, index)) {
const int block_elem_size = kb->totelem * key->elemsize;
memcpy(kb->data, elements, block_elem_size);
@ -1770,7 +1776,7 @@ Key **BKE_key_from_id_p(ID *id)
}
case ID_CU_LEGACY: {
Curve *cu = (Curve *)id;
if (cu->vfont == NULL) {
if (cu->vfont == nullptr) {
return &cu->key;
}
break;
@ -1783,7 +1789,7 @@ Key **BKE_key_from_id_p(ID *id)
break;
}
return NULL;
return nullptr;
}
Key *BKE_key_from_id(ID *id)
@ -1794,16 +1800,16 @@ Key *BKE_key_from_id(ID *id)
return *key_p;
}
return NULL;
return nullptr;
}
Key **BKE_key_from_object_p(Object *ob)
{
if (ob == NULL || ob->data == NULL) {
return NULL;
if (ob == nullptr || ob->data == nullptr) {
return nullptr;
}
return BKE_key_from_id_p(ob->data);
return BKE_key_from_id_p(static_cast<ID *>(ob->data));
}
Key *BKE_key_from_object(Object *ob)
@ -1814,7 +1820,7 @@ Key *BKE_key_from_object(Object *ob)
return *key_p;
}
return NULL;
return nullptr;
}
KeyBlock *BKE_keyblock_add(Key *key, const char *name)
@ -1823,12 +1829,12 @@ KeyBlock *BKE_keyblock_add(Key *key, const char *name)
float curpos = -0.1;
int tot;
kb = key->block.last;
kb = static_cast<KeyBlock *>(key->block.last);
if (kb) {
curpos = kb->pos;
}
kb = MEM_callocN(sizeof(KeyBlock), "Keyblock");
kb = MEM_cnew<KeyBlock>("Keyblock");
BLI_addtail(&key->block, kb);
kb->type = KEY_LINEAR;
@ -1877,7 +1883,7 @@ KeyBlock *BKE_keyblock_add_ctime(Key *key, const char *name, const bool do_force
*/
if (!do_force && (key->type != KEY_RELATIVE)) {
KeyBlock *it_kb;
for (it_kb = key->block.first; it_kb; it_kb = it_kb->next) {
for (it_kb = static_cast<KeyBlock *>(key->block.first); it_kb; it_kb = it_kb->next) {
/* Use epsilon to avoid floating point precision issues.
* 1e-3 because the position is stored as frame * 1e-2. */
if (compare_ff(it_kb->pos, cpos, 1e-3f)) {
@ -1898,11 +1904,11 @@ KeyBlock *BKE_keyblock_from_object(Object *ob)
Key *key = BKE_key_from_object(ob);
if (key) {
KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
KeyBlock *kb = static_cast<KeyBlock *>(BLI_findlink(&key->block, ob->shapenr - 1));
return kb;
}
return NULL;
return nullptr;
}
KeyBlock *BKE_keyblock_from_object_reference(Object *ob)
@ -1913,13 +1919,13 @@ KeyBlock *BKE_keyblock_from_object_reference(Object *ob)
return key->refkey;
}
return NULL;
return nullptr;
}
KeyBlock *BKE_keyblock_from_key(Key *key, int index)
{
if (key) {
KeyBlock *kb = key->block.first;
KeyBlock *kb = static_cast<KeyBlock *>(key->block.first);
for (int i = 1; i < key->totkey; i++) {
kb = kb->next;
@ -1930,12 +1936,12 @@ KeyBlock *BKE_keyblock_from_key(Key *key, int index)
}
}
return NULL;
return nullptr;
}
KeyBlock *BKE_keyblock_find_name(Key *key, const char name[])
{
return BLI_findstring(&key->block, name, offsetof(KeyBlock, name));
return static_cast<KeyBlock *>(BLI_findstring(&key->block, name, offsetof(KeyBlock, name)));
}
KeyBlock *BKE_keyblock_find_uid(Key *key, const int uid)
@ -1945,7 +1951,7 @@ KeyBlock *BKE_keyblock_find_uid(Key *key, const int uid)
return kb;
}
}
return NULL;
return nullptr;
}
void BKE_keyblock_copy_settings(KeyBlock *kb_dst, const KeyBlock *kb_src)
@ -1965,8 +1971,8 @@ char *BKE_keyblock_curval_rnapath_get(const Key *key, const KeyBlock *kb)
PropertyRNA *prop;
/* sanity checks */
if (ELEM(NULL, key, kb)) {
return NULL;
if (ELEM(nullptr, key, kb)) {
return nullptr;
}
/* create the RNA pointer */
@ -1996,7 +2002,7 @@ void BKE_keyblock_update_from_lattice(const Lattice *lt, KeyBlock *kb)
}
bp = lt->def;
fp = kb->data;
fp = static_cast<float(*)[3]>(kb->data);
for (a = 0; a < kb->totelem; a++, fp++, bp++) {
copy_v3_v3(*fp, bp->vec);
}
@ -2031,7 +2037,7 @@ static void keyblock_data_convert_to_lattice(const float (*fp)[3],
void BKE_keyblock_convert_to_lattice(const KeyBlock *kb, Lattice *lt)
{
BPoint *bp = lt->def;
const float(*fp)[3] = kb->data;
const float(*fp)[3] = static_cast<const float(*)[3]>(kb->data);
const int tot = min_ii(kb->totelem, lt->pntsu * lt->pntsv * lt->pntsw);
keyblock_data_convert_to_lattice(fp, bp, tot);
@ -2044,7 +2050,7 @@ int BKE_keyblock_curve_element_count(const ListBase *nurb)
const Nurb *nu;
int tot = 0;
nu = nurb->first;
nu = static_cast<const Nurb *>(nurb->first);
while (nu) {
if (nu->bezt) {
tot += KEYELEM_ELEM_LEN_BEZTRIPLE * nu->pntsu;
@ -2074,8 +2080,8 @@ void BKE_keyblock_update_from_curve(const Curve *UNUSED(cu), KeyBlock *kb, const
return;
}
fp = kb->data;
for (nu = nurb->first; nu; nu = nu->next) {
fp = static_cast<float *>(kb->data);
for (nu = static_cast<Nurb *>(nurb->first); nu; nu = nu->next) {
if (nu->bezt) {
for (a = nu->pntsu, bezt = nu->bezt; a; a--, bezt++) {
for (int i = 0; i < 3; i++) {
@ -2102,9 +2108,9 @@ void BKE_keyblock_curve_data_transform(const ListBase *nurb,
const void *src_data,
void *dst_data)
{
const float *src = src_data;
float *dst = dst_data;
for (Nurb *nu = nurb->first; nu; nu = nu->next) {
const float *src = static_cast<const float *>(src_data);
float *dst = static_cast<float *>(dst_data);
for (Nurb *nu = static_cast<Nurb *>(nurb->first); nu; nu = nu->next) {
if (nu->bezt) {
for (int a = nu->pntsu; a; a--) {
for (int i = 0; i < 3; i++) {
@ -2148,8 +2154,8 @@ void BKE_keyblock_convert_from_curve(const Curve *cu, KeyBlock *kb, const ListBa
static void keyblock_data_convert_to_curve(const float *fp, ListBase *nurb, int totpoint)
{
for (Nurb *nu = nurb->first; nu && totpoint > 0; nu = nu->next) {
if (nu->bezt != NULL) {
for (Nurb *nu = static_cast<Nurb *>(nurb->first); nu && totpoint > 0; nu = nu->next) {
if (nu->bezt != nullptr) {
BezTriple *bezt = nu->bezt;
for (int i = nu->pntsu; i && (totpoint -= KEYELEM_ELEM_LEN_BEZTRIPLE) >= 0;
i--, bezt++, fp += KEYELEM_FLOAT_LEN_BEZTRIPLE) {
@ -2174,7 +2180,7 @@ static void keyblock_data_convert_to_curve(const float *fp, ListBase *nurb, int
void BKE_keyblock_convert_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
{
const float *fp = kb->data;
const float *fp = static_cast<const float *>(kb->data);
const int tot = min_ii(kb->totelem, BKE_keyblock_curve_element_count(nurb));
keyblock_data_convert_to_curve(fp, nurb, tot);
@ -2195,7 +2201,7 @@ void BKE_keyblock_update_from_mesh(const Mesh *me, KeyBlock *kb)
}
const MVert *mvert = BKE_mesh_verts(me);
fp = kb->data;
fp = static_cast<float(*)[3]>(kb->data);
for (a = 0; a < tot; a++, fp++, mvert++) {
copy_v3_v3(*fp, mvert->co);
}
@ -2226,7 +2232,7 @@ static void keyblock_data_convert_to_mesh(const float (*fp)[3], MVert *mvert, co
void BKE_keyblock_convert_to_mesh(const KeyBlock *kb, MVert *mvert, const int totvert)
{
const float(*fp)[3] = kb->data;
const float(*fp)[3] = static_cast<const float(*)[3]>(kb->data);
const int tot = min_ii(kb->totelem, totvert);
keyblock_data_convert_to_mesh(fp, mvert, tot);
@ -2238,31 +2244,33 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
float (*r_polynors)[3],
float (*r_loopnors)[3])
{
if (r_vertnors == NULL && r_polynors == NULL && r_loopnors == NULL) {
if (r_vertnors == nullptr && r_polynors == nullptr && r_loopnors == nullptr) {
return;
}
MVert *verts = MEM_dupallocN(BKE_mesh_verts(mesh));
MVert *verts = static_cast<MVert *>(MEM_dupallocN(BKE_mesh_verts(mesh)));
BKE_keyblock_convert_to_mesh(kb, verts, mesh->totvert);
const MEdge *edges = BKE_mesh_edges(mesh);
const MPoly *polys = BKE_mesh_polys(mesh);
const MLoop *loops = BKE_mesh_loops(mesh);
const bool loop_normals_needed = r_loopnors != NULL;
const bool vert_normals_needed = r_vertnors != NULL || loop_normals_needed;
const bool poly_normals_needed = r_polynors != NULL || vert_normals_needed ||
const bool loop_normals_needed = r_loopnors != nullptr;
const bool vert_normals_needed = r_vertnors != nullptr || loop_normals_needed;
const bool poly_normals_needed = r_polynors != nullptr || vert_normals_needed ||
loop_normals_needed;
float(*vert_normals)[3] = r_vertnors;
float(*poly_normals)[3] = r_polynors;
bool free_vert_normals = false;
bool free_poly_normals = false;
if (vert_normals_needed && r_vertnors == NULL) {
vert_normals = MEM_malloc_arrayN(mesh->totvert, sizeof(float[3]), __func__);
if (vert_normals_needed && r_vertnors == nullptr) {
vert_normals = static_cast<float(*)[3]>(
MEM_malloc_arrayN(mesh->totvert, sizeof(float[3]), __func__));
free_vert_normals = true;
}
if (poly_normals_needed && r_polynors == NULL) {
poly_normals = MEM_malloc_arrayN(mesh->totpoly, sizeof(float[3]), __func__);
if (poly_normals_needed && r_polynors == nullptr) {
poly_normals = static_cast<float(*)[3]>(
MEM_malloc_arrayN(mesh->totpoly, sizeof(float[3]), __func__));
free_poly_normals = true;
}
@ -2281,7 +2289,8 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
vert_normals);
}
if (loop_normals_needed) {
short(*clnors)[2] = CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL); /* May be NULL. */
short(*clnors)[2] = static_cast<short(*)[2]>(
CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL)); /* May be nullptr. */
BKE_mesh_normals_loop_split(verts,
vert_normals,
mesh->totvert,
@ -2295,8 +2304,8 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
mesh->totpoly,
(mesh->flag & ME_AUTOSMOOTH) != 0,
mesh->smoothresh,
NULL,
NULL,
nullptr,
nullptr,
clnors);
}
@ -2314,20 +2323,20 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
void BKE_keyblock_update_from_vertcos(const Object *ob, KeyBlock *kb, const float (*vertCos)[3])
{
const float(*co)[3] = vertCos;
float *fp = kb->data;
float *fp = static_cast<float *>(kb->data);
int tot, a;
#ifndef NDEBUG
if (ob->type == OB_LATTICE) {
Lattice *lt = ob->data;
Lattice *lt = static_cast<Lattice *>(ob->data);
BLI_assert((lt->pntsu * lt->pntsv * lt->pntsw) == kb->totelem);
}
else if (ELEM(ob->type, OB_CURVES_LEGACY, OB_SURF)) {
Curve *cu = ob->data;
Curve *cu = static_cast<Curve *>(ob->data);
BLI_assert(BKE_keyblock_curve_element_count(&cu->nurb) == kb->totelem);
}
else if (ob->type == OB_MESH) {
Mesh *me = ob->data;
Mesh *me = static_cast<Mesh *>(ob->data);
BLI_assert(me->totvert == kb->totelem);
}
else {
@ -2352,7 +2361,7 @@ void BKE_keyblock_update_from_vertcos(const Object *ob, KeyBlock *kb, const floa
const BezTriple *bezt;
const BPoint *bp;
for (nu = cu->nurb.first; nu; nu = nu->next) {
for (nu = static_cast<const Nurb *>(cu->nurb.first); nu; nu = nu->next) {
if (nu->bezt) {
for (a = nu->pntsu, bezt = nu->bezt; a; a--, bezt++) {
for (int i = 0; i < 3; i++, co++) {
@ -2407,7 +2416,7 @@ void BKE_keyblock_convert_from_vertcos(const Object *ob, KeyBlock *kb, const flo
float (*BKE_keyblock_convert_to_vertcos(const Object *ob, const KeyBlock *kb))[3]
{
float(*vertCos)[3], (*co)[3];
const float *fp = kb->data;
const float *fp = static_cast<const float *>(kb->data);
int tot = 0, a;
/* Count of vertex coords in array */
@ -2425,10 +2434,10 @@ float (*BKE_keyblock_convert_to_vertcos(const Object *ob, const KeyBlock *kb))[3
}
if (tot == 0) {
return NULL;
return nullptr;
}
co = vertCos = MEM_mallocN(tot * sizeof(*vertCos), __func__);
co = vertCos = static_cast<float(*)[3]>(MEM_mallocN(tot * sizeof(*vertCos), __func__));
/* Copy coords to array */
if (ELEM(ob->type, OB_MESH, OB_LATTICE)) {
@ -2442,7 +2451,7 @@ float (*BKE_keyblock_convert_to_vertcos(const Object *ob, const KeyBlock *kb))[3
const BezTriple *bezt;
const BPoint *bp;
for (nu = cu->nurb.first; nu; nu = nu->next) {
for (nu = static_cast<Nurb *>(cu->nurb.first); nu; nu = nu->next) {
if (nu->bezt) {
for (a = nu->pntsu, bezt = nu->bezt; a; a--, bezt++) {
for (int i = 0; i < 3; i++, co++) {
@ -2468,7 +2477,7 @@ float (*BKE_keyblock_convert_to_vertcos(const Object *ob, const KeyBlock *kb))[3
void BKE_keyblock_update_from_offset(const Object *ob, KeyBlock *kb, const float (*ofs)[3])
{
int a;
float *fp = kb->data;
float *fp = static_cast<float *>(kb->data);
if (ELEM(ob->type, OB_MESH, OB_LATTICE)) {
for (a = 0; a < kb->totelem; a++, fp += 3, ofs++) {
@ -2481,7 +2490,7 @@ void BKE_keyblock_update_from_offset(const Object *ob, KeyBlock *kb, const float
const BezTriple *bezt;
const BPoint *bp;
for (nu = cu->nurb.first; nu; nu = nu->next) {
for (nu = static_cast<const Nurb *>(cu->nurb.first); nu; nu = nu->next) {
if (nu->bezt) {
for (a = nu->pntsu, bezt = nu->bezt; a; a--, bezt++) {
for (int i = 0; i < 3; i++, ofs++) {
@ -2527,7 +2536,9 @@ bool BKE_keyblock_move(Object *ob, int org_index, int new_index)
/* We swap 'org' element with its previous/next neighbor (depending on direction of the move)
* repeatedly, until we reach final position.
* This allows us to only loop on the list once! */
for (kb = (rev ? key->block.last : key->block.first), i = (rev ? totkey - 1 : 0); kb;
for (kb = static_cast<KeyBlock *>(rev ? key->block.last : key->block.first),
i = (rev ? totkey - 1 : 0);
kb;
kb = (rev ? kb->prev : kb->next), rev ? i-- : i++) {
if (i == org_index) {
in_range = true; /* Start list items swapping... */
@ -2575,7 +2586,7 @@ bool BKE_keyblock_move(Object *ob, int org_index, int new_index)
}
/* First key is always refkey, matches interface and BKE_key_sort */
key->refkey = key->block.first;
key->refkey = static_cast<KeyBlock *>(key->block.first);
return true;
}
@ -2586,7 +2597,7 @@ bool BKE_keyblock_is_basis(const Key *key, const int index)
int i;
if (key->type == KEY_RELATIVE) {
for (i = 0, kb = key->block.first; kb; i++, kb = kb->next) {
for (i = 0, kb = static_cast<const KeyBlock *>(key->block.first); kb; i++, kb = kb->next) {
if ((i != index) && (kb->relative == index)) {
return true;
}

81
source/blender/blenkernel/intern/mesh_mirror.c → source/blender/blenkernel/intern/mesh_mirror.cc
View File

@ -42,15 +42,16 @@ Mesh *BKE_mesh_mirror_bisect_on_mirror_plane_for_modifier(MirrorModifierData *mm
BMIter viter;
BMVert *v, *v_next;
bm = BKE_mesh_to_bmesh_ex(mesh,
&(struct BMeshCreateParams){0},
&(struct BMeshFromMeshParams){
.calc_face_normal = true,
.calc_vert_normal = true,
.cd_mask_extra = {.vmask = CD_MASK_ORIGINDEX,
.emask = CD_MASK_ORIGINDEX,
.pmask = CD_MASK_ORIGINDEX},
});
BMeshCreateParams bmesh_create_params{0};
BMeshFromMeshParams bmesh_from_mesh_params{};
bmesh_from_mesh_params.calc_face_normal = true;
bmesh_from_mesh_params.calc_vert_normal = true;
bmesh_from_mesh_params.cd_mask_extra.vmask = CD_MASK_ORIGINDEX;
bmesh_from_mesh_params.cd_mask_extra.emask = CD_MASK_ORIGINDEX;
bmesh_from_mesh_params.cd_mask_extra.pmask = CD_MASK_ORIGINDEX;
bm = BKE_mesh_to_bmesh_ex(mesh, &bmesh_create_params, &bmesh_from_mesh_params);
/* Define bisecting plane (aka mirror plane). */
float plane[4];
@ -76,7 +77,7 @@ Mesh *BKE_mesh_mirror_bisect_on_mirror_plane_for_modifier(MirrorModifierData *mm
}
}
result = BKE_mesh_from_bmesh_for_eval_nomain(bm, NULL, mesh);
result = BKE_mesh_from_bmesh_for_eval_nomain(bm, nullptr, mesh);
BM_mesh_free(bm);
return result;
@ -87,18 +88,15 @@ void BKE_mesh_mirror_apply_mirror_on_axis(struct Main *bmain,
const int axis,
const float dist)
{
BMesh *bm = BKE_mesh_to_bmesh_ex(mesh,
&(struct BMeshCreateParams){
.use_toolflags = 1,
},
&(struct BMeshFromMeshParams){
.calc_face_normal = true,
.calc_vert_normal = true,
.cd_mask_extra =
{
.vmask = CD_MASK_SHAPEKEY,
},
});
BMeshCreateParams bmesh_create_params{};
bmesh_create_params.use_toolflags = 1;
BMeshFromMeshParams bmesh_from_mesh_params{};
bmesh_from_mesh_params.calc_face_normal = true;
bmesh_from_mesh_params.calc_vert_normal = true;
bmesh_from_mesh_params.cd_mask_extra.vmask = CD_MASK_SHAPEKEY;
BMesh *bm = BKE_mesh_to_bmesh_ex(mesh, &bmesh_create_params, &bmesh_from_mesh_params);
BMO_op_callf(bm,
(BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
"symmetrize input=%avef direction=%i dist=%f use_shapekey=%b",
@ -106,13 +104,10 @@ void BKE_mesh_mirror_apply_mirror_on_axis(struct Main *bmain,
dist,
true);
BM_mesh_bm_to_me(bmain,
bm,
mesh,
(&(struct BMeshToMeshParams){
.calc_object_remap = true,
BMeshToMeshParams bmesh_to_mesh_params{};
bmesh_to_mesh_params.calc_object_remap = true;
}));
BM_mesh_bm_to_me(bmain, bm, mesh, &bmesh_to_mesh_params);
BM_mesh_free(bm);
}
@ -139,14 +134,14 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
float plane_co[3], plane_no[3];
int i;
int a, totshape;
int *vtargetmap = NULL, *vtmap_a = NULL, *vtmap_b = NULL;
int *vtargetmap = nullptr, *vtmap_a = nullptr, *vtmap_b = nullptr;
/* mtx is the mirror transformation */
unit_m4(mtx);
mtx[axis][axis] = -1.0f;
Object *mirror_ob = mmd->mirror_ob;
if (mirror_ob != NULL) {
if (mirror_ob != nullptr) {
float tmp[4][4];
float itmp[4][4];
@ -187,7 +182,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
negate_v3_v3(plane_no, mtx[axis]);
}
Mesh *mesh_bisect = NULL;
Mesh *mesh_bisect = nullptr;
if (do_bisect) {
mesh_bisect = BKE_mesh_mirror_bisect_on_mirror_plane_for_modifier(
mmd, mesh, axis, plane_co, plane_no);
@ -230,7 +225,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
if (do_vtargetmap) {
/* second half is filled with -1 */
vtargetmap = MEM_malloc_arrayN(maxVerts, sizeof(int[2]), "MOD_mirror tarmap");
vtargetmap = static_cast<int *>(
MEM_malloc_arrayN(maxVerts, sizeof(int[2]), "MOD_mirror tarmap"));
vtmap_a = vtargetmap;
vtmap_b = vtargetmap + maxVerts;
@ -297,7 +293,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
/* handle shape keys */
totshape = CustomData_number_of_layers(&result->vdata, CD_SHAPEKEY);
for (a = 0; a < totshape; a++) {
float(*cos)[3] = CustomData_get_layer_n(&result->vdata, CD_SHAPEKEY, a);
float(*cos)[3] = static_cast<float(*)[3]>(
CustomData_get_layer_n(&result->vdata, CD_SHAPEKEY, a));
for (i = maxVerts; i < result->totvert; i++) {
mul_m4_v3(mtx, cos[i]);
}
@ -359,7 +356,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
const int totuv = CustomData_number_of_layers(&result->ldata, CD_MLOOPUV);
for (a = 0; a < totuv; a++) {
MLoopUV *dmloopuv = CustomData_get_layer_n(&result->ldata, CD_MLOOPUV, a);
MLoopUV *dmloopuv = static_cast<MLoopUV *>(
CustomData_get_layer_n(&result->ldata, CD_MLOOPUV, a));
int j = maxLoops;
dmloopuv += j; /* second set of loops only */
for (; j-- > 0; dmloopuv++) {
@ -392,10 +390,11 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
CustomData_has_layer(&result->ldata, CD_CUSTOMLOOPNORMAL)) {
const int totloop = result->totloop;
const int totpoly = result->totpoly;
float(*loop_normals)[3] = MEM_calloc_arrayN((size_t)totloop, sizeof(*loop_normals), __func__);
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] = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
MLoopNorSpaceArray lnors_spacearr = {NULL};
short(*clnors)[2] = static_cast<short(*)[2]>(CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL));
MLoopNorSpaceArray lnors_spacearr = {nullptr};
/* The transform matrix of a normal must be
* the transpose of inverse of transform matrix of the geometry... */
@ -418,7 +417,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
totpoly,
true,
mesh->smoothresh,
NULL,
nullptr,
&lnors_spacearr,
clnors);
@ -448,7 +447,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
/* handle vgroup stuff */
if ((mmd->flag & MOD_MIR_VGROUP) && CustomData_has_layer(&result->vdata, CD_MDEFORMVERT)) {
MDeformVert *dvert = BKE_mesh_deform_verts_for_write(result) + maxVerts;
int *flip_map = NULL, flip_map_len = 0;
int *flip_map = nullptr, flip_map_len = 0;
flip_map = BKE_object_defgroup_flip_map(ob, false, &flip_map_len);
@ -480,8 +479,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
MEM_freeN(vtargetmap);
}
if (mesh_bisect != NULL) {
BKE_id_free(NULL, mesh_bisect);
if (mesh_bisect != nullptr) {
BKE_id_free(nullptr, mesh_bisect);
}
return result;

4
source/blender/blenlib/BLI_linklist.h
View File

@ -88,9 +88,9 @@ LinkNode *BLI_linklist_sort_r(LinkNode *list,
void *thunk) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2);
#define BLI_linklist_prepend_alloca(listp, ptr) \
BLI_linklist_prepend_nlink(listp, ptr, alloca(sizeof(LinkNode)))
BLI_linklist_prepend_nlink(listp, ptr, (LinkNode *)alloca(sizeof(LinkNode)))
#define BLI_linklist_append_alloca(list_pair, ptr) \
BLI_linklist_append_nlink(list_pair, ptr, alloca(sizeof(LinkNode)))
BLI_linklist_append_nlink(list_pair, ptr, (LinkNode *)alloca(sizeof(LinkNode)))
#ifdef __cplusplus
}

2
source/blender/bmesh/CMakeLists.txt
View File

@ -88,7 +88,7 @@ set(SRC
intern/bmesh_mesh_debug.h
intern/bmesh_mesh_duplicate.c
intern/bmesh_mesh_duplicate.h
intern/bmesh_mesh_normals.c
intern/bmesh_mesh_normals.cc
intern/bmesh_mesh_normals.h
intern/bmesh_mesh_partial_update.c
intern/bmesh_mesh_partial_update.h

321
source/blender/bmesh/intern/bmesh_mesh_normals.c → source/blender/bmesh/intern/bmesh_mesh_normals.cc
View File

@ -109,12 +109,12 @@ static void bm_vert_calc_normals_impl(BMVert *v)
zero_v3(v_no);
BMEdge *e_first = v->e;
if (e_first != NULL) {
if (e_first != nullptr) {
float e1diff[3], e2diff[3];
BMEdge *e_iter = e_first;
do {
BMLoop *l_first = e_iter->l;
if (l_first != NULL) {
if (l_first != nullptr) {
sub_v3_v3v3(e2diff, e_iter->v1->co, e_iter->v2->co);
normalize_v3(e2diff);
@ -155,12 +155,12 @@ static void bm_vert_calc_normals_with_coords(BMVert *v, BMVertsCalcNormalsWithCo
/* Loop over edges. */
BMEdge *e_first = v->e;
if (e_first != NULL) {
if (e_first != nullptr) {
float e1diff[3], e2diff[3];
BMEdge *e_iter = e_first;
do {
BMLoop *l_first = e_iter->l;
if (l_first != NULL) {
if (l_first != nullptr) {
sub_v3_v3v3(e2diff,
data->vcos[BM_elem_index_get(e_iter->v1)],
data->vcos[BM_elem_index_get(e_iter->v2)]);
@ -194,7 +194,8 @@ static void bm_vert_calc_normals_with_coords_cb(void *userdata,
MempoolIterData *mp_v,
const TaskParallelTLS *__restrict UNUSED(tls))
{
BMVertsCalcNormalsWithCoordsData *data = userdata;
BMVertsCalcNormalsWithCoordsData *data = static_cast<BMVertsCalcNormalsWithCoordsData *>(
userdata);
BMVert *v = (BMVert *)mp_v;
bm_vert_calc_normals_with_coords(v, data);
}
@ -210,16 +211,15 @@ static void bm_mesh_verts_calc_normals(BMesh *bm,
BLI_parallel_mempool_settings_defaults(&settings);
settings.use_threading = bm->totvert >= BM_OMP_LIMIT;
if (vcos == NULL) {
BM_iter_parallel(bm, BM_VERTS_OF_MESH, bm_vert_calc_normals_cb, NULL, &settings);
if (vcos == nullptr) {
BM_iter_parallel(bm, BM_VERTS_OF_MESH, bm_vert_calc_normals_cb, nullptr, &settings);
}
else {
BLI_assert(!ELEM(NULL, fnos, vnos));
BMVertsCalcNormalsWithCoordsData data = {
.fnos = fnos,
.vcos = vcos,
.vnos = vnos,
};
BLI_assert(!ELEM(nullptr, fnos, vnos));
BMVertsCalcNormalsWithCoordsData data{};
data.fnos = fnos;
data.vcos = vcos;
data.vnos = vnos;
BM_iter_parallel(bm, BM_VERTS_OF_MESH, bm_vert_calc_normals_with_coords_cb, &data, &settings);
}
}
@ -241,19 +241,18 @@ void BM_mesh_normals_update_ex(BMesh *bm, const struct BMeshNormalsUpdate_Params
BLI_parallel_mempool_settings_defaults(&settings);
settings.use_threading = bm->totedge >= BM_OMP_LIMIT;
BM_iter_parallel(bm, BM_FACES_OF_MESH, bm_face_calc_normals_cb, NULL, &settings);
BM_iter_parallel(bm, BM_FACES_OF_MESH, bm_face_calc_normals_cb, nullptr, &settings);
}
/* Add weighted face normals to vertices, and normalize vert normals. */
bm_mesh_verts_calc_normals(bm, NULL, NULL, NULL);
bm_mesh_verts_calc_normals(bm, nullptr, nullptr, nullptr);
}
void BM_mesh_normals_update(BMesh *bm)
{
BM_mesh_normals_update_ex(bm,
&(const struct BMeshNormalsUpdate_Params){
.face_normals = true,
});
BMeshNormalsUpdate_Params params{};
params.face_normals = true;
BM_mesh_normals_update_ex(bm, &params);
}
/** \} */
@ -307,11 +306,9 @@ void BM_mesh_normals_update_with_partial_ex(BMesh *UNUSED(bm),
void BM_mesh_normals_update_with_partial(BMesh *bm, const BMPartialUpdate *bmpinfo)
{
BM_mesh_normals_update_with_partial_ex(bm,
bmpinfo,
&(const struct BMeshNormalsUpdate_Params){
.face_normals = true,
});
BMeshNormalsUpdate_Params params{};
params.face_normals = true;
BM_mesh_normals_update_with_partial_ex(bm, bmpinfo, &params);
}
/** \} */
@ -389,7 +386,7 @@ static void bm_mesh_edges_sharp_tag(BMesh *bm,
if (do_sharp_edges_tag) {
BM_ITER_MESH_INDEX (e, &eiter, bm, BM_EDGES_OF_MESH, i) {
BM_elem_index_set(e, i); /* set_inline */
if (e->l != NULL) {
if (e->l != nullptr) {
bm_edge_tag_from_smooth_and_set_sharp(fnos, e, split_angle_cos);
}
}
@ -397,7 +394,7 @@ static void bm_mesh_edges_sharp_tag(BMesh *bm,
else {
BM_ITER_MESH_INDEX (e, &eiter, bm, BM_EDGES_OF_MESH, i) {
BM_elem_index_set(e, i); /* set_inline */
if (e->l != NULL) {
if (e->l != nullptr) {
bm_edge_tag_from_smooth(fnos, e, split_angle_cos);
}
}
@ -413,7 +410,7 @@ void BM_edges_sharp_from_angle_set(BMesh *bm, const float split_angle)
return;
}
bm_mesh_edges_sharp_tag(bm, NULL, cosf(split_angle), true);
bm_mesh_edges_sharp_tag(bm, nullptr, cosf(split_angle), true);
}
/** \} */
@ -481,8 +478,8 @@ static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm,
MLoopNorSpaceArray *r_lnors_spacearr)
{
BLI_assert((bm->elem_index_dirty & BM_LOOP) == 0);
BLI_assert((fnos == NULL) || ((bm->elem_index_dirty & BM_FACE) == 0));
BLI_assert((vcos == NULL) || ((bm->elem_index_dirty & BM_VERT) == 0));
BLI_assert((fnos == nullptr) || ((bm->elem_index_dirty & BM_FACE) == 0));
BLI_assert((vcos == nullptr) || ((bm->elem_index_dirty & BM_VERT) == 0));
UNUSED_VARS_NDEBUG(bm);
int handled = 0;
@ -537,15 +534,16 @@ static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm,
normalize_v3(vec_prev);
}
BKE_lnor_space_define(lnor_space, r_lnos[l_curr_index], vec_curr, vec_prev, NULL);
BKE_lnor_space_define(lnor_space, r_lnos[l_curr_index], vec_curr, vec_prev, nullptr);
/* We know there is only one loop in this space,
* no need to create a linklist in this case... */
BKE_lnor_space_add_loop(r_lnors_spacearr, lnor_space, l_curr_index, l_curr, true);
if (has_clnors) {
const short(*clnor)[2] = clnors_data ? &clnors_data[l_curr_index] :
(const void *)BM_ELEM_CD_GET_VOID_P(
l_curr, cd_loop_clnors_offset);
const short(*clnor)[2] = clnors_data ?
&clnors_data[l_curr_index] :
static_cast<const short(*)[2]>(
BM_ELEM_CD_GET_VOID_P(l_curr, cd_loop_clnors_offset));
BKE_lnor_space_custom_data_to_normal(lnor_space, *clnor, r_lnos[l_curr_index]);
}
}
@ -579,15 +577,16 @@ static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm,
/* We validate clnors data on the fly - cheapest way to do! */
int clnors_avg[2] = {0, 0};
const short(*clnor_ref)[2] = NULL;
const short(*clnor_ref)[2] = nullptr;
int clnors_count = 0;
bool clnors_invalid = false;
const float *co_pivot = vcos ? vcos[BM_elem_index_get(v_pivot)] : v_pivot->co;
MLoopNorSpace *lnor_space = r_lnors_spacearr ? BKE_lnor_space_create(r_lnors_spacearr) : NULL;
MLoopNorSpace *lnor_space = r_lnors_spacearr ? BKE_lnor_space_create(r_lnors_spacearr) :
nullptr;
BLI_assert((edge_vectors == NULL) || BLI_stack_is_empty(edge_vectors));
BLI_assert((edge_vectors == nullptr) || BLI_stack_is_empty(edge_vectors));
lfan_pivot = l_curr;
lfan_pivot_index = BM_elem_index_get(lfan_pivot);
@ -646,9 +645,10 @@ static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm,
if (has_clnors) {
/* Accumulate all clnors, if they are not all equal we have to fix that! */
const short(*clnor)[2] = clnors_data ? &clnors_data[lfan_pivot_index] :
(const void *)BM_ELEM_CD_GET_VOID_P(
lfan_pivot, cd_loop_clnors_offset);
const short(*clnor)[2] = clnors_data ?
&clnors_data[lfan_pivot_index] :
static_cast<const short(*)[2]>(BM_ELEM_CD_GET_VOID_P(
lfan_pivot, cd_loop_clnors_offset));
if (clnors_count) {
clnors_invalid |= ((*clnor_ref)[0] != (*clnor)[0] || (*clnor_ref)[1] != (*clnor)[1]);
}
@ -713,7 +713,7 @@ static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm,
/* Prints continuously when merge custom normals, so commenting. */
// printf("Invalid clnors in this fan!\n");
while ((clnor = BLI_SMALLSTACK_POP(clnors))) {
while ((clnor = static_cast<short *>(BLI_SMALLSTACK_POP(clnors)))) {
// print_v2("org clnor", clnor);
clnor[0] = (short)clnors_avg[0];
clnor[1] = (short)clnors_avg[1];
@ -735,7 +735,7 @@ static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm,
/* Copy back the final computed normal into all related loop-normals. */
float *nor;
while ((nor = BLI_SMALLSTACK_POP(normal))) {
while ((nor = static_cast<float *>(BLI_SMALLSTACK_POP(normal)))) {
copy_v3_v3(nor, lnor);
}
}
@ -791,14 +791,14 @@ BLI_INLINE bool bm_edge_is_smooth_no_angle_test(const BMEdge *e,
static void bm_edge_tag_from_smooth(const float (*fnos)[3], BMEdge *e, const float split_angle_cos)
{
BLI_assert(e->l != NULL);
BLI_assert(e->l != nullptr);
BMLoop *l_a = e->l, *l_b = l_a->radial_next;
bool is_smooth = false;
if (bm_edge_is_smooth_no_angle_test(e, l_a, l_b)) {
if (split_angle_cos != -1.0f) {
const float dot = (fnos == NULL) ? dot_v3v3(l_a->f->no, l_b->f->no) :
dot_v3v3(fnos[BM_elem_index_get(l_a->f)],
fnos[BM_elem_index_get(l_b->f)]);
const float dot = (fnos == nullptr) ? dot_v3v3(l_a->f->no, l_b->f->no) :
dot_v3v3(fnos[BM_elem_index_get(l_a->f)],
fnos[BM_elem_index_get(l_b->f)]);
if (dot >= split_angle_cos) {
is_smooth = true;
}
@ -832,14 +832,14 @@ static void bm_edge_tag_from_smooth_and_set_sharp(const float (*fnos)[3],
BMEdge *e,
const float split_angle_cos)
{
BLI_assert(e->l != NULL);
BLI_assert(e->l != nullptr);
BMLoop *l_a = e->l, *l_b = l_a->radial_next;
bool is_smooth = false;
if (bm_edge_is_smooth_no_angle_test(e, l_a, l_b)) {
if (split_angle_cos != -1.0f) {
const float dot = (fnos == NULL) ? dot_v3v3(l_a->f->no, l_b->f->no) :
dot_v3v3(fnos[BM_elem_index_get(l_a->f)],
fnos[BM_elem_index_get(l_b->f)]);
const float dot = (fnos == nullptr) ? dot_v3v3(l_a->f->no, l_b->f->no) :
dot_v3v3(fnos[BM_elem_index_get(l_a->f)],
fnos[BM_elem_index_get(l_b->f)]);
if (dot >= split_angle_cos) {
is_smooth = true;
}
@ -887,7 +887,7 @@ static void bm_mesh_loops_calc_normals_for_vert_with_clnors(BMesh *bm,
*
* Sorting is only performed when multiple fans are found. */
const bool has_clnors = true;
LinkNode *loops_of_vert = NULL;
LinkNode *loops_of_vert = nullptr;
int loops_of_vert_count = 0;
/* When false the caller must have already tagged the edges. */
const bool do_edge_tag = (split_angle_cos != EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS);
@ -899,7 +899,7 @@ static void bm_mesh_loops_calc_normals_for_vert_with_clnors(BMesh *bm,
BMEdge *e_curr_iter = v->e;
do { /* Edges of vertex. */
BMLoop *l_curr = e_curr_iter->l;
if (l_curr == NULL) {
if (l_curr == nullptr) {
continue;
}
@ -927,7 +927,7 @@ static void bm_mesh_loops_calc_normals_for_vert_with_clnors(BMesh *bm,
} while ((l_curr = l_curr->radial_next) != e_curr_iter->l);
} while ((e_curr_iter = BM_DISK_EDGE_NEXT(e_curr_iter, v)) != v->e);
if (UNLIKELY(loops_of_vert == NULL)) {
if (UNLIKELY(loops_of_vert == nullptr)) {
return;
}
@ -944,8 +944,8 @@ static void bm_mesh_loops_calc_normals_for_vert_with_clnors(BMesh *bm,
/* Keep track of the number of loops that have been assigned. */
int loops_of_vert_handled = 0;
while (loops_of_vert != NULL) {
BMLoop *l_best = loops_of_vert->link;
while (loops_of_vert != nullptr) {
BMLoop *l_best = static_cast<BMLoop *>(loops_of_vert->link);
loops_of_vert = loops_of_vert->next;
BLI_assert(l_best->v == v);
@ -997,7 +997,7 @@ static void bm_mesh_loops_calc_normals_for_vert_without_clnors(
BMVert *v)
{
const bool has_clnors = false;
const short(*clnors_data)[2] = NULL;
const short(*clnors_data)[2] = nullptr;
/* When false the caller must have already tagged the edges. */
const bool do_edge_tag = (split_angle_cos != EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS);
const int cd_loop_clnors_offset = -1;
@ -1008,7 +1008,7 @@ static void bm_mesh_loops_calc_normals_for_vert_without_clnors(
e_curr_iter = v->e;
do { /* Edges of vertex. */
BMLoop *l_curr = e_curr_iter->l;
if (l_curr == NULL) {
if (l_curr == nullptr) {
continue;
}
@ -1027,7 +1027,7 @@ static void bm_mesh_loops_calc_normals_for_vert_without_clnors(
e_curr_iter = v->e;
do { /* Edges of vertex. */
BMLoop *l_curr = e_curr_iter->l;
if (l_curr == NULL) {
if (l_curr == nullptr) {
continue;
}
do { /* Radial loops. */
@ -1055,7 +1055,7 @@ static void bm_mesh_loops_calc_normals_for_vert_without_clnors(
/**
* BMesh version of BKE_mesh_normals_loop_split() in `mesh_evaluate.cc`
* Will use first clnors_data array, and fallback to cd_loop_clnors_offset
* (use NULL and -1 to not use clnors).
* (use nullptr and -1 to not use clnors).
*
* \note This sets #BM_ELEM_TAG which is used in tool code (e.g. T84426).
* we could add a low-level API flag for this, see #BM_ELEM_API_FLAG_ENABLE and friends.
@ -1076,9 +1076,9 @@ static void bm_mesh_loops_calc_normals__single_threaded(BMesh *bm,
/* When false the caller must have already tagged the edges. */
const bool do_edge_tag = (split_angle_cos != EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS);
MLoopNorSpaceArray _lnors_spacearr = {NULL};
MLoopNorSpaceArray _lnors_spacearr = {nullptr};
BLI_Stack *edge_vectors = NULL;
BLI_Stack *edge_vectors = nullptr;
{
char htype = 0;
@ -1159,9 +1159,9 @@ typedef struct BMLoopsCalcNormalsWithCoordsData {
const float (*vcos)[3];
BMesh *bm;
const short (*clnors_data)[2];
const int cd_loop_clnors_offset;
const bool do_rebuild;
const float split_angle_cos;
int cd_loop_clnors_offset;
bool do_rebuild;
float split_angle_cos;
/* Output. */
float (*r_lnos)[3];
@ -1171,7 +1171,7 @@ typedef struct BMLoopsCalcNormalsWithCoordsData {
typedef struct BMLoopsCalcNormalsWithCoords_TLS {
BLI_Stack *edge_vectors;
/** Copied from #BMLoopsCalcNormalsWithCoordsData.r_lnors_spacearr when it's not NULL. */
/** Copied from #BMLoopsCalcNormalsWithCoordsData.r_lnors_spacearr when it's not nullptr. */
MLoopNorSpaceArray *lnors_spacearr;
MLoopNorSpaceArray lnors_spacearr_buf;
} BMLoopsCalcNormalsWithCoords_TLS;
@ -1179,15 +1179,15 @@ typedef struct BMLoopsCalcNormalsWithCoords_TLS {
static void bm_mesh_loops_calc_normals_for_vert_init_fn(const void *__restrict userdata,
void *__restrict chunk)
{
const BMLoopsCalcNormalsWithCoordsData *data = userdata;
BMLoopsCalcNormalsWithCoords_TLS *tls_data = chunk;
auto *data = static_cast<const BMLoopsCalcNormalsWithCoordsData *>(userdata);
auto *tls_data = static_cast<BMLoopsCalcNormalsWithCoords_TLS *>(chunk);
if (data->r_lnors_spacearr) {
tls_data->edge_vectors = BLI_stack_new(sizeof(float[3]), __func__);
BKE_lnor_spacearr_tls_init(data->r_lnors_spacearr, &tls_data->lnors_spacearr_buf);
tls_data->lnors_spacearr = &tls_data->lnors_spacearr_buf;
}
else {
tls_data->lnors_spacearr = NULL;
tls_data->lnors_spacearr = nullptr;
}
}
@ -1195,8 +1195,8 @@ static void bm_mesh_loops_calc_normals_for_vert_reduce_fn(const void *__restrict
void *__restrict UNUSED(chunk_join),
void *__restrict chunk)
{
const BMLoopsCalcNormalsWithCoordsData *data = userdata;
BMLoopsCalcNormalsWithCoords_TLS *tls_data = chunk;
auto *data = static_cast<const BMLoopsCalcNormalsWithCoordsData *>(userdata);
auto *tls_data = static_cast<BMLoopsCalcNormalsWithCoords_TLS *>(chunk);
if (data->r_lnors_spacearr) {
BKE_lnor_spacearr_tls_join(data->r_lnors_spacearr, tls_data->lnors_spacearr);
@ -1206,8 +1206,8 @@ static void bm_mesh_loops_calc_normals_for_vert_reduce_fn(const void *__restrict
static void bm_mesh_loops_calc_normals_for_vert_free_fn(const void *__restrict userdata,
void *__restrict chunk)
{
const BMLoopsCalcNormalsWithCoordsData *data = userdata;
BMLoopsCalcNormalsWithCoords_TLS *tls_data = chunk;
auto *data = static_cast<const BMLoopsCalcNormalsWithCoordsData *>(userdata);
auto *tls_data = static_cast<BMLoopsCalcNormalsWithCoords_TLS *>(chunk);
if (data->r_lnors_spacearr) {
BLI_stack_free(tls_data->edge_vectors);
@ -1218,11 +1218,11 @@ static void bm_mesh_loops_calc_normals_for_vert_with_clnors_fn(
void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict tls)
{
BMVert *v = (BMVert *)mp_v;
if (v->e == NULL) {
if (v->e == nullptr) {
return;
}
BMLoopsCalcNormalsWithCoordsData *data = userdata;
BMLoopsCalcNormalsWithCoords_TLS *tls_data = tls->userdata_chunk;
auto *data = static_cast<BMLoopsCalcNormalsWithCoordsData *>(userdata);
auto *tls_data = static_cast<BMLoopsCalcNormalsWithCoords_TLS *>(tls->userdata_chunk);
bm_mesh_loops_calc_normals_for_vert_with_clnors(data->bm,
data->vcos,
data->fnos,
@ -1243,11 +1243,11 @@ static void bm_mesh_loops_calc_normals_for_vert_without_clnors_fn(
void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict tls)
{
BMVert *v = (BMVert *)mp_v;
if (v->e == NULL) {
if (v->e == nullptr) {
return;
}
BMLoopsCalcNormalsWithCoordsData *data = userdata;
BMLoopsCalcNormalsWithCoords_TLS *tls_data = tls->userdata_chunk;
auto *data = static_cast<BMLoopsCalcNormalsWithCoordsData *>(userdata);
auto *tls_data = static_cast<BMLoopsCalcNormalsWithCoords_TLS *>(tls->userdata_chunk);
bm_mesh_loops_calc_normals_for_vert_without_clnors(data->bm,
data->vcos,
data->fnos,
@ -1273,7 +1273,7 @@ static void bm_mesh_loops_calc_normals__multi_threaded(BMesh *bm,
const float split_angle_cos)
{
const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
MLoopNorSpaceArray _lnors_spacearr = {NULL};
MLoopNorSpaceArray _lnors_spacearr = {nullptr};
{
char htype = BM_LOOP;
@ -1303,7 +1303,7 @@ static void bm_mesh_loops_calc_normals__multi_threaded(BMesh *bm,
TaskParallelSettings settings;
BLI_parallel_mempool_settings_defaults(&settings);
BMLoopsCalcNormalsWithCoords_TLS tls = {NULL};
BMLoopsCalcNormalsWithCoords_TLS tls = {nullptr};
settings.userdata_chunk = &tls;
settings.userdata_chunk_size = sizeof(tls);
@ -1312,17 +1312,16 @@ static void bm_mesh_loops_calc_normals__multi_threaded(BMesh *bm,
settings.func_reduce = bm_mesh_loops_calc_normals_for_vert_reduce_fn;
settings.func_free = bm_mesh_loops_calc_normals_for_vert_free_fn;
BMLoopsCalcNormalsWithCoordsData data = {
.bm = bm,
.vcos = vcos,
.fnos = fnos,
.r_lnos = r_lnos,
.r_lnors_spacearr = r_lnors_spacearr,
.clnors_data = clnors_data,
.cd_loop_clnors_offset = cd_loop_clnors_offset,
.do_rebuild = do_rebuild,
.split_angle_cos = split_angle_cos,
};
BMLoopsCalcNormalsWithCoordsData data{};
data.bm = bm;
data.vcos = vcos;
data.fnos = fnos;
data.r_lnos = r_lnos;
data.r_lnors_spacearr = r_lnors_spacearr;
data.clnors_data = clnors_data;
data.cd_loop_clnors_offset = cd_loop_clnors_offset;
data.do_rebuild = do_rebuild;
data.split_angle_cos = split_angle_cos;
BM_iter_parallel(bm,
BM_VERTS_OF_MESH,
@ -1391,12 +1390,12 @@ static bool bm_mesh_loops_split_lnor_fans(BMesh *bm,
for (int i = 0; i < bm->totloop; i++) {
if (!lnors_spacearr->lspacearr[i]) {
/* This should not happen in theory, but in some rare case (probably ugly geometry)
* we can get some NULL loopspacearr at this point. :/
* we can get some nullptr loopspacearr at this point. :/
* Maybe we should set those loops' edges as sharp?
*/
BLI_BITMAP_ENABLE(done_loops, i);
if (G.debug & G_DEBUG) {
printf("WARNING! Getting invalid NULL loop space for loop %d!\n", i);
printf("WARNING! Getting invalid nullptr loop space for loop %d!\n", i);
}
continue;
}
@ -1417,11 +1416,11 @@ static bool bm_mesh_loops_split_lnor_fans(BMesh *bm,
}
LinkNode *loops = lnors_spacearr->lspacearr[i]->loops;
BMLoop *prev_ml = NULL;
const float *org_nor = NULL;
BMLoop *prev_ml = nullptr;
const float *org_nor = nullptr;
while (loops) {
BMLoop *ml = loops->link;
BMLoop *ml = static_cast<BMLoop *>(loops->link);
const int lidx = BM_elem_index_get(ml);
const float *nor = new_lnors[lidx];
@ -1453,7 +1452,7 @@ static bool bm_mesh_loops_split_lnor_fans(BMesh *bm,
* See T45984. */
loops = lnors_spacearr->lspacearr[i]->loops;
if (loops && org_nor) {
BMLoop *ml = loops->link;
BMLoop *ml = static_cast<BMLoop *>(loops->link);
const int lidx = BM_elem_index_get(ml);
const float *nor = new_lnors[lidx];
@ -1491,7 +1490,8 @@ static void bm_mesh_loops_assign_normal_data(BMesh *bm,
if (!lnors_spacearr->lspacearr[i]) {
BLI_BITMAP_ENABLE(done_loops, i);
if (G.debug & G_DEBUG) {
printf("WARNING! Still getting invalid NULL loop space in second loop for loop %d!\n", i);
printf("WARNING! Still getting invalid nullptr loop space in second loop for loop %d!\n",
i);
}
continue;
}
@ -1510,8 +1510,9 @@ static void bm_mesh_loops_assign_normal_data(BMesh *bm,
BLI_assert(lidx == i);
const float *nor = new_lnors[lidx];
short *clnor = r_clnors_data ? &r_clnors_data[lidx] :
BM_ELEM_CD_GET_VOID_P(ml, cd_loop_clnors_offset);
short *clnor = static_cast<short *>(r_clnors_data ?
&r_clnors_data[lidx] :
BM_ELEM_CD_GET_VOID_P(ml, cd_loop_clnors_offset));
BKE_lnor_space_custom_normal_to_data(lnors_spacearr->lspacearr[i], nor, clnor);
BLI_BITMAP_ENABLE(done_loops, i);
@ -1524,11 +1525,12 @@ static void bm_mesh_loops_assign_normal_data(BMesh *bm,
zero_v3(avg_nor);
while (loops) {
BMLoop *ml = loops->link;
BMLoop *ml = static_cast<BMLoop *>(loops->link);
const int lidx = BM_elem_index_get(ml);
const float *nor = new_lnors[lidx];
short *clnor = r_clnors_data ? &r_clnors_data[lidx] :
BM_ELEM_CD_GET_VOID_P(ml, cd_loop_clnors_offset);
short *clnor = static_cast<short *>(
r_clnors_data ? &r_clnors_data[lidx] :
BM_ELEM_CD_GET_VOID_P(ml, cd_loop_clnors_offset));
avg_nor_count++;
add_v3_v3(avg_nor, nor);
@ -1542,7 +1544,7 @@ static void bm_mesh_loops_assign_normal_data(BMesh *bm,
BKE_lnor_space_custom_normal_to_data(
lnors_spacearr->lspacearr[i], avg_nor, clnor_data_tmp);
while ((clnor_data = BLI_SMALLSTACK_POP(clnors_data))) {
while ((clnor_data = static_cast<short *>(BLI_SMALLSTACK_POP(clnors_data)))) {
clnor_data[0] = clnor_data_tmp[0];
clnor_data[1] = clnor_data_tmp[1];
}
@ -1573,7 +1575,8 @@ static void bm_mesh_loops_custom_normals_set(BMesh *bm,
BMFace *f;
BMLoop *l;
BMIter liter, fiter;
float(*cur_lnors)[3] = MEM_mallocN(sizeof(*cur_lnors) * bm->totloop, __func__);
float(*cur_lnors)[3] = static_cast<float(*)[3]>(
MEM_mallocN(sizeof(*cur_lnors) * bm->totloop, __func__));
BKE_lnor_spacearr_clear(r_lnors_spacearr);
@ -1596,12 +1599,13 @@ static void bm_mesh_loops_custom_normals_set(BMesh *bm,
/* Extract new normals from the data layer if necessary. */
float(*custom_lnors)[3] = new_lnors;
if (new_lnors == NULL) {
custom_lnors = MEM_mallocN(sizeof(*new_lnors) * bm->totloop, __func__);
if (new_lnors == nullptr) {
custom_lnors = static_cast<float(*)[3]>(
MEM_mallocN(sizeof(*new_lnors) * bm->totloop, __func__));
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
const float *normal = BM_ELEM_CD_GET_VOID_P(l, cd_new_lnors_offset);
const float *normal = static_cast<float *>(BM_ELEM_CD_GET_VOID_P(l, cd_new_lnors_offset));
copy_v3_v3(custom_lnors[BM_elem_index_get(l)], normal);
}
}
@ -1719,7 +1723,7 @@ void BM_loops_calc_normal_vcos(BMesh *bm,
void BM_lnorspacearr_store(BMesh *bm, float (*r_lnors)[3])
{
BLI_assert(bm->lnor_spacearr != NULL);
BLI_assert(bm->lnor_spacearr != nullptr);
if (!CustomData_has_layer(&bm->ldata, CD_CUSTOMLOOPNORMAL)) {
BM_data_layer_add(bm, &bm->ldata, CD_CUSTOMLOOPNORMAL);
@ -1728,14 +1732,14 @@ void BM_lnorspacearr_store(BMesh *bm, float (*r_lnors)[3])
int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
BM_loops_calc_normal_vcos(bm,
NULL,
NULL,
NULL,
nullptr,
nullptr,
nullptr,
true,
M_PI,
r_lnors,
bm->lnor_spacearr,
NULL,
nullptr,
cd_loop_clnors_offset,
false);
bm->spacearr_dirty &= ~(BM_SPACEARR_DIRTY | BM_SPACEARR_DIRTY_ALL);
@ -1752,7 +1756,7 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
return;
}
if (bm->lnor_spacearr == NULL) {
if (bm->lnor_spacearr == nullptr) {
bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
return;
}
@ -1813,7 +1817,7 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
{
BLI_assert(bm->lnor_spacearr != NULL);
BLI_assert(bm->lnor_spacearr != nullptr);
if (!(bm->spacearr_dirty & (BM_SPACEARR_DIRTY | BM_SPACEARR_DIRTY_ALL))) {
return;
@ -1822,22 +1826,24 @@ void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
BMLoop *l;
BMIter fiter, liter;
float(*r_lnors)[3] = MEM_callocN(sizeof(*r_lnors) * bm->totloop, __func__);
float(*oldnors)[3] = preserve_clnor ? MEM_mallocN(sizeof(*oldnors) * bm->totloop, __func__) :
NULL;
float(*r_lnors)[3] = static_cast<float(*)[3]>(
MEM_callocN(sizeof(*r_lnors) * bm->totloop, __func__));
float(*oldnors)[3] = static_cast<float(*)[3]>(
preserve_clnor ? MEM_mallocN(sizeof(*oldnors) * bm->totloop, __func__) : nullptr);
int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
BM_mesh_elem_index_ensure(bm, BM_LOOP);
if (preserve_clnor) {
BLI_assert(bm->lnor_spacearr->lspacearr != NULL);
BLI_assert(bm->lnor_spacearr->lspacearr != nullptr);
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
if (BM_ELEM_API_FLAG_TEST(l, BM_LNORSPACE_UPDATE) ||
bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL) {
short(*clnor)[2] = BM_ELEM_CD_GET_VOID_P(l, cd_loop_clnors_offset);
short(*clnor)[2] = static_cast<short(*)[2]>(
BM_ELEM_CD_GET_VOID_P(l, cd_loop_clnors_offset));
int l_index = BM_elem_index_get(l);
BKE_lnor_space_custom_data_to_normal(
@ -1851,14 +1857,14 @@ void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
BKE_lnor_spacearr_clear(bm->lnor_spacearr);
}
BM_loops_calc_normal_vcos(bm,
NULL,
NULL,
NULL,
nullptr,
nullptr,
nullptr,
true,
M_PI,
r_lnors,
bm->lnor_spacearr,
NULL,
nullptr,
cd_loop_clnors_offset,
true);
MEM_freeN(r_lnors);
@ -1868,7 +1874,8 @@ void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
if (BM_ELEM_API_FLAG_TEST(l, BM_LNORSPACE_UPDATE) ||
bm->spacearr_dirty & BM_SPACEARR_DIRTY_ALL) {
if (preserve_clnor) {
short(*clnor)[2] = BM_ELEM_CD_GET_VOID_P(l, cd_loop_clnors_offset);
short(*clnor)[2] = static_cast<short(*)[2]>(
BM_ELEM_CD_GET_VOID_P(l, cd_loop_clnors_offset));
int l_index = BM_elem_index_get(l);
BKE_lnor_space_custom_normal_to_data(
bm->lnor_spacearr->lspacearr[l_index], oldnors[l_index], *clnor);
@ -1888,11 +1895,12 @@ void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
void BM_lnorspace_update(BMesh *bm)
{
if (bm->lnor_spacearr == NULL) {
bm->lnor_spacearr = MEM_callocN(sizeof(*bm->lnor_spacearr), __func__);
if (bm->lnor_spacearr == nullptr) {
bm->lnor_spacearr = MEM_cnew<MLoopNorSpaceArray>(__func__);
}
if (bm->lnor_spacearr->lspacearr == NULL) {
float(*lnors)[3] = MEM_callocN(sizeof(*lnors) * bm->totloop, __func__);
if (bm->lnor_spacearr->lspacearr == nullptr) {
float(*lnors)[3] = static_cast<float(*)[3]>(
MEM_callocN(sizeof(*lnors) * bm->totloop, __func__));
BM_lnorspacearr_store(bm, lnors);
@ -1922,15 +1930,24 @@ void BM_lnorspace_err(BMesh *bm)
bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL;
bool clear = true;
MLoopNorSpaceArray *temp = MEM_callocN(sizeof(*temp), __func__);
temp->lspacearr = NULL;
MLoopNorSpaceArray *temp = MEM_cnew<MLoopNorSpaceArray>(__func__);
temp->lspacearr = nullptr;
BKE_lnor_spacearr_init(temp, bm->totloop, MLNOR_SPACEARR_BMLOOP_PTR);
int cd_loop_clnors_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
float(*lnors)[3] = MEM_callocN(sizeof(*lnors) * bm->totloop, __func__);
BM_loops_calc_normal_vcos(
bm, NULL, NULL, NULL, true, M_PI, lnors, temp, NULL, cd_loop_clnors_offset, true);
float(*lnors)[3] = static_cast<float(*)[3]>(MEM_callocN(sizeof(*lnors) * bm->totloop, __func__));
BM_loops_calc_normal_vcos(bm,
nullptr,
nullptr,
nullptr,
true,
M_PI,
lnors,
temp,
nullptr,
cd_loop_clnors_offset,
true);
for (int i = 0; i < bm->totloop; i++) {
int j = 0;
@ -1965,7 +1982,7 @@ static void bm_loop_normal_mark_indiv_do_loop(BMLoop *l,
int *totloopsel,
const bool do_all_loops_of_vert)
{
if (l != NULL) {
if (l != nullptr) {
const int l_idx = BM_elem_index_get(l);
if (!BLI_BITMAP_TEST(loops, l_idx)) {
@ -2016,7 +2033,7 @@ static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops, const bool do
BM_mesh_elem_index_ensure(bm, BM_LOOP);
BLI_assert(bm->lnor_spacearr != NULL);
BLI_assert(bm->lnor_spacearr != nullptr);
BLI_assert(bm->lnor_spacearr->data_type == MLNOR_SPACEARR_BMLOOP_PTR);
if (use_sel_face_history) {
@ -2025,7 +2042,7 @@ static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops, const bool do
* but it is not designed to be used with huge selection sets,
* rather with only a few items selected at most. */
/* Goes from last selected to the first selected element. */
for (ese = bm->selected.last; ese; ese = ese->prev) {
for (ese = static_cast<BMEditSelection *>(bm->selected.last); ese; ese = ese->prev) {
if (ese->htype == BM_FACE) {
/* If current face is selected,
* then any verts to be edited must have been selected before it. */
@ -2118,11 +2135,11 @@ static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops, const bool do
static void loop_normal_editdata_init(
BMesh *bm, BMLoopNorEditData *lnor_ed, BMVert *v, BMLoop *l, const int offset)
{
BLI_assert(bm->lnor_spacearr != NULL);
BLI_assert(bm->lnor_spacearr->lspacearr != NULL);
BLI_assert(bm->lnor_spacearr != nullptr);
BLI_assert(bm->lnor_spacearr->lspacearr != nullptr);
const int l_index = BM_elem_index_get(l);
short *clnors_data = BM_ELEM_CD_GET_VOID_P(l, offset);
short *clnors_data = static_cast<short *>(BM_ELEM_CD_GET_VOID_P(l, offset));
lnor_ed->loop_index = l_index;
lnor_ed->loop = l;
@ -2149,9 +2166,8 @@ BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm,
BLI_assert(bm->spacearr_dirty == 0);
BMLoopNorEditDataArray *lnors_ed_arr = MEM_callocN(sizeof(*lnors_ed_arr), __func__);
lnors_ed_arr->lidx_to_lnor_editdata = MEM_callocN(
sizeof(*lnors_ed_arr->lidx_to_lnor_editdata) * bm->totloop, __func__);
BMLoopNorEditDataArray *lnors_ed_arr = MEM_cnew<BMLoopNorEditDataArray>(__func__);
lnors_ed_arr->lidx_to_lnor_editdata = MEM_cnew_array<BMLoopNorEditData *>(bm->totloop, __func__);
if (!CustomData_has_layer(&bm->ldata, CD_CUSTOMLOOPNORMAL)) {
BM_data_layer_add(bm, &bm->ldata, CD_CUSTOMLOOPNORMAL);
@ -2166,8 +2182,8 @@ BMLoopNorEditDataArray *BM_loop_normal_editdata_array_init(BMesh *bm,
totloopsel = bm_loop_normal_mark_indiv(bm, loops, do_all_loops_of_vert);
if (totloopsel) {
BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata = MEM_mallocN(
sizeof(*lnor_ed) * totloopsel, __func__);
BMLoopNorEditData *lnor_ed = lnors_ed_arr->lnor_editdata = static_cast<BMLoopNorEditData *>(
MEM_mallocN(sizeof(*lnor_ed) * totloopsel, __func__));
BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) {
BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
@ -2224,8 +2240,9 @@ bool BM_custom_loop_normals_to_vector_layer(BMesh *bm)
int l_index = 0;
BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
const short *clnors_data = BM_ELEM_CD_GET_VOID_P(l, cd_custom_normal_offset);
float *normal = BM_ELEM_CD_GET_VOID_P(l, cd_normal_offset);
const short *clnors_data = static_cast<const short *>(
BM_ELEM_CD_GET_VOID_P(l, cd_custom_normal_offset));
float *normal = static_cast<float *>(BM_ELEM_CD_GET_VOID_P(l, cd_normal_offset));
BKE_lnor_space_custom_data_to_normal(
bm->lnor_spacearr->lspacearr[l_index], clnors_data, normal);
@ -2246,17 +2263,17 @@ void BM_custom_loop_normals_from_vector_layer(BMesh *bm, bool add_sharp_edges)
const int cd_custom_normal_offset = CustomData_get_offset(&bm->ldata, CD_CUSTOMLOOPNORMAL);
const int cd_normal_offset = CustomData_get_offset(&bm->ldata, CD_NORMAL);
if (bm->lnor_spacearr == NULL) {
bm->lnor_spacearr = MEM_callocN(sizeof(*bm->lnor_spacearr), __func__);
if (bm->lnor_spacearr == nullptr) {
bm->lnor_spacearr = MEM_cnew<MLoopNorSpaceArray>(__func__);
}
bm_mesh_loops_custom_normals_set(bm,
NULL,
NULL,
nullptr,
nullptr,
bm->lnor_spacearr,
NULL,
nullptr,
cd_custom_normal_offset,
NULL,
nullptr,
cd_normal_offset,
add_sharp_edges);

4
source/blender/modifiers/CMakeLists.txt
View File

@ -45,7 +45,7 @@ set(SRC
intern/MOD_curve.c
intern/MOD_datatransfer.cc
intern/MOD_decimate.c
intern/MOD_displace.c
intern/MOD_displace.cc
intern/MOD_dynamicpaint.c
intern/MOD_edgesplit.c
intern/MOD_explode.c
@ -84,7 +84,7 @@ set(SRC
intern/MOD_subsurf.cc
intern/MOD_surface.c
intern/MOD_surfacedeform.c
intern/MOD_triangulate.c
intern/MOD_triangulate.cc
intern/MOD_ui_common.c
intern/MOD_util.cc
intern/MOD_uvproject.cc

71
source/blender/modifiers/intern/MOD_displace.c → source/blender/modifiers/intern/MOD_displace.cc
View File

@ -126,10 +126,10 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
need_transform_relation = true;
}
if (dmd->texture != NULL) {
if (dmd->texture != nullptr) {
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(
ctx->node, dmd->map_object, dmd->map_bone, "Displace Modifier");
need_transform_relation = true;
@ -273,11 +273,11 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
int defgrp_index;
float(*tex_co)[3];
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}};
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;
}
if (dmd->strength == 0.0f) {
@ -287,20 +287,21 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
mvert = BKE_mesh_verts_for_write(mesh);
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. */
return;
}
Tex *tex_target = dmd->texture;
if (tex_target != NULL) {
tex_co = MEM_calloc_arrayN((size_t)verts_num, sizeof(*tex_co), "displaceModifier_do tex_co");
if (tex_target != nullptr) {
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_init_texture((MappingInfoModifierData *)dmd, ctx);
}
else {
tex_co = NULL;
tex_co = nullptr;
}
if (direction == MOD_DISP_DIR_CLNOR) {
@ -311,8 +312,9 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
BKE_mesh_calc_normals_split(mesh);
}
float(*clnors)[3] = CustomData_get_layer(ldata, CD_NORMAL);
vert_clnors = MEM_malloc_arrayN(verts_num, sizeof(*vert_clnors), __func__);
float(*clnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(ldata, CD_NORMAL));
vert_clnors = static_cast<float(*)[3]>(
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);
}
@ -325,7 +327,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
copy_m4_m4(local_mat, ob->object_to_world);
}
DisplaceUserdata data = {NULL};
DisplaceUserdata data = {nullptr};
data.scene = DEG_get_evaluated_scene(ctx->depsgraph);
data.dmd = dmd;
data.dvert = dvert;
@ -342,7 +344,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
data.vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
}
data.vert_clnors = vert_clnors;
if (tex_target != NULL) {
if (tex_target != nullptr) {
data.pool = BKE_image_pool_new();
BKE_texture_fetch_images_for_pool(tex_target, data.pool);
}
@ -351,7 +353,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
settings.use_threading = (verts_num > 512);
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);
}
@ -370,12 +372,12 @@ static void deformVerts(ModifierData *md,
float (*vertexCos)[3],
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);
if (!ELEM(mesh_src, NULL, mesh)) {
BKE_id_free(NULL, mesh_src);
if (!ELEM(mesh_src, nullptr, mesh)) {
BKE_id_free(nullptr, mesh_src);
}
}
@ -386,17 +388,18 @@ static void deformVertsEM(ModifierData *md,
float (*vertexCos)[3],
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). */
if (mesh_src != NULL) {
if (mesh_src != nullptr) {
BKE_mesh_wrapper_ensure_mdata(mesh_src);
}
displaceModifier_do((DisplaceModifierData *)md, ctx, mesh_src, vertexCos, verts_num);
if (!ELEM(mesh_src, NULL, mesh)) {
BKE_id_free(NULL, mesh_src);
if (!ELEM(mesh_src, nullptr, mesh)) {
BKE_id_free(nullptr, mesh_src);
}
}
@ -416,7 +419,7 @@ static void panel_draw(const bContext *C, Panel *panel)
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);
uiLayoutSetActive(col, has_texture);
@ -437,7 +440,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) {
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);
@ -449,16 +452,16 @@ static void panel_draw(const bContext *C, Panel *panel)
MOD_DISP_DIR_Y,
MOD_DISP_DIR_Z,
MOD_DISP_DIR_RGB_XYZ)) {
uiItemR(col, ptr, "space", 0, NULL, ICON_NONE);
uiItemR(col, ptr, "space", 0, nullptr, ICON_NONE);
}
uiItemS(layout);
col = uiLayoutColumn(layout, false);
uiItemR(col, ptr, "strength", 0, NULL, ICON_NONE);
uiItemR(col, ptr, "mid_level", 0, NULL, ICON_NONE);
uiItemR(col, ptr, "strength", 0, nullptr, 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);
}
@ -480,23 +483,23 @@ ModifierTypeInfo modifierType_Displace = {
/* copyData */ BKE_modifier_copydata_generic,
/* deformVerts */ deformVerts,
/* deformMatrices */ NULL,
/* deformMatrices */ nullptr,
/* deformVertsEM */ deformVertsEM,
/* deformMatricesEM */ NULL,
/* modifyMesh */ NULL,
/* modifyGeometrySet */ NULL,
/* deformMatricesEM */ nullptr,
/* modifyMesh */ nullptr,
/* modifyGeometrySet */ nullptr,
/* initData */ initData,
/* requiredDataMask */ requiredDataMask,
/* freeData */ NULL,
/* freeData */ nullptr,
/* isDisabled */ isDisabled,
/* updateDepsgraph */ updateDepsgraph,
/* dependsOnTime */ dependsOnTime,
/* dependsOnNormals */ dependsOnNormals,
/* foreachIDLink */ foreachIDLink,
/* foreachTexLink */ foreachTexLink,
/* freeRuntimeData */ NULL,
/* freeRuntimeData */ nullptr,
/* panelRegister */ panelRegister,
/* blendWrite */ NULL,
/* blendRead */ NULL,
/* blendWrite */ nullptr,
/* blendRead */ nullptr,
};

67
source/blender/modifiers/intern/MOD_triangulate.c → source/blender/modifiers/intern/MOD_triangulate.cc
View File

@ -45,8 +45,10 @@ static Mesh *triangulate_mesh(Mesh *mesh,
BMesh *bm;
int edges_num, i;
MEdge *me;
CustomData_MeshMasks cd_mask_extra = {
.vmask = CD_MASK_ORIGINDEX, .emask = CD_MASK_ORIGINDEX, .pmask = CD_MASK_ORIGINDEX};
CustomData_MeshMasks cd_mask_extra{};
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;
@ -57,22 +59,23 @@ static Mesh *triangulate_mesh(Mesh *mesh,
cd_mask_extra.lmask |= CD_MASK_NORMAL;
}
bm = BKE_mesh_to_bmesh_ex(mesh,
&((struct BMeshCreateParams){0}),
&((struct BMeshFromMeshParams){
.calc_face_normal = true,
.calc_vert_normal = false,
.cd_mask_extra = cd_mask_extra,
}));
BMeshCreateParams bmesh_create_params{};
BMeshFromMeshParams bmesh_from_mesh_params{};
bmesh_from_mesh_params.calc_face_normal = true;
bmesh_from_mesh_params.calc_vert_normal = false;
bmesh_from_mesh_params.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);
BM_mesh_free(bm);
if (keep_clnors) {
float(*lnors)[3] = CustomData_get_layer(&result->ldata, CD_NORMAL);
BLI_assert(lnors != NULL);
float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&result->ldata, CD_NORMAL));
BLI_assert(lnors != nullptr);
BKE_mesh_set_custom_normals(result, lnors);
@ -125,10 +128,10 @@ static void panel_draw(const bContext *UNUSED(C), Panel *panel)
uiLayoutSetPropSep(layout, true);
uiItemR(layout, ptr, "quad_method", 0, NULL, ICON_NONE);
uiItemR(layout, ptr, "ngon_method", 0, NULL, ICON_NONE);
uiItemR(layout, ptr, "min_vertices", 0, NULL, ICON_NONE);
uiItemR(layout, ptr, "keep_custom_normals", 0, NULL, ICON_NONE);
uiItemR(layout, ptr, "quad_method", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "ngon_method", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "min_vertices", 0, nullptr, ICON_NONE);
uiItemR(layout, ptr, "keep_custom_normals", 0, nullptr, ICON_NONE);
modifier_panel_end(layout, ptr);
}
@ -151,24 +154,24 @@ ModifierTypeInfo modifierType_Triangulate = {
/* copyData */ BKE_modifier_copydata_generic,
/* deformVerts */ NULL,
/* deformMatrices */ NULL,
/* deformVertsEM */ NULL,
/* deformMatricesEM */ NULL,
/* deformVerts */ nullptr,
/* deformMatrices */ nullptr,
/* deformVertsEM */ nullptr,
/* deformMatricesEM */ nullptr,
/* modifyMesh */ modifyMesh,
/* modifyGeometrySet */ NULL,
/* modifyGeometrySet */ nullptr,
/* initData */ initData,
/* requiredDataMask */ NULL, // requiredDataMask,
/* freeData */ NULL,
/* isDisabled */ NULL,
/* updateDepsgraph */ NULL,
/* dependsOnTime */ NULL,
/* dependsOnNormals */ NULL,
/* foreachIDLink */ NULL,
/* foreachTexLink */ NULL,
/* freeRuntimeData */ NULL,
/* requiredDataMask */ nullptr, // requiredDataMask,
/* freeData */ nullptr,
/* isDisabled */ nullptr,
/* updateDepsgraph */ nullptr,
/* dependsOnTime */ nullptr,
/* dependsOnNormals */ nullptr,
/* foreachIDLink */ nullptr,
/* foreachTexLink */ nullptr,
/* freeRuntimeData */ nullptr,
/* panelRegister */ panelRegister,
/* blendWrite */ NULL,
/* blendRead */ NULL,
/* blendWrite */ nullptr,
/* blendRead */ nullptr,
};

4
source/blender/render/CMakeLists.txt
View File

@ -26,10 +26,10 @@ set(INC
set(SRC
intern/bake.c
intern/bake.cc
intern/engine.cc
intern/initrender.cc
intern/multires_bake.c
intern/multires_bake.cc
intern/pipeline.cc
intern/render_result.cc
intern/texture_image.c

65
source/blender/render/intern/bake.c → source/blender/render/intern/bake.cc
View File

@ -336,7 +336,8 @@ static bool cast_ray_highpoly(BVHTreeFromMesh *treeData,
}
BVHTreeRayHit *hits;
hits = MEM_mallocN(sizeof(BVHTreeRayHit) * tot_highpoly, "Bake Highpoly to Lowpoly: BVH Rays");
hits = static_cast<BVHTreeRayHit *>(
MEM_mallocN(sizeof(BVHTreeRayHit) * tot_highpoly, "Bake Highpoly to Lowpoly: BVH Rays"));
for (i = 0; i < tot_highpoly; i++) {
float co_high[3], dir_high[3];
@ -463,15 +464,15 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
const MPoly *polys = BKE_mesh_polys(me);
const MLoop *loops = BKE_mesh_loops(me);
looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__);
triangles = MEM_callocN(sizeof(TriTessFace) * tottri, __func__);
looptri = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__));
triangles = static_cast<TriTessFace *>(MEM_callocN(sizeof(TriTessFace) * tottri, __func__));
const float(*precomputed_normals)[3] = BKE_mesh_poly_normals_are_dirty(me) ?
NULL :
nullptr :
BKE_mesh_poly_normals_ensure(me);
const bool calculate_normal = precomputed_normals ? false : true;
if (precomputed_normals != NULL) {
if (precomputed_normals != nullptr) {
BKE_mesh_recalc_looptri_with_normals(
loops, polys, verts, me->totloop, me->totpoly, looptri, precomputed_normals);
}
@ -479,17 +480,18 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
BKE_mesh_recalc_looptri(loops, polys, verts, me->totloop, me->totpoly, looptri);
}
const TSpace *tspace = NULL;
const float(*loop_normals)[3] = NULL;
const TSpace *tspace = nullptr;
const float(*loop_normals)[3] = nullptr;
if (tangent) {
BKE_mesh_ensure_normals_for_display(me_eval);
BKE_mesh_calc_normals_split(me_eval);
BKE_mesh_calc_loop_tangents(me_eval, true, NULL, 0);
BKE_mesh_calc_loop_tangents(me_eval, true, nullptr, 0);
tspace = CustomData_get_layer(&me_eval->ldata, CD_TANGENT);
tspace = static_cast<const TSpace *>(CustomData_get_layer(&me_eval->ldata, CD_TANGENT));
BLI_assert(tspace);
loop_normals = CustomData_get_layer(&me_eval->ldata, CD_NORMAL);
loop_normals = static_cast<const float(*)[3]>(
CustomData_get_layer(&me_eval->ldata, CD_NORMAL));
}
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(me);
@ -551,41 +553,42 @@ bool RE_bake_pixels_populate_from_objects(struct Mesh *me_low,
int primitive_id;
float u, v;
float imat_low[4][4];
bool is_cage = me_cage != NULL;
bool is_cage = me_cage != nullptr;
bool result = true;
Mesh *me_eval_low = NULL;
Mesh *me_eval_low = nullptr;
Mesh **me_highpoly;
BVHTreeFromMesh *treeData;
/* NOTE: all coordinates are in local space. */
TriTessFace *tris_low = NULL;
TriTessFace *tris_cage = NULL;
TriTessFace *tris_low = nullptr;
TriTessFace *tris_cage = nullptr;
TriTessFace **tris_high;
/* Assume all low-poly tessfaces can be quads. */
tris_high = MEM_callocN(sizeof(TriTessFace *) * tot_highpoly, "MVerts Highpoly Mesh Array");
tris_high = MEM_cnew_array<TriTessFace *>(tot_highpoly, "MVerts Highpoly Mesh Array");
/* Assume all high-poly tessfaces are triangles. */
me_highpoly = MEM_mallocN(sizeof(Mesh *) * tot_highpoly, "Highpoly Derived Meshes");
treeData = MEM_callocN(sizeof(BVHTreeFromMesh) * tot_highpoly, "Highpoly BVH Trees");
me_highpoly = static_cast<Mesh **>(
MEM_mallocN(sizeof(Mesh *) * tot_highpoly, "Highpoly Derived Meshes"));
treeData = MEM_cnew_array<BVHTreeFromMesh>(tot_highpoly, "Highpoly BVH Trees");
if (!is_cage) {
me_eval_low = BKE_mesh_copy_for_eval(me_low, false);
tris_low = mesh_calc_tri_tessface(me_low, true, me_eval_low);
}
else if (is_custom_cage) {
tris_low = mesh_calc_tri_tessface(me_low, false, NULL);
tris_cage = mesh_calc_tri_tessface(me_cage, false, NULL);
tris_low = mesh_calc_tri_tessface(me_low, false, nullptr);
tris_cage = mesh_calc_tri_tessface(me_cage, false, nullptr);
}
else {
tris_cage = mesh_calc_tri_tessface(me_cage, false, NULL);
tris_cage = mesh_calc_tri_tessface(me_cage, false, nullptr);
}
invert_m4_m4(imat_low, mat_low);
for (i = 0; i < tot_highpoly; i++) {
tris_high[i] = mesh_calc_tri_tessface(highpoly[i].me, false, NULL);
tris_high[i] = mesh_calc_tri_tessface(highpoly[i].me, false, nullptr);
me_highpoly[i] = highpoly[i].me;
BKE_mesh_runtime_looptri_ensure(me_highpoly[i]);
@ -594,7 +597,7 @@ bool RE_bake_pixels_populate_from_objects(struct Mesh *me_low,
/* Create a BVH-tree for each `highpoly` object. */
BKE_bvhtree_from_mesh_get(&treeData[i], me_highpoly[i], BVHTREE_FROM_LOOPTRI, 2);
if (treeData[i].tree == NULL) {
if (treeData[i].tree == nullptr) {
printf("Baking: out of memory while creating BHVTree for object \"%s\"\n",
highpoly[i].ob->id.name + 2);
result = false;
@ -668,7 +671,7 @@ cleanup:
MEM_freeN(me_highpoly);
if (me_eval_low) {
BKE_id_free(NULL, me_eval_low);
BKE_id_free(nullptr, me_eval_low);
}
if (tris_low) {
MEM_freeN(tris_low);
@ -712,21 +715,21 @@ void RE_bake_pixels_populate(Mesh *me,
const char *uv_layer)
{
const MLoopUV *mloopuv;
if ((uv_layer == NULL) || (uv_layer[0] == '\0')) {
mloopuv = CustomData_get_layer(&me->ldata, CD_MLOOPUV);
if ((uv_layer == nullptr) || (uv_layer[0] == '\0')) {
mloopuv = static_cast<const MLoopUV *>(CustomData_get_layer(&me->ldata, CD_MLOOPUV));
}
else {
int uv_id = CustomData_get_named_layer(&me->ldata, CD_MLOOPUV, uv_layer);
mloopuv = CustomData_get_layer_n(&me->ldata, CD_MLOOPUV, uv_id);
mloopuv = static_cast<const MLoopUV *>(CustomData_get_layer_n(&me->ldata, CD_MLOOPUV, uv_id));
}
if (mloopuv == NULL) {
if (mloopuv == nullptr) {
return;
}
BakeDataZSpan bd;
bd.pixel_array = pixel_array;
bd.zspan = MEM_callocN(sizeof(ZSpan) * targets->images_num, "bake zspan");
bd.zspan = MEM_cnew_array<ZSpan>(targets->images_num, "bake zspan");
/* initialize all pixel arrays so we know which ones are 'blank' */
for (int i = 0; i < pixels_num; i++) {
@ -739,7 +742,7 @@ void RE_bake_pixels_populate(Mesh *me,
}
const int tottri = poly_to_tri_count(me->totpoly, me->totloop);
MLoopTri *looptri = MEM_mallocN(sizeof(*looptri) * tottri, __func__);
MLoopTri *looptri = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__));
const MVert *verts = BKE_mesh_verts(me);
const MPoly *polys = BKE_mesh_polys(me);
@ -957,7 +960,7 @@ void RE_bake_normal_world_to_tangent(const BakePixel pixel_array[],
MEM_freeN(triangles);
if (me_eval) {
BKE_id_free(NULL, me_eval);
BKE_id_free(nullptr, me_eval);
}
}
@ -1027,7 +1030,7 @@ void RE_bake_ibuf_clear(Image *image, const bool is_tangent)
const float nor_alpha[4] = {0.5f, 0.5f, 1.0f, 0.0f};
const float nor_solid[4] = {0.5f, 0.5f, 1.0f, 1.0f};
ibuf = BKE_image_acquire_ibuf(image, NULL, &lock);
ibuf = BKE_image_acquire_ibuf(image, nullptr, &lock);
BLI_assert(ibuf);
if (is_tangent) {

79
source/blender/render/intern/multires_bake.c → source/blender/render/intern/multires_bake.cc
View File

@ -383,14 +383,14 @@ static void *do_multires_bake_thread(void *data_v)
while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) {
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;
if (multiresbake_test_break(bkr)) {
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) {
continue;
}
@ -427,7 +427,7 @@ static void *do_multires_bake_thread(void *data_v)
BLI_spin_unlock(&handle->queue->spin);
}
return NULL;
return nullptr;
}
/* some of arrays inside ccgdm are lazy-initialized, which will generally
@ -475,13 +475,13 @@ static void do_multires_bake(MultiresBakeRender *bkr,
MVert *mvert = dm->getVertArray(dm);
MPoly *mpoly = dm->getPolyArray(dm);
MLoop *mloop = dm->getLoopArray(dm);
MLoopUV *mloopuv = dm->getLoopDataArray(dm, CD_MLOOPUV);
float *pvtangent = NULL;
MLoopUV *mloopuv = static_cast<MLoopUV *>(dm->getLoopDataArray(dm, CD_MLOOPUV));
float *pvtangent = nullptr;
ListBase threads;
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(
dm->getNumVerts(dm), dm->getNumEdges(dm), 0, dm->getNumLoops(dm), dm->getNumPolys(dm));
@ -511,19 +511,19 @@ static void do_multires_bake(MultiresBakeRender *bkr,
dm->getNumLoopTri(dm),
&dm->loopData,
true,
NULL,
nullptr,
0,
vert_normals,
poly_normals,
(const float(*)[3])dm->getLoopDataArray(dm, CD_NORMAL),
(const float(*)[3])dm->getVertDataArray(dm, CD_ORCO), /* may be nullptr */
(const float(*)[3])dm->getVertDataArray(dm, CD_ORCO), /* may be nullptrptr */
/* result */
&dm->loopData,
dm->getNumLoops(dm),
&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 */
@ -535,7 +535,7 @@ static void do_multires_bake(MultiresBakeRender *bkr,
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);
@ -553,8 +553,8 @@ static void do_multires_bake(MultiresBakeRender *bkr,
handle->queue = &queue;
handle->data.mpoly = mpoly;
handle->data.material_indices = CustomData_get_layer_named(
&dm->polyData, CD_PROP_INT32, "material_index");
handle->data.material_indices = static_cast<const int *>(
CustomData_get_layer_named(&dm->polyData, CD_PROP_INT32, "material_index"));
handle->data.mvert = mvert;
handle->data.vert_normals = vert_normals;
handle->data.mloopuv = mloopuv;
@ -609,7 +609,7 @@ static void do_multires_bake(MultiresBakeRender *bkr,
MEM_freeN(handles);
BKE_id_free(NULL, temp_mesh);
BKE_id_free(nullptr, temp_mesh);
}
/* mode = 0: interpolate normals,
@ -704,11 +704,11 @@ static void get_ccgdm_data(DerivedMesh *lodm,
CLAMP(crn_x, 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);
}
if (co != NULL) {
if (co != nullptr) {
interp_bilinear_grid(&key, grid_data[g_index + S], crn_x, crn_y, 1, co);
}
}
@ -772,19 +772,19 @@ static void *init_heights_data(MultiresBakeRender *bkr, ImBuf *ibuf)
{
MHeightBakeData *height_data;
DerivedMesh *lodm = bkr->lores_dm;
BakeImBufuserData *userdata = ibuf->userdata;
BakeImBufuserData *userdata = static_cast<BakeImBufuserData *>(ibuf->userdata);
if (userdata->displacement_buffer == NULL) {
userdata->displacement_buffer = MEM_callocN(sizeof(float) * ibuf->x * ibuf->y,
"MultiresBake heights");
if (userdata->displacement_buffer == nullptr) {
userdata->displacement_buffer = MEM_cnew_array<float>(ibuf->x * ibuf->y,
"MultiresBake heights");
}
height_data = MEM_callocN(sizeof(MHeightBakeData), "MultiresBake heightData");
height_data = MEM_cnew<MHeightBakeData>("MultiresBake heightData");
height_data->heights = userdata->displacement_buffer;
if (!bkr->use_lores_mesh) {
SubsurfModifierData smd = {{NULL}};
SubsurfModifierData smd = {{nullptr}};
int ss_lvl = bkr->tot_lvl - bkr->lvl;
CLAMP(ss_lvl, 0, 6);
@ -795,12 +795,13 @@ static void *init_heights_data(MultiresBakeRender *bkr, ImBuf *ibuf)
smd.quality = 3;
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);
}
}
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;
}
@ -837,7 +838,7 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
MLoop *mloop = lores_dm->getLoopArray(lores_dm);
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;
MultiresBakeThread *thread_data = (MultiresBakeThread *)thread_data_v;
float uv[2], *st0, *st1, *st2, *st3;
@ -863,7 +864,7 @@ static void apply_heights_callback(DerivedMesh *lores_dm,
clamp_v2(uv, 0.0f, 1.0f);
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) {
get_ccgdm_data(lores_dm,
@ -914,9 +915,10 @@ static void *init_normal_data(MultiresBakeRender *bkr, ImBuf *UNUSED(ibuf))
MNormalBakeData *normal_data;
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;
}
@ -950,7 +952,7 @@ static void apply_tangmat_callback(DerivedMesh *lores_dm,
{
const MLoopTri *lt = lores_dm->getLoopTriArray(lores_dm) + tri_index;
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;
float uv[2], *st0, *st1, *st2, *st3;
int pixel = ibuf->x * y + x;
@ -975,7 +977,7 @@ static void apply_tangmat_callback(DerivedMesh *lores_dm,
clamp_v2(uv, 0.0f, 1.0f);
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);
normalize_v3_length(vec, 0.5);
@ -1435,7 +1437,7 @@ static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
{
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;
LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
@ -1443,12 +1445,11 @@ static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
BKE_imageuser_default(&iuser);
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) {
BakeImBufuserData *userdata = MEM_callocN(sizeof(BakeImBufuserData),
"MultiresBake userdata");
userdata->mask_buffer = MEM_callocN(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
BakeImBufuserData *userdata = MEM_cnew<BakeImBufuserData>("MultiresBake userdata");
userdata->mask_buffer = MEM_cnew_array<char>(ibuf->y * ibuf->x, "MultiresBake imbuf mask");
ibuf->userdata = userdata;
switch (bkr->mode) {
@ -1483,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;
@ -1495,7 +1496,7 @@ static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
LinkData *link;
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;
LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
@ -1503,7 +1504,7 @@ static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
BKE_imageuser_default(&iuser);
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;
if (ibuf->x <= 0 || ibuf->y <= 0) {
@ -1547,10 +1548,10 @@ static void finish_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
MEM_freeN(userdata->mask_buffer);
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);
}
}