Cleanup: Voxel remesh function naming

- Remove BKE prefix for static functions
- Make specific intermediate functions static
- Avoid unecessary "_to_mesh_nomain" suffix

4 files changed, 59 insertions, 79 deletions

diff --git a/source/blender/blenkernel/BKE_mesh_remesh_voxel.h b/source/blender/blenkernel/BKE_mesh_remesh_voxel.h
index 3ada2eb6c6c..7fc776a5c5d 100644
--- a/source/blender/blenkernel/BKE_mesh_remesh_voxel.h
+++ b/source/blender/blenkernel/BKE_mesh_remesh_voxel.h
@@ -33,31 +33,19 @@ extern "C" {
 
 struct Mesh;
 
-/* OpenVDB Voxel Remesher */
-#ifdef WITH_OPENVDB
-struct OpenVDBLevelSet *BKE_mesh_remesh_voxel_ovdb_mesh_to_level_set_create(
-    struct Mesh *mesh, struct OpenVDBTransform *transform);
-struct Mesh *BKE_mesh_remesh_voxel_ovdb_volume_to_mesh_nomain(struct OpenVDBLevelSet *level_set,
-                                                              double isovalue,
-                                                              double adaptivity,
-                                                              bool relax_disoriented_triangles);
-#endif
-
 struct Mesh *BKE_mesh_remesh_voxel_fix_poles(struct Mesh *mesh);
-struct Mesh *BKE_mesh_remesh_voxel_to_mesh_nomain(struct Mesh *mesh,
-                                                  float voxel_size,
-                                                  float adaptivity,
-                                                  float isovalue);
-struct Mesh *BKE_mesh_remesh_quadriflow_to_mesh_nomain(struct Mesh *mesh,
-                                                       int target_faces,
-                                                       int seed,
-                                                       bool preserve_sharp,
-                                                       bool preserve_boundary,
-                                                       bool adaptive_scale,
-                                                       void (*update_cb)(void *,
-                                                                         float progress,
-                                                                         int *cancel),
-                                                       void *update_cb_data);
+struct Mesh *BKE_mesh_remesh_voxel(struct Mesh *mesh,
+                                   float voxel_size,
+                                   float adaptivity,
+                                   float isovalue);
+struct Mesh *BKE_mesh_remesh_quadriflow(struct Mesh *mesh,
+                                        int target_faces,
+                                        int seed,
+                                        bool preserve_sharp,
+                                        bool preserve_boundary,
+                                        bool adaptive_scale,
+                                        void (*update_cb)(void *, float progress, int *cancel),
+                                        void *update_cb_data);
 
 /* Data reprojection functions */
 void BKE_mesh_remesh_reproject_paint_mask(struct Mesh *target, struct Mesh *source);
diff --git a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc
index 9cb33bc17cb..4501ef74055 100644
--- a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc
+++ b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc
@@ -64,14 +64,14 @@ using blender::float3;
 using blender::IndexRange;
 
 #ifdef WITH_QUADRIFLOW
-static Mesh *BKE_mesh_remesh_quadriflow(Mesh *input_mesh,
-                                        int target_faces,
-                                        int seed,
-                                        bool preserve_sharp,
-                                        bool preserve_boundary,
-                                        bool adaptive_scale,
-                                        void (*update_cb)(void *, float progress, int *cancel),
-                                        void *update_cb_data)
+static Mesh *remesh_quadriflow(Mesh *input_mesh,
+                               int target_faces,
+                               int seed,
+                               bool preserve_sharp,
+                               bool preserve_boundary,
+                               bool adaptive_scale,
+                               void (*update_cb)(void *, float progress, int *cancel),
+                               void *update_cb_data)
 {
   /* Ensure that the triangulated mesh data is up to data */
   BKE_mesh_runtime_looptri_recalc(input_mesh);
@@ -162,30 +162,27 @@ static Mesh *BKE_mesh_remesh_quadriflow(Mesh *input_mesh,
 }
 #endif
 
-Mesh *BKE_mesh_remesh_quadriflow_to_mesh_nomain(Mesh *mesh,
-                                                int target_faces,
-                                                int seed,
-                                                bool preserve_sharp,
-                                                bool preserve_boundary,
-                                                bool adaptive_scale,
-                                                void (*update_cb)(void *,
-                                                                  float progress,
-                                                                  int *cancel),
-                                                void *update_cb_data)
+Mesh *BKE_mesh_remesh_quadriflow(Mesh *mesh,
+                                 int target_faces,
+                                 int seed,
+                                 bool preserve_sharp,
+                                 bool preserve_boundary,
+                                 bool adaptive_scale,
+                                 void (*update_cb)(void *, float progress, int *cancel),
+                                 void *update_cb_data)
 {
-  Mesh *new_mesh = nullptr;
 #ifdef WITH_QUADRIFLOW
   if (target_faces <= 0) {
     target_faces = -1;
   }
-  new_mesh = BKE_mesh_remesh_quadriflow(mesh,
-                                        target_faces,
-                                        seed,
-                                        preserve_sharp,
-                                        preserve_boundary,
-                                        adaptive_scale,
-                                        update_cb,
-                                        update_cb_data);
+  return remesh_quadriflow(mesh,
+                           target_faces,
+                           seed,
+                           preserve_sharp,
+                           preserve_boundary,
+                           adaptive_scale,
+                           update_cb,
+                           update_cb_data);
 #else
   UNUSED_VARS(mesh,
               target_faces,
@@ -195,13 +192,13 @@ Mesh *BKE_mesh_remesh_quadriflow_to_mesh_nomain(Mesh *mesh,
               adaptive_scale,
               update_cb,
               update_cb_data);
+  return nullptr;
 #endif
-  return new_mesh;
 }
 
 #ifdef WITH_OPENVDB
-struct OpenVDBLevelSet *BKE_mesh_remesh_voxel_ovdb_mesh_to_level_set_create(
-    Mesh *mesh, struct OpenVDBTransform *transform)
+static struct OpenVDBLevelSet *remesh_voxel_level_set_create(Mesh *mesh,
+                                                             struct OpenVDBTransform *transform)
 {
   BKE_mesh_runtime_looptri_recalc(mesh);
   const MLoopTri *looptri = BKE_mesh_runtime_looptri_ensure(mesh);
@@ -235,10 +232,10 @@ struct OpenVDBLevelSet *BKE_mesh_remesh_voxel_ovdb_mesh_to_level_set_create(
   return level_set;
 }
 
-Mesh *BKE_mesh_remesh_voxel_ovdb_volume_to_mesh_nomain(struct OpenVDBLevelSet *level_set,
-                                                       double isovalue,
-                                                       double adaptivity,
-                                                       bool relax_disoriented_triangles)
+static Mesh *remesh_voxel_volume_to_mesh(struct OpenVDBLevelSet *level_set,
+                                         double isovalue,
+                                         double adaptivity,
+                                         bool relax_disoriented_triangles)
 {
   struct OpenVDBVolumeToMeshData output_mesh;
   OpenVDBLevelSet_volume_to_mesh(
@@ -291,25 +288,21 @@ Mesh *BKE_mesh_remesh_voxel_ovdb_volume_to_mesh_nomain(struct OpenVDBLevelSet *l
 }
 #endif
 
-Mesh *BKE_mesh_remesh_voxel_to_mesh_nomain(Mesh *mesh,
-                                           float voxel_size,
-                                           float adaptivity,
-                                           float isovalue)
+Mesh *BKE_mesh_remesh_voxel(Mesh *mesh, float voxel_size, float adaptivity, float isovalue)
 {
-  Mesh *new_mesh = nullptr;
 #ifdef WITH_OPENVDB
-  struct OpenVDBLevelSet *level_set;
   struct OpenVDBTransform *xform = OpenVDBTransform_create();
   OpenVDBTransform_create_linear_transform(xform, (double)voxel_size);
-  level_set = BKE_mesh_remesh_voxel_ovdb_mesh_to_level_set_create(mesh, xform);
-  new_mesh = BKE_mesh_remesh_voxel_ovdb_volume_to_mesh_nomain(
+  struct OpenVDBLevelSet *level_set = remesh_voxel_level_set_create(mesh, xform);
+  Mesh *new_mesh = remesh_voxel_volume_to_mesh(
       level_set, (double)isovalue, (double)adaptivity, false);
   OpenVDBLevelSet_free(level_set);
   OpenVDBTransform_free(xform);
+  return new_mesh;
 #else
   UNUSED_VARS(mesh, voxel_size, adaptivity, isovalue);
+  return nullptr;
 #endif
-  return new_mesh;
 }
 
 void BKE_mesh_remesh_reproject_paint_mask(Mesh *target, Mesh *source)
diff --git a/source/blender/editors/object/object_remesh.cc b/source/blender/editors/object/object_remesh.cc
index 6bee04e2b4f..eb9a6a5856d 100644
--- a/source/blender/editors/object/object_remesh.cc
+++ b/source/blender/editors/object/object_remesh.cc
@@ -151,7 +151,7 @@ static int voxel_remesh_exec(bContext *C, wmOperator *op)
     isovalue = mesh->remesh_voxel_size * 0.3f;
   }
 
-  new_mesh = BKE_mesh_remesh_voxel_to_mesh_nomain(
+  new_mesh = BKE_mesh_remesh_voxel(
       mesh, mesh->remesh_voxel_size, mesh->remesh_voxel_adaptivity, isovalue);
 
   if (!new_mesh) {
@@ -853,19 +853,18 @@ static void quadriflow_start_job(void *customdata, short *stop, short *do_update
   /* Bisect the input mesh using the paint symmetry settings */
   bisect_mesh = remesh_symmetry_bisect(bisect_mesh, qj->symmetry_axes);
 
-  new_mesh = BKE_mesh_remesh_quadriflow_to_mesh_nomain(
-      bisect_mesh,
-      qj->target_faces,
-      qj->seed,
-      qj->use_preserve_sharp,
-      (qj->use_preserve_boundary || qj->use_mesh_symmetry),
+  new_mesh = BKE_mesh_remesh_quadriflow(bisect_mesh,
+                                        qj->target_faces,
+                                        qj->seed,
+                                        qj->use_preserve_sharp,
+                                        (qj->use_preserve_boundary || qj->use_mesh_symmetry),
 #ifdef USE_MESH_CURVATURE
-      qj->use_mesh_curvature,
+                                        qj->use_mesh_curvature,
 #else
-      false,
+                                        false,
 #endif
-      quadriflow_update_job,
-      (void *)qj);
+                                        quadriflow_update_job,
+                                        (void *)qj);
 
   BKE_id_free(nullptr, bisect_mesh);
 
diff --git a/source/blender/modifiers/intern/MOD_remesh.c b/source/blender/modifiers/intern/MOD_remesh.c
index 4677a9bc253..df3db894f4e 100644
--- a/source/blender/modifiers/intern/MOD_remesh.c
+++ b/source/blender/modifiers/intern/MOD_remesh.c
@@ -159,7 +159,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *UNUSED(ctx)
     if (rmd->voxel_size == 0.0f) {
       return NULL;
     }
-    result = BKE_mesh_remesh_voxel_to_mesh_nomain(mesh, rmd->voxel_size, rmd->adaptivity, 0.0f);
+    result = BKE_mesh_remesh_voxel(mesh, rmd->voxel_size, rmd->adaptivity, 0.0f);
     if (result == NULL) {
       return NULL;
     }