blender
/
blender
133
398
Fork 579
Code Issues 6.3k Pull Requests 746 Projects 19 Wiki Activity

Mesh: Replace auto smooth with node group #108014

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

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

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

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

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

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

@ -1,3 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2014 Blender Foundation. All rights reserved. */
/** \file
* \ingroup bke
@ -269,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) {
@ -297,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);
}
}
@ -328,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... */
@ -362,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,
@ -420,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;
@ -485,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,
@ -506,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... */
@ -536,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 {
@ -579,9 +584,9 @@ 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__);
memset(data_dst_to_delete, true, sizeof(*data_dst_to_delete) * (size_t)tot_dst);
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));
}
}
@ -598,7 +603,7 @@ static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map
if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) {
if (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 {
@ -671,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))) {
@ -686,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),
@ -739,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),
@ -762,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),
@ -781,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),
@ -816,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) {
@ -873,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)) {
@ -955,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;
@ -973,7 +980,7 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
data_size,
data_offset,
data_flag,
NULL,
nullptr,
interp_data);
return true;
}
@ -1049,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;
@ -1067,7 +1074,7 @@ static bool data_transfer_layersmapping_generate(ListBase *r_map,
data_size,
data_offset,
data_flag,
NULL,
nullptr,
interp_data);
return true;
}
@ -1096,7 +1103,7 @@ void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph,
BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH));
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);
@ -1130,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,
@ -1139,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,
@ -1159,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,
@ -1179,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,
@ -1199,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);
}
}
}
@ -1246,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;
@ -1270,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);
}
@ -1287,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;
@ -1302,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;
}
@ -1384,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]);
}
@ -1407,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);
}
@ -1463,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]);
}
@ -1486,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);
}
@ -1558,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]);
}
@ -1581,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);
}
@ -1638,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,
@ -1668,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);
}
@ -1722,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,

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

@ -1763,43 +1763,6 @@ void BKE_mesh_vert_coords_apply_with_mat4(Mesh *mesh,
BKE_mesh_tag_coords_changed(mesh);
}
static void calc_normals_split(Mesh *mesh,
MLoopNorSpaceArray *r_lnors_spacearr,
float (*r_corner_normals)[3])
{
const float split_angle = (mesh->flag & ME_AUTOSMOOTH) != 0 ? mesh->smoothresh : float(M_PI);
/* may be nullptr */
short(*clnors)[2] = (short(*)[2])CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);
const Span<MVert> verts = mesh->verts();
const Span<MEdge> edges = mesh->edges();
const Span<MPoly> polys = mesh->polys();
const Span<MLoop> loops = mesh->loops();
BKE_mesh_normals_loop_split(verts.data(),
BKE_mesh_vertex_normals_ensure(mesh),
verts.size(),
edges.data(),
edges.size(),
loops.data(),
r_corner_normals,
loops.size(),
polys.data(),
BKE_mesh_poly_normals_ensure(mesh),
polys.size(),
true,
split_angle,
nullptr,
r_lnors_spacearr,
clnors);
}
void BKE_mesh_calc_normals_split(Mesh *mesh)
{
BKE_mesh_calc_normals_split_ex(mesh, nullptr, ensure_corner_normal_layer(*mesh));
}
/* **** Depsgraph evaluation **** */
void BKE_mesh_eval_geometry(Depsgraph *depsgraph, Mesh *mesh)

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

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

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

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

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

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

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

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

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

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

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

@ -126,10 +126,10 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
need_transform_relation = true;
}
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,34 +287,32 @@ 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) {
CustomData *ldata = &mesh->ldata;
if (CustomData_has_layer(ldata, CD_CUSTOMLOOPNORMAL)) {
if (!CustomData_has_layer(ldata, CD_NORMAL)) {
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__);
BKE_mesh_normals_loop_to_vertex(
verts_num, BKE_mesh_loops(mesh), mesh->totloop, (const float(*)[3])clnors, vert_clnors);
if (CustomData_has_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL)) {
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,
BKE_mesh_corner_normals_ensure(mesh),
vert_clnors);
}
else {
direction = MOD_DISP_DIR_NOR;
@ -325,7 +323,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 +340,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 +349,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 +368,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 +384,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 +415,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 +436,7 @@ static void panel_draw(const bContext *C, Panel *panel)
}
}
else if (texture_coords == MOD_DISP_MAP_UV && RNA_enum_get(&ob_ptr, "type") == OB_MESH) {
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 +448,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 +479,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,
};

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

@ -45,40 +45,39 @@ 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;
if (keep_clnors) {
BKE_mesh_calc_normals_split(mesh);
/* We need that one to 'survive' to/from BMesh conversions. */
CustomData_clear_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
cd_mask_extra.lmask |= CD_MASK_NORMAL;
CustomData_add_layer(&mesh->ldata,
CD_NORMAL,
CD_DUPLICATE,
const_cast<float(*)[3]>(BKE_mesh_corner_normals_ensure(mesh)),
mesh->totloop);
}
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));
BKE_mesh_set_custom_normals(result, lnors);
/* Do some cleanup, we do not want those temp data to stay around. */
CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
CustomData_set_layer_flag(&result->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);
CustomData_free_layers(&result->ldata, CD_NORMAL, result->totloop);
}
edges_num = result->totedge;
@ -125,10 +124,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 +150,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,
};

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

@ -1,3 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2012 Blender Foundation. All rights reserved. */
/** \file
* \ingroup render
@ -381,14 +383,14 @@ static void *do_multires_bake_thread(void *data_v)
while ((tri_index = multires_bake_queue_next_tri(handle->queue)) >= 0) {
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;
}
@ -418,14 +420,14 @@ static void *do_multires_bake_thread(void *data_v)
}
if (bkr->progress) {
*bkr->progress = ((float)bkr->baked_objects +
(float)bkr->baked_faces / handle->queue->tot_tri) /
*bkr->progress = (float(bkr->baked_objects) +
float(bkr->baked_faces) / handle->queue->tot_tri) /
bkr->tot_obj;
}
BLI_spin_unlock(&handle->queue->spin);
}
return NULL;
return nullptr;
}
/* some of arrays inside ccgdm are lazy-initialized, which will generally
@ -473,13 +475,13 @@ static void do_multires_bake(MultiresBakeRender *bkr,
MVert *mvert = dm->getVertArray(dm);
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));
@ -509,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 */
BKE_mesh_corner_normals_ensure(temp_mesh),
(const float(*)[3])dm->getVertDataArray(dm, CD_ORCO), /* May be nullptr. */
/* 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 */
@ -533,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);
@ -551,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;
@ -607,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,
@ -619,10 +621,10 @@ static void interp_bilinear_grid(
float u, v;
float data[4][3];
x0 = (int)crn_x;
x0 = int(crn_x);
x1 = x0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (x0 + 1);
y0 = (int)crn_y;
y0 = int(crn_y);
y1 = y0 >= (key->grid_size - 1) ? (key->grid_size - 1) : (y0 + 1);
u = crn_x - x0;
@ -702,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);
}
}
@ -770,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);
@ -793,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;
}
@ -835,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;
@ -861,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,
@ -912,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;
}
@ -948,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;
@ -973,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);
@ -1433,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) {
@ -1441,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) {
@ -1481,7 +1484,7 @@ static void bake_images(MultiresBakeRender *bkr, MultiresBakeResult *result)
}
}
BKE_image_release_ibuf(ima, ibuf, NULL);
BKE_image_release_ibuf(ima, ibuf, nullptr);
}
ima->id.tag |= LIB_TAG_DOIT;
@ -1493,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) {
@ -1501,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) {
@ -1545,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);
}
}