[Bf-blender-cvs] [d4f77c22661] master: Cleanup: Move shrinkwrap.c to C++
Hans Goudey
noreply at git.blender.org
Thu Oct 6 22:48:37 CEST 2022
Commit: d4f77c22661c316bdaada2ff053f1484412ccb83
Author: Hans Goudey
Date: Thu Oct 6 15:15:49 2022 -0500
Branches: master
https://developer.blender.org/rBd4f77c22661c316bdaada2ff053f1484412ccb83
Cleanup: Move shrinkwrap.c to C++
===================================================================
M source/blender/blenkernel/CMakeLists.txt
R090 source/blender/blenkernel/intern/shrinkwrap.c source/blender/blenkernel/intern/shrinkwrap.cc
===================================================================
diff --git a/source/blender/blenkernel/CMakeLists.txt b/source/blender/blenkernel/CMakeLists.txt
index 192acbf8338..a58fc22b880 100644
--- a/source/blender/blenkernel/CMakeLists.txt
+++ b/source/blender/blenkernel/CMakeLists.txt
@@ -259,7 +259,7 @@ set(SRC
intern/scene.cc
intern/screen.c
intern/shader_fx.c
- intern/shrinkwrap.c
+ intern/shrinkwrap.cc
intern/simulation.cc
intern/softbody.c
intern/sound.c
diff --git a/source/blender/blenkernel/intern/shrinkwrap.c b/source/blender/blenkernel/intern/shrinkwrap.cc
similarity index 90%
rename from source/blender/blenkernel/intern/shrinkwrap.c
rename to source/blender/blenkernel/intern/shrinkwrap.cc
index f94836551bb..2b8af00d281 100644
--- a/source/blender/blenkernel/intern/shrinkwrap.c
+++ b/source/blender/blenkernel/intern/shrinkwrap.cc
@@ -5,12 +5,12 @@
* \ingroup bke
*/
-#include <float.h>
-#include <math.h>
+#include <cfloat>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
#include <memory.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
#include "DNA_gpencil_modifier_types.h"
#include "DNA_mesh_types.h"
@@ -54,30 +54,30 @@
/* Util macros */
#define OUT_OF_MEMORY() ((void)printf("Shrinkwrap: Out of memory\n"))
-typedef struct ShrinkwrapCalcData {
+struct ShrinkwrapCalcData {
ShrinkwrapModifierData *smd; /* shrinkwrap modifier data */
- struct Object *ob; /* object we are applying shrinkwrap to */
+ Object *ob; /* object we are applying shrinkwrap to */
- struct MVert *vert; /* Array of verts being projected. */
+ MVert *vert; /* Array of verts being projected. */
const float (*vert_normals)[3];
float (*vertexCos)[3]; /* vertexs being shrinkwraped */
int numVerts;
- const struct MDeformVert *dvert; /* Pointer to mdeform array */
- int vgroup; /* Vertex group num */
- bool invert_vgroup; /* invert vertex group influence */
+ const MDeformVert *dvert; /* Pointer to mdeform array */
+ int vgroup; /* Vertex group num */
+ bool invert_vgroup; /* invert vertex group influence */
- struct Mesh *target; /* mesh we are shrinking to */
- struct SpaceTransform local2target; /* transform to move between local and target space */
- struct ShrinkwrapTreeData *tree; /* mesh BVH tree data */
+ Mesh *target; /* mesh we are shrinking to */
+ SpaceTransform local2target; /* transform to move between local and target space */
+ ShrinkwrapTreeData *tree; /* mesh BVH tree data */
- struct Object *aux_target;
+ Object *aux_target;
float keepDist; /* Distance to keep above target surface (units are in local space) */
-} ShrinkwrapCalcData;
+};
-typedef struct ShrinkwrapCalcCBData {
+struct ShrinkwrapCalcCBData {
ShrinkwrapCalcData *calc;
ShrinkwrapTreeData *tree;
@@ -85,7 +85,7 @@ typedef struct ShrinkwrapCalcCBData {
float *proj_axis;
SpaceTransform *local2aux;
-} ShrinkwrapCalcCBData;
+};
bool BKE_shrinkwrap_needs_normals(int shrinkType, int shrinkMode)
{
@@ -99,7 +99,7 @@ bool BKE_shrinkwrap_init_tree(
{
memset(data, 0, sizeof(*data));
- if (mesh == NULL) {
+ if (mesh == nullptr) {
return false;
}
@@ -118,7 +118,7 @@ bool BKE_shrinkwrap_init_tree(
if (shrinkType == MOD_SHRINKWRAP_NEAREST_VERTEX) {
data->bvh = BKE_bvhtree_from_mesh_get(&data->treeData, mesh, BVHTREE_FROM_VERTS, 2);
- return data->bvh != NULL;
+ return data->bvh != nullptr;
}
if (mesh->totpoly <= 0) {
@@ -127,14 +127,14 @@ bool BKE_shrinkwrap_init_tree(
data->bvh = BKE_bvhtree_from_mesh_get(&data->treeData, mesh, BVHTREE_FROM_LOOPTRI, 4);
- if (data->bvh == NULL) {
+ if (data->bvh == nullptr) {
return false;
}
if (force_normals || BKE_shrinkwrap_needs_normals(shrinkType, shrinkMode)) {
data->pnors = BKE_mesh_poly_normals_ensure(mesh);
if ((mesh->flag & ME_AUTOSMOOTH) != 0) {
- data->clnors = CustomData_get_layer(&mesh->ldata, CD_NORMAL);
+ data->clnors = static_cast<const float(*)[3]>(CustomData_get_layer(&mesh->ldata, CD_NORMAL));
}
}
@@ -150,11 +150,11 @@ void BKE_shrinkwrap_free_tree(ShrinkwrapTreeData *data)
free_bvhtree_from_mesh(&data->treeData);
}
-void BKE_shrinkwrap_discard_boundary_data(struct Mesh *mesh)
+void BKE_shrinkwrap_discard_boundary_data(Mesh *mesh)
{
- struct ShrinkwrapBoundaryData *data = mesh->runtime.shrinkwrap_data;
+ ShrinkwrapBoundaryData *data = mesh->runtime.shrinkwrap_data;
- if (data != NULL) {
+ if (data != nullptr) {
MEM_freeN((void *)data->edge_is_boundary);
MEM_freeN((void *)data->looptri_has_boundary);
MEM_freeN((void *)data->vert_boundary_id);
@@ -163,7 +163,7 @@ void BKE_shrinkwrap_discard_boundary_data(struct Mesh *mesh)
MEM_freeN(data);
}
- mesh->runtime.shrinkwrap_data = NULL;
+ mesh->runtime.shrinkwrap_data = nullptr;
}
/* Accumulate edge for average boundary edge direction. */
@@ -190,14 +190,15 @@ static void merge_vert_dir(ShrinkwrapBoundaryVertData *vdata,
status[index] = (status[index] == 0) ? side : -1;
}
-static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(struct Mesh *mesh)
+static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(Mesh *mesh)
{
const MVert *mvert = BKE_mesh_verts(mesh);
const MEdge *medge = BKE_mesh_edges(mesh);
const MLoop *mloop = BKE_mesh_loops(mesh);
/* Count faces per edge (up to 2). */
- char *edge_mode = MEM_calloc_arrayN((size_t)mesh->totedge, sizeof(char), __func__);
+ char *edge_mode = static_cast<char *>(
+ MEM_calloc_arrayN((size_t)mesh->totedge, sizeof(char), __func__));
for (int i = 0; i < mesh->totloop; i++) {
uint eidx = mloop[i].e;
@@ -221,16 +222,15 @@ static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(struct Mesh *mesh)
}
}
- /* If no boundary, return NULL. */
+ /* If no boundary, return nullptr. */
if (num_boundary_edges == 0) {
MEM_freeN(edge_is_boundary);
MEM_freeN(edge_mode);
- return NULL;
+ return nullptr;
}
/* Allocate the data object. */
- ShrinkwrapBoundaryData *data = MEM_callocN(sizeof(ShrinkwrapBoundaryData),
- "ShrinkwrapBoundaryData");
+ ShrinkwrapBoundaryData *data = MEM_cnew<ShrinkwrapBoundaryData>(__func__);
data->edge_is_boundary = edge_is_boundary;
@@ -256,8 +256,8 @@ static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(struct Mesh *mesh)
data->looptri_has_boundary = looptri_has_boundary;
/* Find boundary vertices and build a mapping table for compact storage of data. */
- int *vert_boundary_id = MEM_calloc_arrayN(
- (size_t)mesh->totvert, sizeof(int), "ShrinkwrapBoundaryData::vert_boundary_id");
+ int *vert_boundary_id = static_cast<int *>(
+ MEM_calloc_arrayN((size_t)mesh->totvert, sizeof(int), __func__));
for (int i = 0; i < mesh->totedge; i++) {
if (edge_mode[i]) {
@@ -278,10 +278,11 @@ static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(struct Mesh *mesh)
data->num_boundary_verts = num_boundary_verts;
/* Compute average directions. */
- ShrinkwrapBoundaryVertData *boundary_verts = MEM_calloc_arrayN(
- num_boundary_verts, sizeof(*boundary_verts), "ShrinkwrapBoundaryData::boundary_verts");
+ ShrinkwrapBoundaryVertData *boundary_verts = static_cast<ShrinkwrapBoundaryVertData *>(
+ MEM_calloc_arrayN(num_boundary_verts, sizeof(*boundary_verts), __func__));
- signed char *vert_status = MEM_calloc_arrayN(num_boundary_verts, sizeof(char), __func__);
+ signed char *vert_status = static_cast<signed char *>(
+ MEM_calloc_arrayN(num_boundary_verts, sizeof(char), __func__));
for (int i = 0; i < mesh->totedge; i++) {
if (edge_mode[i]) {
@@ -321,7 +322,7 @@ static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(struct Mesh *mesh)
return data;
}
-void BKE_shrinkwrap_compute_boundary_data(struct Mesh *mesh)
+void BKE_shrinkwrap_compute_boundary_data(Mesh *mesh)
{
BKE_shrinkwrap_discard_boundary_data(mesh);
@@ -338,11 +339,11 @@ static void shrinkwrap_calc_nearest_vertex_cb_ex(void *__restrict userdata,
const int i,
const TaskParallelTLS *__restrict tls)
{
- ShrinkwrapCalcCBData *data = userdata;
+ ShrinkwrapCalcCBData *data = static_cast<ShrinkwrapCalcCBData *>(userdata);
ShrinkwrapCalcData *calc = data->calc;
BVHTreeFromMesh *treeData = &data->tree->treeData;
- BVHTreeNearest *nearest = tls->userdata_chunk;
+ BVHTreeNearest *nearest = static_cast<BVHTreeNearest *>(tls->userdata_chunk);
float *co = calc->vertexCos[i];
float tmp_co[3];
@@ -404,10 +405,9 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
nearest.index = -1;
nearest.dist_sq = FLT_MAX;
- ShrinkwrapCalcCBData data = {
- .calc = calc,
- .tree = calc->tree,
- };
+ ShrinkwrapCalcCBData data{};
+ data.calc = calc;
+ data.tree = calc->tree;
TaskParallelSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
@@ -496,7 +496,7 @@ static void shrinkwrap_calc_normal_projection_cb_ex(void *__restrict userdata,
const int i,
const TaskParallelTLS *__restrict tls)
{
- ShrinkwrapCalcCBData *data = userdata;
+ ShrinkwrapCalcCBData *data = static_cast<ShrinkwrapCalcCBData *>(userdata);
ShrinkwrapCalcData *calc = data->calc;
ShrinkwrapTreeData *tree = data->tree;
@@ -505,7 +505,7 @@ static void shrinkwrap_calc_normal_projection_cb_ex(void *__restrict userdata,
float *proj_axis = data->proj_axis;
SpaceTransform *local2aux = data->local2aux;
- BVHTreeRayHit *hit = tls->userdata_chunk;
+ BVHTreeRayHit *hit = static_cast<BVHTreeRayHit *>(tls->userdata_chunk);
const float proj_limit_squared = calc->smd->projLimit * calc->smd->projLimit;
float *co = calc->vertexCos[i];
@@ -520,7 +520,7 @@ static void shrinkwrap_calc_normal_projection_cb_ex(void *__restrict userdata,
return;
}
- if (calc->vert != NULL && calc->smd
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list