griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: modifiers: Replace 'void' MEM_[cm]allocN with templated, type-safe MEM_[cm]allocN<T>.

Browse Source 
The main issue of 'type-less' standard C allocations is that there is no check on
allocated type possible.

This is a serious source of annoyance (and crashes) when making some
low-level structs non-trivial, as tracking down all usages of these
structs in higher-level other structs and their allocation is... really
painful.

MEM_[cm]allocN<T> templates on the other hand do check that the
given type is trivial, at build time (static assert), which makes such issue...
trivial to catch.

NOTE: New code should strive to use MEM_new (i.e. allocation and
construction) as much as possible, even for trivial PoD types.
This commit is contained in:
Bastien Montagne
2025-03-12 14:03:26 +01:00
committed by Bastien Montagne
parent 3ff3c2bf21
commit 58d34984d2
31 changed files with 213 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -166,10 +166,10 @@ static void dm_mvert_map_doubles(int *doubles_map,
source_end = source_start + source_verts_num;
/* build array of MVerts to be tested for merging */
SortVertsElem *sorted_verts_target = static_cast<SortVertsElem *>(
MEM_malloc_arrayN(target_verts_num, sizeof(SortVertsElem), __func__));
SortVertsElem *sorted_verts_source = static_cast<SortVertsElem *>(
MEM_malloc_arrayN(source_verts_num, sizeof(SortVertsElem), __func__));
SortVertsElem *sorted_verts_target = MEM_malloc_arrayN<SortVertsElem>(size_t(target_verts_num),
__func__);
SortVertsElem *sorted_verts_source = MEM_malloc_arrayN<SortVertsElem>(size_t(source_verts_num),
__func__);
/* Copy target vertices index and cos into SortVertsElem array */
svert_from_mvert(sorted_verts_target, vert_positions, target_start, target_end);
@@ -567,7 +567,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
if (use_merge) {
/* Will need full_doubles_map for handling merge */
full_doubles_map = static_cast<int *>(MEM_malloc_arrayN(result_nverts, sizeof(int), __func__));
full_doubles_map = MEM_malloc_arrayN<int>(size_t(result_nverts), __func__);
copy_vn_i(full_doubles_map, result_nverts, -1);
}

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

@@ -490,7 +490,7 @@ static Mesh *exact_boolean_mesh(BooleanModifierData *bmd,
if (material_mode == eBooleanModifierMaterialMode_Transfer) {
MEM_SAFE_FREE(result->mat);
result->mat = (Material **)MEM_malloc_arrayN(materials.size(), sizeof(Material *), __func__);
result->mat = MEM_malloc_arrayN<Material *>(size_t(materials.size()), __func__);
result->totcol = materials.size();
MutableSpan(result->mat, result->totcol).copy_from(materials);
}

6
source/blender/modifiers/intern/MOD_build.cc
View File

@@ -70,9 +70,9 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
const blender::Span<int> corner_verts_src = mesh->corner_verts();
const blender::Span<int> corner_edges_src = mesh->corner_edges();
int *vertMap = static_cast<int *>(MEM_malloc_arrayN(vert_src_num, sizeof(int), __func__));
int *edgeMap = static_cast<int *>(MEM_malloc_arrayN(edges_src.size(), sizeof(int), __func__));
int *faceMap = static_cast<int *>(MEM_malloc_arrayN(faces_src.size(), sizeof(int), __func__));
int *vertMap = MEM_malloc_arrayN<int>(size_t(vert_src_num), __func__);
int *edgeMap = MEM_malloc_arrayN<int>(size_t(edges_src.size()), __func__);
int *faceMap = MEM_malloc_arrayN<int>(size_t(faces_src.size()), __func__);
range_vn_i(vertMap, vert_src_num, 0);
range_vn_i(edgeMap, edges_src.size(), 0);

12
source/blender/modifiers/intern/MOD_collision.cc
View File

@@ -124,8 +124,7 @@ static void deform_verts(ModifierData *md,
if (collmd->time_xnew == -1000) { /* first time */
mvert_num = mesh->verts_num;
collmd->x = static_cast<float(*)[3]>(
MEM_malloc_arrayN(mvert_num, sizeof(float[3]), __func__));
collmd->x = MEM_malloc_arrayN<float[3]>(size_t(mvert_num), __func__);
blender::MutableSpan(reinterpret_cast<blender::float3 *>(collmd->x), mvert_num)
.copy_from(mesh->vert_positions());
@@ -144,8 +143,7 @@ static void deform_verts(ModifierData *md,
{
const blender::Span<blender::int3> corner_tris = mesh->corner_tris();
collmd->tri_num = corner_tris.size();
int(*vert_tris)[3] = static_cast<int(*)[3]>(
MEM_malloc_arrayN(collmd->tri_num, sizeof(int[3]), __func__));
int(*vert_tris)[3] = MEM_malloc_arrayN<int[3]>(collmd->tri_num, __func__);
blender::bke::mesh::vert_tris_from_corner_tris(
mesh->corner_verts(),
corner_tris,
@@ -255,9 +253,9 @@ static void blend_read(BlendDataReader * /*reader*/, ModifierData *md)
collmd->xnew = newdataadr(fd, collmd->xnew);
collmd->mfaces = newdataadr(fd, collmd->mfaces);
collmd->current_x = MEM_calloc_arrayN(collmd->mvert_num, sizeof(float[3]), "current_x");
collmd->current_xnew = MEM_calloc_arrayN(collmd->mvert_num, sizeof(float[3]), "current_xnew");
collmd->current_v = MEM_calloc_arrayN(collmd->mvert_num, sizeof(float[3]), "current_v");
collmd->current_x = MEM_calloc_arrayN<float[3]>(collmd->mvert_num, "current_x");
collmd->current_xnew = MEM_calloc_arrayN<float[3]>(collmd->mvert_num, "current_xnew");
collmd->current_v = MEM_calloc_arrayN<float[3]>(collmd->mvert_num, "current_v");
#endif
collmd->x = nullptr;

33
source/blender/modifiers/intern/MOD_correctivesmooth.cc
View File

@@ -127,8 +127,7 @@ static void mesh_get_boundaries(Mesh *mesh, float *smooth_weights)
const blender::Span<int> corner_edges = mesh->corner_edges();
/* Flag boundary edges so only boundaries are set to 1. */
uint8_t *boundaries = static_cast<uint8_t *>(
MEM_calloc_arrayN(size_t(edges.size()), sizeof(*boundaries), __func__));
uint8_t *boundaries = MEM_calloc_arrayN<uint8_t>(size_t(edges.size()), __func__);
for (const int64_t i : faces.index_range()) {
for (const int edge : corner_edges.slice(faces[i])) {
@@ -170,8 +169,7 @@ static void smooth_iter__simple(CorrectiveSmoothModifierData *csmd,
SmoothingData_Simple *smooth_data = MEM_calloc_arrayN<SmoothingData_Simple>(
size_t(vertexCos.size()), __func__);
float *vertex_edge_count_div = static_cast<float *>(
MEM_calloc_arrayN(size_t(vertexCos.size()), sizeof(float), __func__));
float *vertex_edge_count_div = MEM_calloc_arrayN<float>(size_t(vertexCos.size()), __func__);
/* calculate as floats to avoid int->float conversion in #smooth_iter */
for (i = 0; i < edges_num; i++) {
@@ -251,8 +249,7 @@ static void smooth_iter__length_weight(CorrectiveSmoothModifierData *csmd,
size_t(vertexCos.size()), __func__);
/* calculate as floats to avoid int->float conversion in #smooth_iter */
float *vertex_edge_count = static_cast<float *>(
MEM_calloc_arrayN(size_t(vertexCos.size()), sizeof(float), __func__));
float *vertex_edge_count = MEM_calloc_arrayN<float>(size_t(vertexCos.size()), __func__);
for (i = 0; i < edges_num; i++) {
vertex_edge_count[edges[i][0]] += 1.0f;
vertex_edge_count[edges[i][1]] += 1.0f;
@@ -352,8 +349,7 @@ static void smooth_verts(CorrectiveSmoothModifierData *csmd,
if (dvert || (csmd->flag & MOD_CORRECTIVESMOOTH_PIN_BOUNDARY)) {
smooth_weights = static_cast<float *>(
MEM_malloc_arrayN(size_t(vertexCos.size()), sizeof(float), __func__));
smooth_weights = MEM_malloc_arrayN<float>(size_t(vertexCos.size()), __func__);
if (dvert) {
mesh_get_weights(dvert,
@@ -514,8 +510,8 @@ static void calc_deltas(CorrectiveSmoothModifierData *csmd,
uint l_index;
float(*tangent_spaces)[3][3] = static_cast<float(*)[3][3]>(
MEM_malloc_arrayN(size_t(corner_verts.size()), sizeof(float[3][3]), __func__));
float(*tangent_spaces)[3][3] = MEM_malloc_arrayN<float[3][3]>(size_t(corner_verts.size()),
__func__);
if (csmd->delta_cache.deltas_num != uint(corner_verts.size())) {
MEM_SAFE_FREE(csmd->delta_cache.deltas);
@@ -524,8 +520,7 @@ static void calc_deltas(CorrectiveSmoothModifierData *csmd,
/* allocate deltas if they have not yet been allocated, otherwise we will just write over them */
if (!csmd->delta_cache.deltas) {
csmd->delta_cache.deltas_num = uint(corner_verts.size());
csmd->delta_cache.deltas = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(corner_verts.size()), sizeof(float[3]), __func__));
csmd->delta_cache.deltas = MEM_malloc_arrayN<float[3]>(size_t(corner_verts.size()), __func__);
}
smooth_verts(csmd, mesh, dvert, defgrp_index, smooth_vertex_coords);
@@ -579,8 +574,7 @@ static void correctivesmooth_modifier_do(ModifierData *md,
{
if (DEG_is_active(depsgraph)) {
BLI_assert(csmd->bind_coords == nullptr);
csmd->bind_coords = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(vertexCos.size()), sizeof(float[3]), __func__));
csmd->bind_coords = MEM_malloc_arrayN<float[3]>(size_t(vertexCos.size()), __func__);
memcpy(csmd->bind_coords, vertexCos.data(), size_t(vertexCos.size_in_bytes()));
csmd->bind_coords_num = uint(vertexCos.size());
BLI_assert(csmd->bind_coords != nullptr);
@@ -691,12 +685,11 @@ static void correctivesmooth_modifier_do(ModifierData *md,
const float scale = csmd->scale;
float(*tangent_spaces)[3][3] = static_cast<float(*)[3][3]>(
MEM_malloc_arrayN(size_t(corner_verts.size()), sizeof(float[3][3]), __func__));
float *tangent_weights = static_cast<float *>(
MEM_malloc_arrayN(size_t(corner_verts.size()), sizeof(float), __func__));
float *tangent_weights_per_vertex = static_cast<float *>(
MEM_malloc_arrayN(size_t(vertexCos.size()), sizeof(float), __func__));
float(*tangent_spaces)[3][3] = MEM_malloc_arrayN<float[3][3]>(size_t(corner_verts.size()),
__func__);
float *tangent_weights = MEM_malloc_arrayN<float>(size_t(corner_verts.size()), __func__);
float *tangent_weights_per_vertex = MEM_malloc_arrayN<float>(size_t(vertexCos.size()),
__func__);
calc_tangent_spaces(
mesh, vertexCos, tangent_spaces, tangent_weights, tangent_weights_per_vertex);

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

@@ -142,7 +142,7 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
const uint vert_tot = mesh->verts_num;
uint i;
vweights = static_cast<float *>(MEM_malloc_arrayN(vert_tot, sizeof(float), __func__));
vweights = MEM_malloc_arrayN<float>(vert_tot, __func__);
if (dmd->flag & MOD_DECIM_FLAG_INVERT_VGROUP) {
for (i = 0; i < vert_tot; i++) {

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

@@ -277,8 +277,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
Tex *tex_target = dmd->texture;
if (tex_target != nullptr) {
tex_co = static_cast<float(*)[3]>(MEM_calloc_arrayN(
size_t(positions.size()), sizeof(*tex_co), "displaceModifier_do tex_co"));
tex_co = MEM_calloc_arrayN<float[3]>(size_t(positions.size()), "displaceModifier_do tex_co");
MOD_get_texture_coords((MappingInfoModifierData *)dmd,
ctx,
ob,
@@ -294,8 +293,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
if (direction == MOD_DISP_DIR_CLNOR) {
if (mesh->attributes().contains("custom_normal")) {
vert_clnors = static_cast<float(*)[3]>(
MEM_malloc_arrayN(positions.size(), sizeof(*vert_clnors), __func__));
vert_clnors = MEM_malloc_arrayN<float[3]>(size_t(positions.size()), __func__);
BKE_mesh_normals_loop_to_vertex(
positions.size(),
mesh->corner_verts().data(),

11
source/blender/modifiers/intern/MOD_explode.cc
View File

@@ -108,9 +108,9 @@ static void createFacepa(ExplodeModifierData *emd, ParticleSystemModifierData *p
if (emd->facepa) {
MEM_freeN(emd->facepa);
}
facepa = emd->facepa = static_cast<int *>(MEM_calloc_arrayN(totface, sizeof(int), __func__));
facepa = emd->facepa = MEM_calloc_arrayN<int>(size_t(totface), __func__);
vertpa = static_cast<int *>(MEM_calloc_arrayN(totvert, sizeof(int), __func__));
vertpa = MEM_calloc_arrayN<int>(size_t(totvert), __func__);
/* initialize all faces & verts to no particle */
for (i = 0; i < totface; i++) {
@@ -656,8 +656,8 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
int totvert = mesh->verts_num;
int totface = mesh->totface_legacy;
int *facesplit = static_cast<int *>(MEM_calloc_arrayN(totface, sizeof(int), __func__));
int *vertpa = static_cast<int *>(MEM_calloc_arrayN(totvert, sizeof(int), __func__));
int *facesplit = MEM_calloc_arrayN<int>(size_t(totface), __func__);
int *vertpa = MEM_calloc_arrayN<int>(size_t(totvert), __func__);
int *facepa = emd->facepa;
int *fs, totfsplit = 0, curdupface = 0;
int i, v1, v2, v3, v4, v[4] = {0, 0, 0, 0}, /* To quite gcc barking... */
@@ -746,8 +746,7 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
* later interpreted as triangles, for this to work right I think we probably
* have to stop using tessface. */
facepa = static_cast<int *>(
MEM_calloc_arrayN((totface + (totfsplit * 2)), sizeof(int), __func__));
facepa = MEM_calloc_arrayN<int>(size_t(totface) + (size_t(totfsplit) * 2), __func__);
// memcpy(facepa, emd->facepa, totface*sizeof(int));
emd->facepa = facepa;

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

@@ -477,8 +477,7 @@ static void panel_register(ARegionType *region_type)
{
modifier_panel_register(region_type, eModifierType_GreasePencilDash, panel_draw);
uiListType *list_type = static_cast<uiListType *>(
MEM_callocN(sizeof(uiListType), "Grease Pencil Dash modifier segments"));
uiListType *list_type = MEM_callocN<uiListType>("Grease Pencil Dash modifier segments");
STRNCPY(list_type->idname, "MOD_UL_grease_pencil_dash_modifier_segments");
list_type->draw_item = segment_list_item_draw;
WM_uilisttype_add(list_type);

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

@@ -638,8 +638,7 @@ static void panel_register(ARegionType *region_type)
{
modifier_panel_register(region_type, eModifierType_GreasePencilTime, panel_draw);
uiListType *list_type = static_cast<uiListType *>(
MEM_callocN(sizeof(uiListType), "Grease Pencil Time modifier segments"));
uiListType *list_type = MEM_callocN<uiListType>("Grease Pencil Time modifier segments");
STRNCPY(list_type->idname, "MOD_UL_grease_pencil_time_modifier_segments");
list_type->draw_item = segment_list_item_draw;
WM_uilisttype_add(list_type);

23
source/blender/modifiers/intern/MOD_laplaciandeform.cc
View File

@@ -125,12 +125,12 @@ static LaplacianSystem *initLaplacianSystem(int verts_num,
sys->anchors_num = anchors_num;
sys->repeat = iterations;
STRNCPY(sys->anchor_grp_name, defgrpName);
sys->co = static_cast<float(*)[3]>(MEM_malloc_arrayN(verts_num, sizeof(float[3]), __func__));
sys->no = static_cast<float(*)[3]>(MEM_calloc_arrayN(verts_num, sizeof(float[3]), __func__));
sys->delta = static_cast<float(*)[3]>(MEM_calloc_arrayN(verts_num, sizeof(float[3]), __func__));
sys->tris = static_cast<uint(*)[3]>(MEM_malloc_arrayN(tris_num, sizeof(int[3]), __func__));
sys->index_anchors = static_cast<int *>(MEM_malloc_arrayN((anchors_num), sizeof(int), __func__));
sys->unit_verts = static_cast<int *>(MEM_calloc_arrayN(verts_num, sizeof(int), __func__));
sys->co = MEM_malloc_arrayN<float[3]>(size_t(verts_num), __func__);
sys->no = MEM_calloc_arrayN<float[3]>(size_t(verts_num), __func__);
sys->delta = MEM_calloc_arrayN<float[3]>(size_t(verts_num), __func__);
sys->tris = MEM_malloc_arrayN<uint[3]>(size_t(tris_num), __func__);
sys->index_anchors = MEM_malloc_arrayN<int>(size_t(anchors_num), __func__);
sys->unit_verts = MEM_calloc_arrayN<int>(size_t(verts_num), __func__);
return sys;
}
@@ -543,8 +543,7 @@ static void initSystem(
const bool invert_vgroup = (lmd->flag & MOD_LAPLACIANDEFORM_INVERT_VGROUP) != 0;
if (isValidVertexGroup(lmd, ob, mesh)) {
int *index_anchors = static_cast<int *>(
MEM_malloc_arrayN(verts_num, sizeof(int), __func__)); /* Over-allocate. */
int *index_anchors = MEM_malloc_arrayN<int>(size_t(verts_num), __func__); /* Over-allocate. */
STACK_DECLARE(index_anchors);
@@ -577,7 +576,7 @@ static void initSystem(
memcpy(sys->index_anchors, index_anchors, sizeof(int) * anchors_num);
memcpy(sys->co, vertexCos, sizeof(float[3]) * verts_num);
MEM_freeN(index_anchors);
lmd->vertexco = static_cast<float *>(MEM_malloc_arrayN(verts_num, sizeof(float[3]), __func__));
lmd->vertexco = MEM_malloc_arrayN<float>(3 * size_t(verts_num), __func__);
memcpy(lmd->vertexco, vertexCos, sizeof(float[3]) * verts_num);
lmd->verts_num = verts_num;
@@ -658,8 +657,7 @@ static void LaplacianDeformModifier_do(
sys = static_cast<LaplacianSystem *>(lmd->cache_system);
if (sysdif) {
if (ELEM(sysdif, LAPDEFORM_SYSTEM_ONLY_CHANGE_ANCHORS, LAPDEFORM_SYSTEM_ONLY_CHANGE_GROUP)) {
filevertexCos = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(float[3]), __func__));
filevertexCos = MEM_malloc_arrayN<float[3]>(size_t(verts_num), __func__);
memcpy(filevertexCos, lmd->vertexco, sizeof(float[3]) * verts_num);
MEM_SAFE_FREE(lmd->vertexco);
lmd->verts_num = 0;
@@ -703,8 +701,7 @@ static void LaplacianDeformModifier_do(
lmd->flag &= ~MOD_LAPLACIANDEFORM_BIND;
}
else if (lmd->verts_num > 0 && lmd->verts_num == verts_num) {
filevertexCos = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(float[3]), "TempDeformCoordinates"));
filevertexCos = MEM_malloc_arrayN<float[3]>(size_t(verts_num), "TempDeformCoordinates");
memcpy(filevertexCos, lmd->vertexco, sizeof(float[3]) * verts_num);
MEM_SAFE_FREE(lmd->vertexco);
lmd->verts_num = 0;

6
source/blender/modifiers/intern/MOD_meshcache.cc
View File

@@ -81,8 +81,7 @@ static void meshcache_do(MeshCacheModifierData *mcmd,
float(*vertexCos_Store)[3] = (use_factor || influence_group_index != -1 ||
(mcmd->deform_mode == MOD_MESHCACHE_DEFORM_INTEGRATE)) ?
static_cast<float(*)[3]>(MEM_malloc_arrayN(
verts_num, sizeof(*vertexCos_Store), __func__)) :
MEM_malloc_arrayN<float[3]>(size_t(verts_num), __func__) :
nullptr;
float(*vertexCos)[3] = vertexCos_Store ? vertexCos_Store : vertexCos_Real;
@@ -173,8 +172,7 @@ static void meshcache_do(MeshCacheModifierData *mcmd,
BKE_modifier_set_error(ob, &mcmd->modifier, "'Integrate' requires faces");
}
else {
float(*vertexCos_New)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(*vertexCos_New), __func__));
float(*vertexCos_New)[3] = MEM_malloc_arrayN<float[3]>(size_t(verts_num), __func__);
BKE_mesh_calc_relative_deform(
mesh->face_offsets().data(),

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

@@ -464,9 +464,8 @@ void BKE_modifier_mdef_compact_influences(ModifierData *md)
}
/* allocate bind influences */
mmd->bindinfluences = static_cast<MDefInfluence *>(
MEM_calloc_arrayN(mmd->influences_num, sizeof(MDefInfluence), __func__));
mmd->bindoffsets = static_cast<int *>(MEM_calloc_arrayN((verts_num + 1), sizeof(int), __func__));
mmd->bindinfluences = MEM_calloc_arrayN<MDefInfluence>(size_t(mmd->influences_num), __func__);
mmd->bindoffsets = MEM_calloc_arrayN<int>(size_t(verts_num) + 1, __func__);
/* write influences */
influences_num = 0;

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

@@ -87,8 +87,7 @@ static MultiresRuntimeData *multires_ensure_runtime(MultiresModifierData *mmd)
{
MultiresRuntimeData *runtime_data = (MultiresRuntimeData *)mmd->modifier.runtime;
if (runtime_data == nullptr) {
runtime_data = static_cast<MultiresRuntimeData *>(
MEM_callocN(sizeof(*runtime_data), __func__));
runtime_data = MEM_callocN<MultiresRuntimeData>(__func__);
mmd->modifier.runtime = runtime_data;
}
return runtime_data;

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

@@ -134,8 +134,7 @@ static void mix_normals(const float mix_factor,
int i;
if (dvert) {
facs = static_cast<float *>(
MEM_malloc_arrayN(size_t(corner_verts.size()), sizeof(*facs), __func__));
facs = MEM_malloc_arrayN<float>(size_t(corner_verts.size()), __func__);
BKE_defvert_extract_vgroup_to_loopweights(dvert,
defgrp_index,
verts_num,
@@ -233,8 +232,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
const bool do_facenors_fix = (enmd->flag & MOD_NORMALEDIT_NO_POLYNORS_FIX) == 0;
float(*cos)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(vert_positions.size()), sizeof(*cos), __func__));
float(*cos)[3] = MEM_malloc_arrayN<float[3]>(size_t(vert_positions.size()), __func__);
blender::Array<blender::float3> nos(corner_verts.size());
float3 size;
@@ -384,8 +382,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
}
}
else {
float(*cos)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(positions.size()), sizeof(*cos), __func__));
float(*cos)[3] = MEM_malloc_arrayN<float[3]>(size_t(positions.size()), __func__);
generate_vert_coordinates(mesh, ob, ob_target, nullptr, positions.size(), cos, nullptr);
BLI_bitmap *done_verts = BLI_BITMAP_NEW(size_t(positions.size()), __func__);

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

@@ -244,7 +244,7 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
if (pimd->flag & eParticleInstanceFlag_UseSize) {
float *si;
si = size = static_cast<float *>(MEM_calloc_arrayN(part_end, sizeof(float), __func__));
si = size = MEM_calloc_arrayN<float>(part_end, __func__);
if (pimd->flag & eParticleInstanceFlag_Parents) {
for (p = 0, pa = psys->particles; p < psys->totpart; p++, pa++, si++) {

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

@@ -157,7 +157,7 @@ static Mesh *mesh_remove_doubles_on_axis(Mesh *result,
if (tot_doubles != 0) {
uint tot = totvert * step_tot;
int *full_doubles_map = static_cast<int *>(MEM_malloc_arrayN(tot, sizeof(int), __func__));
int *full_doubles_map = MEM_malloc_arrayN<int>(tot, __func__);
copy_vn_i(full_doubles_map, int(tot), -1);
uint tot_doubles_left = tot_doubles;
@@ -461,12 +461,10 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
/* build face -> edge map */
if (faces_num) {
edge_face_map = static_cast<uint *>(
MEM_malloc_arrayN(totedge, sizeof(*edge_face_map), __func__));
edge_face_map = MEM_malloc_arrayN<uint>(totedge, __func__);
memset(edge_face_map, 0xff, sizeof(*edge_face_map) * totedge);
vert_loop_map = static_cast<uint *>(
MEM_malloc_arrayN(totvert, sizeof(*vert_loop_map), __func__));
vert_loop_map = MEM_malloc_arrayN<uint>(totvert, __func__);
memset(vert_loop_map, 0xff, sizeof(*vert_loop_map) * totvert);
for (const int64_t i : faces_orig.index_range()) {
@@ -490,8 +488,7 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
* Sort edge verts for correct face flipping
* NOT REALLY NEEDED but face flipping is nice. */
vert_connect = static_cast<ScrewVertConnect *>(
MEM_malloc_arrayN(totvert, sizeof(ScrewVertConnect), __func__));
vert_connect = MEM_malloc_arrayN<ScrewVertConnect>(totvert, __func__);
/* skip the first slice of verts. */
// vert_connect = (ScrewVertConnect *) &medge_new[totvert];
vc = vert_connect;

6
source/blender/modifiers/intern/MOD_smooth.cc
View File

@@ -69,14 +69,12 @@ static void smoothModifier_do(
return;
}
float(*accumulated_vecs)[3] = static_cast<float(*)[3]>(
MEM_calloc_arrayN(size_t(verts_num), sizeof(*accumulated_vecs), __func__));
float(*accumulated_vecs)[3] = MEM_calloc_arrayN<float[3]>(size_t(verts_num), __func__);
if (!accumulated_vecs) {
return;
}
uint *accumulated_vecs_count = static_cast<uint *>(
MEM_calloc_arrayN(size_t(verts_num), sizeof(*accumulated_vecs_count), __func__));
uint *accumulated_vecs_count = MEM_calloc_arrayN<uint>(size_t(verts_num), __func__);
if (!accumulated_vecs_count) {
MEM_freeN(accumulated_vecs);
return;

45
source/blender/modifiers/intern/MOD_solidify_extrude.cc
View File

@@ -230,13 +230,11 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
#define INVALID_UNUSED uint(-1)
#define INVALID_PAIR uint(-2)
new_vert_arr = static_cast<uint *>(
MEM_malloc_arrayN(verts_num, 2 * sizeof(*new_vert_arr), __func__));
new_edge_arr = static_cast<uint *>(
MEM_malloc_arrayN(((edges_num * 2) + verts_num), sizeof(*new_edge_arr), __func__));
new_vert_arr = MEM_malloc_arrayN<uint>(2 * verts_num, __func__);
new_edge_arr = MEM_malloc_arrayN<uint>(((edges_num * 2) + verts_num), __func__);
edge_users = static_cast<uint *>(MEM_malloc_arrayN(edges_num, sizeof(*edge_users), __func__));
edge_order = static_cast<int *>(MEM_malloc_arrayN(edges_num, sizeof(*edge_order), __func__));
edge_users = MEM_malloc_arrayN<uint>(edges_num, __func__);
edge_order = MEM_malloc_arrayN<int>(edges_num, __func__);
/* save doing 2 loops here... */
#if 0
@@ -314,7 +312,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
#endif
if (smd->flag & MOD_SOLIDIFY_NORMAL_CALC) {
vert_nors = static_cast<float(*)[3]>(MEM_calloc_arrayN(verts_num, sizeof(float[3]), __func__));
vert_nors = MEM_calloc_arrayN<float[3]>(verts_num, __func__);
mesh_calc_hq_normal(mesh,
face_normals,
vert_nors
@@ -495,7 +493,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
float *edge_angs = nullptr;
if (do_clamp) {
vert_lens = static_cast<float *>(MEM_malloc_arrayN(verts_num, sizeof(float), "vert_lens"));
vert_lens = MEM_malloc_arrayN<float>(verts_num, "vert_lens");
copy_vn_fl(vert_lens, int(verts_num), FLT_MAX);
for (uint i = 0; i < edges_num; i++) {
const float ed_len_sq = len_squared_v3v3(vert_positions[edges[i][0]],
@@ -508,18 +506,16 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
if (do_angle_clamp || do_bevel_convex) {
uint eidx;
if (do_angle_clamp) {
vert_angs = static_cast<float *>(MEM_malloc_arrayN(verts_num, sizeof(float), "vert_angs"));
vert_angs = MEM_malloc_arrayN<float>(verts_num, "vert_angs");
copy_vn_fl(vert_angs, int(verts_num), 0.5f * M_PI);
}
if (do_bevel_convex) {
edge_angs = static_cast<float *>(MEM_malloc_arrayN(edges_num, sizeof(float), "edge_angs"));
edge_angs = MEM_malloc_arrayN<float>(edges_num, "edge_angs");
if (!do_rim) {
edge_users = static_cast<uint *>(
MEM_malloc_arrayN(edges_num, sizeof(*edge_users), "solid_mod edges"));
edge_users = MEM_malloc_arrayN<uint>(edges_num, "solid_mod edges");
}
}
uint(*edge_user_pairs)[2] = static_cast<uint(*)[2]>(
MEM_malloc_arrayN(edges_num, sizeof(*edge_user_pairs), "edge_user_pairs"));
uint(*edge_user_pairs)[2] = MEM_malloc_arrayN<uint[2]>(edges_num, "edge_user_pairs");
for (eidx = 0; eidx < edges_num; eidx++) {
edge_user_pairs[eidx][0] = INVALID_UNUSED;
edge_user_pairs[eidx][1] = INVALID_UNUSED;
@@ -711,15 +707,13 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const bool check_non_manifold = (smd->flag & MOD_SOLIDIFY_NORMAL_CALC) != 0;
#endif
/* same as EM_solidify() in editmesh_lib.c */
float *vert_angles = static_cast<float *>(
MEM_calloc_arrayN(verts_num, sizeof(float[2]), "mod_solid_pair")); /* 2 in 1 */
float *vert_angles = MEM_calloc_arrayN<float>(2 * verts_num, "mod_solid_pair"); /* 2 in 1 */
float *vert_accum = vert_angles + verts_num;
uint vidx;
uint i;
if (vert_nors == nullptr) {
vert_nors = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(float[3]), "mod_solid_vno"));
vert_nors = MEM_malloc_arrayN<float[3]>(verts_num, "mod_solid_vno");
for (i = 0; i < verts_num; i++) {
copy_v3_v3(vert_nors[i], vert_normals[i]);
}
@@ -808,20 +802,16 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
if (do_angle_clamp || do_bevel_convex) {
uint eidx;
if (do_angle_clamp) {
vert_angs = static_cast<float *>(
MEM_malloc_arrayN(verts_num, sizeof(float), "vert_angs even"));
vert_angs = MEM_malloc_arrayN<float>(verts_num, "vert_angs even");
copy_vn_fl(vert_angs, int(verts_num), 0.5f * M_PI);
}
if (do_bevel_convex) {
edge_angs = static_cast<float *>(
MEM_malloc_arrayN(edges_num, sizeof(float), "edge_angs even"));
edge_angs = MEM_malloc_arrayN<float>(edges_num, "edge_angs even");
if (!do_rim) {
edge_users = static_cast<uint *>(
MEM_malloc_arrayN(edges_num, sizeof(*edge_users), "solid_mod edges"));
edge_users = MEM_malloc_arrayN<uint>(edges_num, "solid_mod edges");
}
}
uint(*edge_user_pairs)[2] = static_cast<uint(*)[2]>(
MEM_malloc_arrayN(edges_num, sizeof(*edge_user_pairs), "edge_user_pairs"));
uint(*edge_user_pairs)[2] = MEM_malloc_arrayN<uint[2]>(edges_num, "edge_user_pairs");
for (eidx = 0; eidx < edges_num; eidx++) {
edge_user_pairs[eidx][0] = INVALID_UNUSED;
edge_user_pairs[eidx][1] = INVALID_UNUSED;
@@ -879,8 +869,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const float clamp_fac = 1 + (do_angle_clamp ? fabsf(smd->offset_fac) : 0);
const float offset = fabsf(smd->offset) * smd->offset_clamp * clamp_fac;
if (offset > FLT_EPSILON) {
float *vert_lens_sq = static_cast<float *>(
MEM_malloc_arrayN(verts_num, sizeof(float), "vert_lens_sq"));
float *vert_lens_sq = MEM_malloc_arrayN<float>(verts_num, "vert_lens_sq");
const float offset_sq = offset * offset;
copy_vn_fl(vert_lens_sq, int(verts_num), FLT_MAX);
for (i = 0; i < edges_num; i++) {

129
source/blender/modifiers/intern/MOD_solidify_nonmanifold.cc
View File

@@ -212,10 +212,10 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
blender::Array<blender::float3> face_nors = mesh->face_normals();
blender::Array<NewFaceRef> face_sides_arr(faces_num * 2);
bool *null_faces =
(smd->nonmanifold_offset_mode == MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_CONSTRAINTS) ?
static_cast<bool *>(MEM_calloc_arrayN(faces_num, sizeof(*null_faces), __func__)) :
nullptr;
bool *null_faces = (smd->nonmanifold_offset_mode ==
MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_CONSTRAINTS) ?
MEM_calloc_arrayN<bool>(faces_num, __func__) :
nullptr;
uint largest_ngon = 3;
/* Calculate face to #NewFaceRef map. */
{
@@ -237,8 +237,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
}
NewEdgeRef **link_edges = static_cast<NewEdgeRef **>(
MEM_calloc_arrayN(uint(face.size()), sizeof(*link_edges), __func__));
NewEdgeRef **link_edges = MEM_calloc_arrayN<NewEdgeRef *>(uint(face.size()), __func__);
NewFaceRef new_face_ref_a{};
new_face_ref_a.face = face;
@@ -247,8 +246,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
new_face_ref_a.link_edges = link_edges;
face_sides_arr[i * 2] = std::move(new_face_ref_a);
link_edges = static_cast<NewEdgeRef **>(
MEM_calloc_arrayN(uint(face.size()), sizeof(*link_edges), __func__));
link_edges = MEM_calloc_arrayN<NewEdgeRef *>(uint(face.size()), __func__);
NewFaceRef new_face_ref_b{};
new_face_ref_b.face = face;
@@ -268,8 +266,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
}
uint *edge_adj_faces_len = static_cast<uint *>(
MEM_calloc_arrayN(edges_num, sizeof(*edge_adj_faces_len), __func__));
uint *edge_adj_faces_len = MEM_calloc_arrayN<uint>(edges_num, __func__);
/* Count for each edge how many faces it has adjacent. */
{
for (const int64_t i : orig_faces.index_range()) {
@@ -280,16 +277,13 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
/* Original edge to #NewEdgeRef map. */
NewEdgeRef ***orig_edge_data_arr = static_cast<NewEdgeRef ***>(
MEM_calloc_arrayN(edges_num, sizeof(*orig_edge_data_arr), __func__));
NewEdgeRef ***orig_edge_data_arr = MEM_calloc_arrayN<NewEdgeRef **>(edges_num, __func__);
/* Original edge length cache. */
float *orig_edge_lengths = static_cast<float *>(
MEM_calloc_arrayN(edges_num, sizeof(*orig_edge_lengths), __func__));
float *orig_edge_lengths = MEM_calloc_arrayN<float>(edges_num, __func__);
/* Edge groups for every original vert. */
EdgeGroup **orig_vert_groups_arr = static_cast<EdgeGroup **>(
MEM_calloc_arrayN(verts_num, sizeof(*orig_vert_groups_arr), __func__));
EdgeGroup **orig_vert_groups_arr = MEM_calloc_arrayN<EdgeGroup *>(verts_num, __func__);
/* vertex map used to map duplicates. */
uint *vm = static_cast<uint *>(MEM_malloc_arrayN(verts_num, sizeof(*vm), __func__));
uint *vm = MEM_malloc_arrayN<uint>(verts_num, __func__);
for (uint i = 0; i < verts_num; i++) {
vm[i] = i;
}
@@ -301,11 +295,9 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
bool has_singularities = false;
/* Vert edge adjacent map. */
OldVertEdgeRef **vert_adj_edges = static_cast<OldVertEdgeRef **>(
MEM_calloc_arrayN(verts_num, sizeof(*vert_adj_edges), __func__));
OldVertEdgeRef **vert_adj_edges = MEM_calloc_arrayN<OldVertEdgeRef *>(verts_num, __func__);
/* Original vertex positions (changed for degenerated geometry). */
float(*orig_mvert_co)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(*orig_mvert_co), __func__));
float(*orig_mvert_co)[3] = MEM_malloc_arrayN<float[3]>(verts_num, __func__);
/* Fill in the original vertex positions. */
for (uint i = 0; i < verts_num; i++) {
orig_mvert_co[i][0] = orig_vert_positions[i][0];
@@ -315,8 +307,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
/* Create edge to #NewEdgeRef map. */
{
OldEdgeFaceRef **edge_adj_faces = static_cast<OldEdgeFaceRef **>(
MEM_calloc_arrayN(edges_num, sizeof(*edge_adj_faces), __func__));
OldEdgeFaceRef **edge_adj_faces = MEM_calloc_arrayN<OldEdgeFaceRef *>(edges_num, __func__);
/* Create link_faces for edges. */
{
@@ -329,17 +320,14 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (old_face_edge_ref == nullptr) {
const uint len = edge_adj_faces_len[edge];
BLI_assert(len > 0);
uint *adj_faces = static_cast<uint *>(
MEM_malloc_arrayN(len, sizeof(*adj_faces), __func__));
bool *adj_faces_reversed = static_cast<bool *>(
MEM_malloc_arrayN(len, sizeof(*adj_faces_reversed), __func__));
uint *adj_faces = MEM_malloc_arrayN<uint>(len, __func__);
bool *adj_faces_reversed = MEM_malloc_arrayN<bool>(len, __func__);
adj_faces[0] = uint(i);
for (uint k = 1; k < len; k++) {
adj_faces[k] = MOD_SOLIDIFY_EMPTY_TAG;
}
adj_faces_reversed[0] = reversed;
OldEdgeFaceRef *ref = static_cast<OldEdgeFaceRef *>(
MEM_mallocN(sizeof(*ref), __func__));
OldEdgeFaceRef *ref = MEM_mallocN<OldEdgeFaceRef>(__func__);
*ref = OldEdgeFaceRef{adj_faces, len, adj_faces_reversed, 1};
edge_adj_faces[edge] = ref;
}
@@ -357,17 +345,14 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
float edgedir[3] = {0, 0, 0};
uint *vert_adj_edges_len = static_cast<uint *>(
MEM_calloc_arrayN(verts_num, sizeof(*vert_adj_edges_len), __func__));
uint *vert_adj_edges_len = MEM_calloc_arrayN<uint>(verts_num, __func__);
/* Calculate edge lengths and len vert_adj edges. */
{
bool *face_singularity = static_cast<bool *>(
MEM_calloc_arrayN(faces_num, sizeof(*face_singularity), __func__));
bool *face_singularity = MEM_calloc_arrayN<bool>(faces_num, __func__);
const float merge_tolerance_sqr = smd->merge_tolerance * smd->merge_tolerance;
uint *combined_verts = static_cast<uint *>(
MEM_calloc_arrayN(verts_num, sizeof(*combined_verts), __func__));
uint *combined_verts = MEM_calloc_arrayN<uint>(verts_num, __func__);
for (uint i = 0; i < edges_num; i++) {
const int2 &edge = orig_edges[i];
@@ -502,14 +487,12 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (len > 0) {
OldVertEdgeRef *old_edge_vert_ref = vert_adj_edges[vert];
if (old_edge_vert_ref == nullptr) {
uint *adj_edges = static_cast<uint *>(
MEM_calloc_arrayN(len, sizeof(*adj_edges), __func__));
uint *adj_edges = MEM_calloc_arrayN<uint>(len, __func__);
adj_edges[0] = i;
for (uint k = 1; k < len; k++) {
adj_edges[k] = MOD_SOLIDIFY_EMPTY_TAG;
}
OldVertEdgeRef *ref = static_cast<OldVertEdgeRef *>(
MEM_mallocN(sizeof(*ref), __func__));
OldVertEdgeRef *ref = MEM_mallocN<OldVertEdgeRef>(__func__);
*ref = OldVertEdgeRef{adj_edges, 1};
vert_adj_edges[vert] = ref;
}
@@ -568,10 +551,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
new_loops_num -= 4 * j;
}
const uint len = i_adj_faces->faces_len + invalid_adj_faces->faces_len - 2 * j;
uint *adj_faces = static_cast<uint *>(
MEM_malloc_arrayN(len, sizeof(*adj_faces), __func__));
bool *adj_faces_loops_reversed = static_cast<bool *>(
MEM_malloc_arrayN(len, sizeof(*adj_faces_loops_reversed), __func__));
uint *adj_faces = MEM_malloc_arrayN<uint>(len, __func__);
bool *adj_faces_loops_reversed = MEM_malloc_arrayN<bool>(len, __func__);
/* Clean merge of adj_faces. */
j = 0;
for (uint k = 0; k < i_adj_faces->faces_len; k++) {
@@ -778,8 +759,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const uint *adj_faces_faces = adj_faces->faces;
const bool *adj_faces_reversed = adj_faces->faces_reversed;
uint new_edges_len = 0;
FaceKeyPair *sorted_faces = static_cast<FaceKeyPair *>(
MEM_malloc_arrayN(adj_len, sizeof(*sorted_faces), __func__));
FaceKeyPair *sorted_faces = MEM_malloc_arrayN<FaceKeyPair>(adj_len, __func__);
if (adj_len > 1) {
new_edges_len = adj_len;
/* Get keys for sorting. */
@@ -834,8 +814,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
/* Create a list of new edges and fill it. */
NewEdgeRef **new_edges = static_cast<NewEdgeRef **>(
MEM_malloc_arrayN(new_edges_len + 1, sizeof(*new_edges), __func__));
NewEdgeRef **new_edges = MEM_malloc_arrayN<NewEdgeRef *>(new_edges_len + 1, __func__);
new_edges[new_edges_len] = nullptr;
NewFaceRef *faces[2];
for (uint j = 0; j < new_edges_len; j++) {
@@ -856,8 +835,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
faces[1] = nullptr;
angle = 0;
}
NewEdgeRef *edge_data = static_cast<NewEdgeRef *>(
MEM_mallocN(sizeof(*edge_data), __func__));
NewEdgeRef *edge_data = MEM_mallocN<NewEdgeRef>(__func__);
uint edge_data_edge_index = MOD_SOLIDIFY_EMPTY_TAG;
if (do_shell || (adj_len == 1 && do_rim)) {
edge_data_edge_index = 0;
@@ -942,8 +920,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
}
}
NewEdgeRef **unassigned_edges = static_cast<NewEdgeRef **>(
MEM_malloc_arrayN(unassigned_edges_len, sizeof(*unassigned_edges), __func__));
NewEdgeRef **unassigned_edges = MEM_malloc_arrayN<NewEdgeRef *>(unassigned_edges_len,
__func__);
for (uint j = 0, k = 0; j < tot_adj_edges; j++) {
NewEdgeRef **new_edges = orig_edge_data_arr[adj_edges[j]];
if (new_edges) {
@@ -957,8 +935,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
/* An edge group will always contain min 2 edges
* so max edge group count can be calculated. */
uint edge_groups_len = unassigned_edges_len / 2;
edge_groups = static_cast<EdgeGroup *>(
MEM_calloc_arrayN(edge_groups_len + 1, sizeof(*edge_groups), __func__));
edge_groups = MEM_calloc_arrayN<EdgeGroup>(edge_groups_len + 1, __func__);
uint assigned_edges_len = 0;
NewEdgeRef *found_edge = nullptr;
@@ -1064,8 +1041,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const uint needed_capacity = edge_groups[eg_index].edges_len + 1;
if (needed_capacity > eg_capacity) {
eg_capacity = needed_capacity + 1;
NewEdgeRef **new_eg = static_cast<NewEdgeRef **>(
MEM_calloc_arrayN(eg_capacity, sizeof(*new_eg), __func__));
NewEdgeRef **new_eg = MEM_calloc_arrayN<NewEdgeRef *>(eg_capacity, __func__);
if (insert_at_start) {
memcpy(new_eg + 1,
edge_groups[eg_index].edges,
@@ -1102,8 +1078,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
eg_index++;
BLI_assert(eg_index < edge_groups_len);
eg_capacity = 5;
NewEdgeRef **edges = static_cast<NewEdgeRef **>(
MEM_calloc_arrayN(eg_capacity, sizeof(*edges), __func__));
NewEdgeRef **edges = MEM_calloc_arrayN<NewEdgeRef *>(eg_capacity, __func__);
EdgeGroup edge_group{};
edge_group.valid = true;
@@ -1144,8 +1119,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const uint edges_len = edge_groups[j + add_index].edges_len;
if (edges_len > 3) {
bool has_doubles = false;
bool *doubles = static_cast<bool *>(
MEM_calloc_arrayN(edges_len, sizeof(*doubles), __func__));
bool *doubles = MEM_calloc_arrayN<bool>(edges_len, __func__);
EdgeGroup g = edge_groups[j + add_index];
for (uint k = 0; k < edges_len; k++) {
for (uint l = k + 1; l < edges_len; l++) {
@@ -1193,8 +1167,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
if (last_split > split) {
const uint edges_len_group = (split + edges_len) - uint(last_split);
NewEdgeRef **edges = static_cast<NewEdgeRef **>(
MEM_malloc_arrayN(edges_len_group, sizeof(*edges), __func__));
NewEdgeRef **edges = MEM_malloc_arrayN<NewEdgeRef *>(edges_len_group,
__func__);
memcpy(edges,
g.edges + last_split,
(edges_len - uint(last_split)) * sizeof(*edges));
@@ -1219,8 +1193,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
else {
const uint edges_len_group = split - uint(last_split);
NewEdgeRef **edges = static_cast<NewEdgeRef **>(
MEM_malloc_arrayN(edges_len_group, sizeof(*edges), __func__));
NewEdgeRef **edges = MEM_malloc_arrayN<NewEdgeRef *>(edges_len_group,
__func__);
memcpy(edges, g.edges + last_split, edges_len_group * sizeof(*edges));
EdgeGroup edge_group{};
@@ -1266,8 +1240,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
edge_groups + (j + add_index + 1),
(uint(eg_index) - j - 1) * sizeof(*edge_groups));
}
NewEdgeRef **edges = static_cast<NewEdgeRef **>(
MEM_malloc_arrayN(uint(first_split), sizeof(*edges), __func__));
NewEdgeRef **edges = MEM_malloc_arrayN<NewEdgeRef *>(uint(first_split),
__func__);
memcpy(edges, g.edges, uint(first_split) * sizeof(*edges));
EdgeGroup edge_group_a{};
@@ -1287,8 +1261,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
add_index++;
splits++;
edges = static_cast<NewEdgeRef **>(MEM_malloc_arrayN(
edges_len - uint(last_split), sizeof(*edges), __func__));
edges = MEM_malloc_arrayN<NewEdgeRef *>(edges_len - uint(last_split),
__func__);
memcpy(edges,
g.edges + last_split,
(edges_len - uint(last_split)) * sizeof(*edges));
@@ -1413,8 +1387,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
float *face_weight = nullptr;
if (do_flat_faces) {
face_weight = static_cast<float *>(
MEM_malloc_arrayN(faces_num, sizeof(*face_weight), __func__));
face_weight = MEM_malloc_arrayN<float>(faces_num, __func__);
for (const int i : orig_faces.index_range()) {
float scalar_vgroup = 1.0f;
@@ -1453,8 +1426,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
NewEdgeRef *first_edge = nullptr;
NewEdgeRef **edge_ptr = g->edges;
/* Contains normal and offset `[nx, ny, nz, ofs]`. */
float(*planes_queue)[4] = static_cast<float(*)[4]>(
MEM_malloc_arrayN(g->edges_len + 1, sizeof(*planes_queue), __func__));
float(*planes_queue)[4] = MEM_malloc_arrayN<float[4]>(g->edges_len + 1, __func__);
uint queue_index = 0;
float fallback_nor[3];
@@ -1947,8 +1919,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
has_singularities = false;
uint i = 0;
uint singularity_edges_len = 1;
singularity_edges = static_cast<uint(*)[2]>(
MEM_malloc_arrayN(singularity_edges_len, sizeof(*singularity_edges), __func__));
singularity_edges = MEM_malloc_arrayN<uint[2]>(singularity_edges_len, __func__);
for (NewEdgeRef ***new_edges = orig_edge_data_arr; i < edges_num; i++, new_edges++) {
if (*new_edges && (do_shell || edge_adj_faces_len[i] == 1) && (**new_edges)->old_edge == i) {
for (NewEdgeRef **l = *new_edges; *l; l++) {
@@ -2286,8 +2257,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
edge_index++;
/* Loop data. */
int *loops_data = static_cast<int *>(
MEM_malloc_arrayN(j, sizeof(*loops_data), __func__));
int *loops_data = MEM_malloc_arrayN<int>(j, __func__);
/* The result material index is from consensus. */
short most_mat_nr = 0;
uint most_mat_nr_face = 0;
@@ -2556,12 +2526,9 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
/* Make faces. */
if (do_shell) {
uint *face_loops = static_cast<uint *>(
MEM_malloc_arrayN(largest_ngon * 2, sizeof(*face_loops), __func__));
uint *face_verts = static_cast<uint *>(
MEM_malloc_arrayN(largest_ngon * 2, sizeof(*face_verts), __func__));
uint *face_edges = static_cast<uint *>(
MEM_malloc_arrayN(largest_ngon * 2, sizeof(*face_edges), __func__));
uint *face_loops = MEM_malloc_arrayN<uint>(largest_ngon * 2, __func__);
uint *face_verts = MEM_malloc_arrayN<uint>(largest_ngon * 2, __func__);
uint *face_edges = MEM_malloc_arrayN<uint>(largest_ngon * 2, __func__);
for (uint i = 0; i < faces_num * 2; i++) {
NewFaceRef &fr = face_sides_arr[i];
const uint loopstart = uint(fr.face.start());

6
source/blender/modifiers/intern/MOD_surface.cc
View File

@@ -121,10 +121,8 @@ static void deform_verts(ModifierData *md,
MEM_SAFE_FREE(surmd->runtime.vert_positions_prev);
MEM_SAFE_FREE(surmd->runtime.vert_velocities);
surmd->runtime.vert_positions_prev = static_cast<float(*)[3]>(
MEM_calloc_arrayN(mesh_verts_num, sizeof(float[3]), __func__));
surmd->runtime.vert_velocities = static_cast<float(*)[3]>(
MEM_calloc_arrayN(mesh_verts_num, sizeof(float[3]), __func__));
surmd->runtime.vert_positions_prev = MEM_calloc_arrayN<float[3]>(mesh_verts_num, __func__);
surmd->runtime.vert_velocities = MEM_calloc_arrayN<float[3]>(mesh_verts_num, __func__);
surmd->runtime.verts_num = mesh_verts_num;

57
source/blender/modifiers/intern/MOD_surfacedeform.cc
View File

@@ -488,7 +488,7 @@ BLI_INLINE SDefBindWeightData *computeBindWeights(SDefBindCalcData *const data,
float tot_weight = 0.0f;
int inf_weight_flags = 0;
bwdata = static_cast<SDefBindWeightData *>(MEM_callocN(sizeof(*bwdata), "SDefBindWeightData"));
bwdata = MEM_callocN<SDefBindWeightData>("SDefBindWeightData");
if (bwdata == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return nullptr;
@@ -496,8 +496,7 @@ BLI_INLINE SDefBindWeightData *computeBindWeights(SDefBindCalcData *const data,
bwdata->faces_num = data->vert_edges[nearest].num / 2;
bpoly = static_cast<SDefBindPoly *>(
MEM_calloc_arrayN(bwdata->faces_num, sizeof(*bpoly), "SDefBindPoly"));
bpoly = MEM_calloc_arrayN<SDefBindPoly>(size_t(bwdata->faces_num), "SDefBindPoly");
if (bpoly == nullptr) {
freeBindData(bwdata);
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
@@ -540,16 +539,15 @@ BLI_INLINE SDefBindWeightData *computeBindWeights(SDefBindCalcData *const data,
bpoly->verts_num = face.size();
bpoly->loopstart = face.start();
bpoly->coords = static_cast<float(*)[3]>(
MEM_malloc_arrayN(face.size(), sizeof(*bpoly->coords), "SDefBindPolyCoords"));
bpoly->coords = MEM_malloc_arrayN<float[3]>(size_t(face.size()), "SDefBindPolyCoords");
if (bpoly->coords == nullptr) {
freeBindData(bwdata);
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return nullptr;
}
bpoly->coords_v2 = static_cast<float(*)[2]>(
MEM_malloc_arrayN(face.size(), sizeof(*bpoly->coords_v2), "SDefBindPolyCoords_v2"));
bpoly->coords_v2 = MEM_malloc_arrayN<float[2]>(size_t(face.size()),
"SDefBindPolyCoords_v2");
if (bpoly->coords_v2 == nullptr) {
freeBindData(bwdata);
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
@@ -989,8 +987,7 @@ static void bindVert(void *__restrict userdata,
return;
}
sdvert->binds = static_cast<SDefBind *>(
MEM_calloc_arrayN(bwdata->binds_num, sizeof(*sdvert->binds), "SDefVertBindData"));
sdvert->binds = MEM_calloc_arrayN<SDefBind>(size_t(bwdata->binds_num), "SDefVertBindData");
if (sdvert->binds == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
sdvert->binds_num = 0;
@@ -1010,15 +1007,14 @@ static void bindVert(void *__restrict userdata,
sdbind->verts_num = bpoly->verts_num;
sdbind->mode = MOD_SDEF_MODE_NGONS;
sdbind->vert_weights = static_cast<float *>(MEM_malloc_arrayN(
bpoly->verts_num, sizeof(*sdbind->vert_weights), "SDefNgonVertWeights"));
sdbind->vert_weights = MEM_malloc_arrayN<float>(size_t(bpoly->verts_num),
"SDefNgonVertWeights");
if (sdbind->vert_weights == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return;
}
sdbind->vert_inds = static_cast<uint *>(
MEM_malloc_arrayN(bpoly->verts_num, sizeof(*sdbind->vert_inds), "SDefNgonVertInds"));
sdbind->vert_inds = MEM_malloc_arrayN<uint>(size_t(bpoly->verts_num), "SDefNgonVertInds");
if (sdbind->vert_inds == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return;
@@ -1051,15 +1047,14 @@ static void bindVert(void *__restrict userdata,
sdbind->verts_num = bpoly->verts_num;
sdbind->mode = MOD_SDEF_MODE_CENTROID;
sdbind->vert_weights = static_cast<float *>(
MEM_malloc_arrayN(3, sizeof(*sdbind->vert_weights), "SDefCentVertWeights"));
sdbind->vert_weights = MEM_malloc_arrayN<float>(3, "SDefCentVertWeights");
if (sdbind->vert_weights == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return;
}
sdbind->vert_inds = static_cast<uint *>(
MEM_malloc_arrayN(bpoly->verts_num, sizeof(*sdbind->vert_inds), "SDefCentVertInds"));
sdbind->vert_inds = MEM_malloc_arrayN<uint>(size_t(bpoly->verts_num),
"SDefCentVertInds");
if (sdbind->vert_inds == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return;
@@ -1099,15 +1094,13 @@ static void bindVert(void *__restrict userdata,
sdbind->verts_num = bpoly->verts_num;
sdbind->mode = MOD_SDEF_MODE_CORNER_TRIS;
sdbind->vert_weights = static_cast<float *>(
MEM_malloc_arrayN(3, sizeof(*sdbind->vert_weights), "SDefTriVertWeights"));
sdbind->vert_weights = MEM_malloc_arrayN<float>(3, "SDefTriVertWeights");
if (sdbind->vert_weights == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return;
}
sdbind->vert_inds = static_cast<uint *>(
MEM_malloc_arrayN(bpoly->verts_num, sizeof(*sdbind->vert_inds), "SDefTriVertInds"));
sdbind->vert_inds = MEM_malloc_arrayN<uint>(size_t(bpoly->verts_num), "SDefTriVertInds");
if (sdbind->vert_inds == nullptr) {
data->success = MOD_SDEF_BIND_RESULT_MEM_ERR;
return;
@@ -1180,23 +1173,23 @@ static bool surfacedeformBind(Object *ob,
uint tedges_num = target->edges_num;
int adj_result;
SDefAdjacencyArray *vert_edges = static_cast<SDefAdjacencyArray *>(
MEM_calloc_arrayN(target_verts_num, sizeof(*vert_edges), "SDefVertEdgeMap"));
SDefAdjacencyArray *vert_edges = MEM_calloc_arrayN<SDefAdjacencyArray>(size_t(target_verts_num),
"SDefVertEdgeMap");
if (vert_edges == nullptr) {
BKE_modifier_set_error(ob, (ModifierData *)smd_eval, "Out of memory");
return false;
}
SDefAdjacency *adj_array = static_cast<SDefAdjacency *>(
MEM_malloc_arrayN(tedges_num, 2 * sizeof(*adj_array), "SDefVertEdge"));
SDefAdjacency *adj_array = MEM_malloc_arrayN<SDefAdjacency>(2 * size_t(tedges_num),
"SDefVertEdge");
if (adj_array == nullptr) {
BKE_modifier_set_error(ob, (ModifierData *)smd_eval, "Out of memory");
MEM_freeN(vert_edges);
return false;
}
SDefEdgePolys *edge_polys = static_cast<SDefEdgePolys *>(
MEM_calloc_arrayN(tedges_num, sizeof(*edge_polys), "SDefEdgeFaceMap"));
SDefEdgePolys *edge_polys = MEM_calloc_arrayN<SDefEdgePolys>(size_t(tedges_num),
"SDefEdgeFaceMap");
if (edge_polys == nullptr) {
BKE_modifier_set_error(ob, (ModifierData *)smd_eval, "Out of memory");
MEM_freeN(vert_edges);
@@ -1204,8 +1197,7 @@ static bool surfacedeformBind(Object *ob,
return false;
}
smd_orig->verts = static_cast<SDefVert *>(
MEM_malloc_arrayN(verts_num, sizeof(*smd_orig->verts), "SDefBindVerts"));
smd_orig->verts = MEM_malloc_arrayN<SDefVert>(size_t(verts_num), "SDefBindVerts");
if (smd_orig->verts == nullptr) {
BKE_modifier_set_error(ob, (ModifierData *)smd_eval, "Out of memory");
freeAdjacencyMap(vert_edges, adj_array, edge_polys);
@@ -1252,8 +1244,8 @@ static bool surfacedeformBind(Object *ob,
data.corner_edges = corner_edges;
data.corner_tris = target->corner_tris();
data.tri_faces = target->corner_tri_faces();
data.targetCos = static_cast<float(*)[3]>(
MEM_malloc_arrayN(target_verts_num, sizeof(float[3]), "SDefTargetBindVertArray"));
data.targetCos = MEM_malloc_arrayN<float[3]>(size_t(target_verts_num),
"SDefTargetBindVertArray");
data.bind_verts = smd_orig->verts;
data.vertexCos = vertexCos;
data.falloff = smd_orig->falloff;
@@ -1537,8 +1529,7 @@ static void surfacedeformModifier_do(ModifierData *md,
/* Actual vertex location update starts here */
SDefDeformData data{};
data.bind_verts = smd->verts;
data.targetCos = static_cast<float(*)[3]>(
MEM_malloc_arrayN(target_verts_num, sizeof(float[3]), "SDefTargetVertArray"));
data.targetCos = MEM_malloc_arrayN<float[3]>(size_t(target_verts_num), "SDefTargetVertArray");
data.vertexCos = vertexCos;
data.dvert = dvert;
data.defgrp_index = defgrp_index;

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

@@ -234,7 +234,7 @@ static void warpModifier_do(WarpModifierData *wmd,
Tex *tex_target = wmd->texture;
if (mesh != nullptr && tex_target != nullptr) {
tex_co = static_cast<float(*)[3]>(MEM_malloc_arrayN(verts_num, sizeof(*tex_co), __func__));
tex_co = MEM_malloc_arrayN<float[3]>(size_t(verts_num), __func__);
MOD_get_texture_coords((MappingInfoModifierData *)wmd, ctx, ob, mesh, vertexCos, tex_co);
MOD_init_texture((MappingInfoModifierData *)wmd, ctx);

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

@@ -170,7 +170,7 @@ static void waveModifier_do(WaveModifierData *wmd,
Tex *tex_target = wmd->texture;
if (mesh != nullptr && tex_target != nullptr) {
tex_co = static_cast<float(*)[3]>(MEM_malloc_arrayN(verts_num, sizeof(*tex_co), __func__));
tex_co = MEM_malloc_arrayN<float[3]>(size_t(verts_num), __func__);
MOD_get_texture_coords((MappingInfoModifierData *)wmd, ctx, ob, mesh, vertexCos, tex_co);
MOD_init_texture((MappingInfoModifierData *)wmd, ctx);

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

@@ -381,8 +381,7 @@ static void wn_face_area(WeightedNormalModifierData *wnmd, WeightedNormalData *w
const blender::OffsetIndices faces = wn_data->faces;
const blender::Span<int> corner_verts = wn_data->corner_verts;
ModePair *face_area = static_cast<ModePair *>(
MEM_malloc_arrayN(faces.size(), sizeof(*face_area), __func__));
ModePair *face_area = MEM_malloc_arrayN<ModePair>(size_t(faces.size()), __func__);
ModePair *f_area = face_area;
for (const int i : faces.index_range()) {
@@ -402,13 +401,11 @@ static void wn_corner_angle(WeightedNormalModifierData *wnmd, WeightedNormalData
const blender::OffsetIndices faces = wn_data->faces;
const blender::Span<int> corner_verts = wn_data->corner_verts;
ModePair *corner_angle = static_cast<ModePair *>(
MEM_malloc_arrayN(corner_verts.size(), sizeof(*corner_angle), __func__));
ModePair *corner_angle = MEM_malloc_arrayN<ModePair>(size_t(corner_verts.size()), __func__);
for (const int i : faces.index_range()) {
const blender::IndexRange face = faces[i];
float *index_angle = static_cast<float *>(
MEM_malloc_arrayN(face.size(), sizeof(*index_angle), __func__));
float *index_angle = MEM_malloc_arrayN<float>(size_t(face.size()), __func__);
blender::bke::mesh::face_angles_calc(
positions, corner_verts.slice(face), {index_angle, face.size()});
@@ -435,15 +432,13 @@ static void wn_face_with_angle(WeightedNormalModifierData *wnmd, WeightedNormalD
const blender::OffsetIndices faces = wn_data->faces;
const blender::Span<int> corner_verts = wn_data->corner_verts;
ModePair *combined = static_cast<ModePair *>(
MEM_malloc_arrayN(corner_verts.size(), sizeof(*combined), __func__));
ModePair *combined = MEM_malloc_arrayN<ModePair>(size_t(corner_verts.size()), __func__);
for (const int i : faces.index_range()) {
const blender::IndexRange face = faces[i];
const blender::Span<int> face_verts = corner_verts.slice(face);
const float face_area = blender::bke::mesh::face_area_calc(positions, face_verts);
float *index_angle = static_cast<float *>(
MEM_malloc_arrayN(size_t(face.size()), sizeof(*index_angle), __func__));
float *index_angle = MEM_malloc_arrayN<float>(size_t(face.size()), __func__);
blender::bke::mesh::face_angles_calc(positions, face_verts, {index_angle, face.size()});
ModePair *cmbnd = &combined[face.start()];

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

@@ -149,7 +149,7 @@ void weightvg_do_mask(const ModifierEvalContext *ctx,
STRNCPY(t_map.uvlayer_name, tex_uvlayer_name);
t_map.texmapping = tex_mapping;
tex_co = static_cast<float(*)[3]>(MEM_calloc_arrayN(verts_num, sizeof(*tex_co), __func__));
tex_co = MEM_calloc_arrayN<float[3]>(size_t(verts_num), __func__);
MOD_get_texture_coords(&t_map, ctx, ob, mesh, nullptr, tex_co);
MOD_init_texture(&t_map, ctx);

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

@@ -202,10 +202,9 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
}
/* Get org weights, assuming 0.0 for vertices not in given vgroup. */
org_w = static_cast<float *>(MEM_malloc_arrayN(verts_num, sizeof(float), __func__));
new_w = static_cast<float *>(MEM_malloc_arrayN(verts_num, sizeof(float), __func__));
dw = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(verts_num, sizeof(MDeformWeight *), __func__));
org_w = MEM_malloc_arrayN<float>(size_t(verts_num), __func__);
new_w = MEM_malloc_arrayN<float>(size_t(verts_num), __func__);
dw = MEM_malloc_arrayN<MDeformWeight *>(size_t(verts_num), __func__);
for (i = 0; i < verts_num; i++) {
dw[i] = BKE_defvert_find_index(&dvert[i], defgrp_index);
if (dw[i]) {

20
source/blender/modifiers/intern/MOD_weightvgmix.cc
View File

@@ -267,11 +267,9 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
}
/* Find out which vertices to work on. */
tidx = static_cast<int *>(MEM_malloc_arrayN(verts_num, sizeof(int), __func__));
tdw1 = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(verts_num, sizeof(MDeformWeight *), __func__));
tdw2 = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(verts_num, sizeof(MDeformWeight *), __func__));
tidx = MEM_malloc_arrayN<int>(size_t(verts_num), __func__);
tdw1 = MEM_malloc_arrayN<MDeformWeight *>(size_t(verts_num), __func__);
tdw2 = MEM_malloc_arrayN<MDeformWeight *>(size_t(verts_num), __func__);
switch (wmd->mix_set) {
case MOD_WVG_SET_A:
/* All vertices in first vgroup. */
@@ -347,14 +345,12 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
return mesh;
}
if (index_num != -1) {
indices = static_cast<int *>(MEM_malloc_arrayN(index_num, sizeof(int), __func__));
indices = MEM_malloc_arrayN<int>(size_t(index_num), __func__);
memcpy(indices, tidx, sizeof(int) * index_num);
dw1 = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(index_num, sizeof(MDeformWeight *), __func__));
dw1 = MEM_malloc_arrayN<MDeformWeight *>(size_t(index_num), __func__);
memcpy(dw1, tdw1, sizeof(MDeformWeight *) * index_num);
MEM_freeN(tdw1);
dw2 = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(index_num, sizeof(MDeformWeight *), __func__));
dw2 = MEM_malloc_arrayN<MDeformWeight *>(size_t(index_num), __func__);
memcpy(dw2, tdw2, sizeof(MDeformWeight *) * index_num);
MEM_freeN(tdw2);
}
@@ -367,8 +363,8 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
}
MEM_freeN(tidx);
org_w = static_cast<float *>(MEM_malloc_arrayN(index_num, sizeof(float), __func__));
new_w = static_cast<float *>(MEM_malloc_arrayN(index_num, sizeof(float), __func__));
org_w = MEM_malloc_arrayN<float>(size_t(index_num), __func__);
new_w = MEM_malloc_arrayN<float>(size_t(index_num), __func__);
/* Mix weights. */
for (i = 0; i < index_num; i++) {

25
source/blender/modifiers/intern/MOD_weightvgproximity.cc
View File

@@ -473,10 +473,9 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
}
/* Find out which vertices to work on (all vertices in vgroup), and get their relevant weight. */
tidx = static_cast<int *>(MEM_malloc_arrayN(verts_num, sizeof(int), __func__));
tw = static_cast<float *>(MEM_malloc_arrayN(verts_num, sizeof(float), __func__));
tdw = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(verts_num, sizeof(MDeformWeight *), __func__));
tidx = MEM_malloc_arrayN<int>(size_t(verts_num), __func__);
tw = MEM_malloc_arrayN<float>(size_t(verts_num), __func__);
tdw = MEM_malloc_arrayN<MDeformWeight *>(size_t(verts_num), __func__);
for (i = 0; i < verts_num; i++) {
MDeformWeight *_dw = BKE_defvert_find_index(&dvert[i], defgrp_index);
if (_dw) {
@@ -493,12 +492,11 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
return mesh;
}
if (index_num != verts_num) {
indices = static_cast<int *>(MEM_malloc_arrayN(index_num, sizeof(int), __func__));
indices = MEM_malloc_arrayN<int>(size_t(index_num), __func__);
memcpy(indices, tidx, sizeof(int) * index_num);
org_w = static_cast<float *>(MEM_malloc_arrayN(index_num, sizeof(float), __func__));
org_w = MEM_malloc_arrayN<float>(size_t(index_num), __func__);
memcpy(org_w, tw, sizeof(float) * index_num);
dw = static_cast<MDeformWeight **>(
MEM_malloc_arrayN(index_num, sizeof(MDeformWeight *), __func__));
dw = MEM_malloc_arrayN<MDeformWeight *>(size_t(index_num), __func__);
memcpy(dw, tdw, sizeof(MDeformWeight *) * index_num);
MEM_freeN(tw);
MEM_freeN(tdw);
@@ -507,7 +505,7 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
org_w = tw;
dw = tdw;
}
new_w = static_cast<float *>(MEM_malloc_arrayN(index_num, sizeof(float), __func__));
new_w = MEM_malloc_arrayN<float>(size_t(index_num), __func__);
MEM_freeN(tidx);
const blender::Span<blender::float3> positions = mesh->vert_positions();
@@ -535,14 +533,11 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh
BKE_mesh_wrapper_ensure_mdata(target_mesh);
SpaceTransform loc2trgt;
float *dists_v = use_trgt_verts ? static_cast<float *>(MEM_malloc_arrayN(
index_num, sizeof(float), __func__)) :
float *dists_v = use_trgt_verts ? MEM_malloc_arrayN<float>(size_t(index_num), __func__) :
nullptr;
float *dists_e = use_trgt_edges ? static_cast<float *>(MEM_malloc_arrayN(
index_num, sizeof(float), __func__)) :
float *dists_e = use_trgt_edges ? MEM_malloc_arrayN<float>(size_t(index_num), __func__) :
nullptr;
float *dists_f = use_trgt_faces ? static_cast<float *>(MEM_malloc_arrayN(
index_num, sizeof(float), __func__)) :
float *dists_f = use_trgt_faces ? MEM_malloc_arrayN<float>(size_t(index_num), __func__) :
nullptr;
BLI_SPACE_TRANSFORM_SETUP(&loc2trgt, ob, obr);

68
source/blender/modifiers/intern/lineart/lineart_cpu.cc
View File

@@ -376,8 +376,7 @@ static void lineart_bounding_area_line_add(LineartBoundingArea *ba, LineartEdge
return;
}
if (ba->line_count >= ba->max_line_count) {
LineartEdge **new_array = static_cast<LineartEdge **>(
MEM_malloc_arrayN(ba->max_line_count * 2, sizeof(LineartEdge *), __func__));
LineartEdge **new_array = MEM_malloc_arrayN<LineartEdge *>(ba->max_line_count * 2, __func__);
memcpy(new_array, ba->linked_lines, sizeof(LineartEdge *) * ba->max_line_count);
ba->max_line_count *= 2;
MEM_freeN(ba->linked_lines);
@@ -472,8 +471,8 @@ static void lineart_occlusion_worker(TaskPool *__restrict /*pool*/, LineartRende
void lineart_main_occlusion_begin(LineartData *ld)
{
int thread_count = ld->thread_count;
LineartRenderTaskInfo *rti = static_cast<LineartRenderTaskInfo *>(
MEM_callocN(sizeof(LineartRenderTaskInfo) * thread_count, __func__));
LineartRenderTaskInfo *rti = MEM_calloc_arrayN<LineartRenderTaskInfo>(size_t(thread_count),
__func__);
int i;
TaskPool *tp = BLI_task_pool_create(nullptr, TASK_PRIORITY_HIGH);
@@ -1742,8 +1741,8 @@ void lineart_add_edge_to_array(LineartPendingEdges *pe, LineartEdge *e)
pe->max = 1000;
}
LineartEdge **new_array = static_cast<LineartEdge **>(
MEM_mallocN(sizeof(LineartEdge *) * pe->max * 2, "LineartPendingEdges array"));
LineartEdge **new_array = MEM_malloc_arrayN<LineartEdge *>(size_t(pe->max) * 2,
"LineartPendingEdges array");
if (LIKELY(pe->array)) {
memcpy(new_array, pe->array, sizeof(LineartEdge *) * pe->max);
MEM_freeN(pe->array);
@@ -1769,8 +1768,8 @@ void lineart_finalize_object_edge_array_reserve(LineartPendingEdges *pe, int cou
}
pe->max = count;
LineartEdge **new_array = static_cast<LineartEdge **>(
MEM_mallocN(sizeof(LineartEdge *) * pe->max, "LineartPendingEdges array final"));
LineartEdge **new_array = MEM_malloc_arrayN<LineartEdge *>(size_t(pe->max),
"LineartPendingEdges array final");
pe->array = new_array;
}
@@ -1933,10 +1932,10 @@ static void lineart_sort_adjacent_items(LineartAdjacentEdge *ai, int length)
static LineartEdgeNeighbor *lineart_build_edge_neighbor(Mesh *mesh, int total_edges)
{
/* Because the mesh is triangulated, so `mesh->edges_num` should be reliable? */
LineartAdjacentEdge *adj_e = static_cast<LineartAdjacentEdge *>(
MEM_mallocN(sizeof(LineartAdjacentEdge) * total_edges, "LineartAdjacentEdge arr"));
LineartEdgeNeighbor *edge_nabr = static_cast<LineartEdgeNeighbor *>(
MEM_mallocN(sizeof(LineartEdgeNeighbor) * total_edges, "LineartEdgeNeighbor arr"));
LineartAdjacentEdge *adj_e = MEM_malloc_arrayN<LineartAdjacentEdge>(size_t(total_edges),
"LineartAdjacentEdge arr");
LineartEdgeNeighbor *edge_nabr = MEM_malloc_arrayN<LineartEdgeNeighbor>(
size_t(total_edges), "LineartEdgeNeighbor arr");
TaskParallelSettings en_settings;
BLI_parallel_range_settings_defaults(&en_settings);
@@ -2049,8 +2048,8 @@ static void lineart_geometry_object_load(LineartObjectInfo *ob_info,
((usage == OBJECT_LRT_NO_INTERSECTION) ? LRT_ELEMENT_NO_INTERSECTION : 0));
/* Note this memory is not from pool, will be deleted after culling. */
LineartTriangleAdjacent *tri_adj = static_cast<LineartTriangleAdjacent *>(MEM_callocN(
sizeof(LineartTriangleAdjacent) * corner_tris.size(), "LineartTriangleAdjacent"));
LineartTriangleAdjacent *tri_adj = MEM_calloc_arrayN<LineartTriangleAdjacent>(
size_t(corner_tris.size()), "LineartTriangleAdjacent");
/* Link is minimal so we use pool anyway. */
BLI_spin_lock(&la_data->lock_task);
lineart_list_append_pointer_pool_thread(
@@ -2153,8 +2152,7 @@ static void lineart_geometry_object_load(LineartObjectInfo *ob_info,
/* Only identifying floating edges at this point because other edges has been taken care of
* inside #lineart_identify_corner_tri_feature_edges function. */
const LooseEdgeCache &loose_edges = mesh->loose_edges();
loose_data.loose_array = static_cast<int *>(
MEM_malloc_arrayN(loose_edges.count, sizeof(int), __func__));
loose_data.loose_array = MEM_malloc_arrayN<int>(size_t(loose_edges.count), __func__);
if (loose_edges.count > 0) {
loose_data.loose_count = 0;
for (const int64_t edge_i : IndexRange(mesh->edges_num)) {
@@ -3319,8 +3317,8 @@ static void lineart_add_isec_thread(LineartIsecThread *th,
{
if (th->current == th->max) {
LineartIsecSingle *new_array = static_cast<LineartIsecSingle *>(
MEM_mallocN(sizeof(LineartIsecSingle) * th->max * 2, "LineartIsecSingle"));
LineartIsecSingle *new_array = MEM_malloc_arrayN<LineartIsecSingle>(size_t(th->max) * 2,
"LineartIsecSingle");
memcpy(new_array, th->array, sizeof(LineartIsecSingle) * th->max);
th->max *= 2;
MEM_freeN(th->array);
@@ -3386,8 +3384,7 @@ static bool lineart_schedule_new_triangle_task(LineartIsecThread *th)
*/
static void lineart_init_isec_thread(LineartIsecData *d, LineartData *ld, int thread_count)
{
d->threads = static_cast<LineartIsecThread *>(
MEM_callocN(sizeof(LineartIsecThread) * thread_count, "LineartIsecThread arr"));
d->threads = MEM_calloc_arrayN<LineartIsecThread>(size_t(thread_count), "LineartIsecThread arr");
d->ld = ld;
d->thread_count = thread_count;
@@ -3397,8 +3394,7 @@ static void lineart_init_isec_thread(LineartIsecData *d, LineartData *ld, int th
for (int i = 0; i < thread_count; i++) {
LineartIsecThread *it = &d->threads[i];
it->array = static_cast<LineartIsecSingle *>(
MEM_mallocN(sizeof(LineartIsecSingle) * 100, "LineartIsecSingle arr"));
it->array = MEM_malloc_arrayN<LineartIsecSingle>(100, "LineartIsecSingle arr");
it->max = 100;
it->current = 0;
it->thread_id = i;
@@ -3570,8 +3566,7 @@ void MOD_lineart_destroy_render_data_v3(GreasePencilLineartModifierData *lmd)
LineartCache *MOD_lineart_init_cache()
{
LineartCache *lc = static_cast<LineartCache *>(
MEM_callocN(sizeof(LineartCache), "Lineart Cache"));
LineartCache *lc = MEM_callocN<LineartCache>("Lineart Cache");
return lc;
}
@@ -3591,8 +3586,7 @@ static LineartData *lineart_create_render_buffer_v3(Scene *scene,
Object *active_camera,
LineartCache *lc)
{
LineartData *ld = static_cast<LineartData *>(
MEM_callocN(sizeof(LineartData), "Line Art render buffer"));
LineartData *ld = MEM_callocN<LineartData>("Line Art render buffer");
lmd->cache = lc;
lmd->la_data_ptr = ld;
lc->all_enabled_edge_types = lmd->edge_types_override;
@@ -3793,10 +3787,9 @@ void lineart_main_bounding_area_make_initial(LineartData *ld)
/* Init linked_triangles array. */
ba->max_triangle_count = LRT_TILE_SPLITTING_TRIANGLE_LIMIT;
ba->max_line_count = LRT_TILE_EDGE_COUNT_INITIAL;
ba->linked_triangles = static_cast<LineartTriangle **>(
MEM_callocN(sizeof(LineartTriangle *) * ba->max_triangle_count, "ba_linked_triangles"));
ba->linked_lines = static_cast<LineartEdge **>(
MEM_callocN(sizeof(LineartEdge *) * ba->max_line_count, "ba_linked_lines"));
ba->linked_triangles = MEM_calloc_arrayN<LineartTriangle *>(ba->max_triangle_count,
"ba_linked_triangles");
ba->linked_lines = MEM_calloc_arrayN<LineartEdge *>(ba->max_line_count, "ba_linked_lines");
BLI_spin_init(&ba->lock);
}
@@ -4038,10 +4031,9 @@ static void lineart_bounding_area_split(LineartData *ld,
for (int i = 0; i < 4; i++) {
ba[i].max_triangle_count = LRT_TILE_SPLITTING_TRIANGLE_LIMIT;
ba[i].max_line_count = LRT_TILE_EDGE_COUNT_INITIAL;
ba[i].linked_triangles = static_cast<LineartTriangle **>(
MEM_callocN(sizeof(LineartTriangle *) * ba[i].max_triangle_count, "ba_linked_triangles"));
ba[i].linked_lines = static_cast<LineartEdge **>(
MEM_callocN(sizeof(LineartEdge *) * ba[i].max_line_count, "ba_linked_lines"));
ba[i].linked_triangles = MEM_calloc_arrayN<LineartTriangle *>(ba[i].max_triangle_count,
"ba_linked_triangles");
ba[i].linked_lines = MEM_calloc_arrayN<LineartEdge *>(ba[i].max_line_count, "ba_linked_lines");
BLI_spin_init(&ba[i].lock);
}
@@ -4334,8 +4326,8 @@ static void lineart_clear_linked_edges_recursive(LineartData *ld, LineartBoundin
}
root_ba->line_count = 0;
root_ba->max_line_count = 128;
root_ba->linked_lines = static_cast<LineartEdge **>(
MEM_callocN(sizeof(LineartEdge *) * root_ba->max_line_count, "cleared lineart edges"));
root_ba->linked_lines = MEM_calloc_arrayN<LineartEdge *>(root_ba->max_line_count,
"cleared lineart edges");
}
void lineart_main_clear_linked_edges(LineartData *ld)
{
@@ -4392,8 +4384,8 @@ static void lineart_main_remove_unused_lines_recursive(LineartBoundingArea *ba,
return;
}
LineartEdge **new_array = static_cast<LineartEdge **>(
MEM_callocN(sizeof(LineartEdge *) * usable_count, "cleaned lineart edge array"));
LineartEdge **new_array = MEM_calloc_arrayN<LineartEdge *>(size_t(usable_count),
"cleaned lineart edge array");
int new_i = 0;
for (int i = 0; i < ba->line_count; i++) {

3
source/blender/modifiers/intern/lineart/lineart_shadow.cc
View File

@@ -1173,8 +1173,7 @@ bool lineart_main_try_generate_shadow_v3(Depsgraph *depsgraph,
}
}
LineartData *ld = static_cast<LineartData *>(
MEM_mallocN(sizeof(LineartData), "LineArt render buffer copied"));
LineartData *ld = MEM_mallocN<LineartData>("LineArt render buffer copied");
memcpy(ld, original_ld, sizeof(LineartData));
BLI_spin_init(&ld->lock_task);