Cleanup: Move mesh_convert.c to C++

This should allow easier changes when it's helpful to use C++ types. The diff is for a test on the buildbot. Differential Revision: https://developer.blender.org/D12528
2021-09-16 15:44:43 -05:00
parent 7a9cfd08a8
commit 8e2e44b58b
2 changed files with 144 additions and 138 deletions
--- a/source/blender/blenkernel/CMakeLists.txt
+++ b/source/blender/blenkernel/CMakeLists.txt
@@ -186,7 +186,7 @@ set(SRC
  intern/mball_tessellate.c
  intern/mesh.c
  intern/mesh_boolean_convert.cc
-  intern/mesh_convert.c
+  intern/mesh_convert.cc
  intern/mesh_evaluate.cc
  intern/mesh_fair.cc
  intern/mesh_iterators.c
--- a/source/blender/blenkernel/intern/mesh_convert.cc
+++ b/source/blender/blenkernel/intern/mesh_convert.cc
@@ -68,7 +68,7 @@

 #ifdef VALIDATE_MESH
 #  define ASSERT_IS_VALID_MESH(mesh) \
-    (BLI_assert((mesh == NULL) || (BKE_mesh_is_valid(mesh) == true)))
+    (BLI_assert((mesh == nullptr) || (BKE_mesh_is_valid(mesh) == true)))
 #else
 #  define ASSERT_IS_VALID_MESH(mesh)
 #endif
@@ -84,15 +84,16 @@ void BKE_mesh_from_metaball(ListBase *lb, Mesh *me)
  const float *nors, *verts;
  int a, *index;

-  dl = lb->first;
-  if (dl == NULL) {
+  dl = (DispList *)lb->first;
+  if (dl == nullptr) {
    return;
  }

  if (dl->type == DL_INDEX4) {
-    mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, dl->nr);
-    allloop = mloop = CustomData_add_layer(&me->ldata, CD_MLOOP, CD_CALLOC, NULL, dl->parts * 4);
-    mpoly = CustomData_add_layer(&me->pdata, CD_MPOLY, CD_CALLOC, NULL, dl->parts);
+    mvert = (MVert *)CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, nullptr, dl->nr);
+    allloop = mloop = (MLoop *)CustomData_add_layer(
+        &me->ldata, CD_MLOOP, CD_CALLOC, nullptr, dl->parts * 4);
+    mpoly = (MPoly *)CustomData_add_layer(&me->pdata, CD_MPOLY, CD_CALLOC, nullptr, dl->parts);
    me->mvert = mvert;
    me->mloop = mloop;
    me->mpoly = mpoly;
@@ -177,9 +178,10 @@ static void make_edges_mdata_extend(
    MEdge *medge;
    uint e_index = totedge;

-    *r_alledge = medge = (*r_alledge ?
-                              MEM_reallocN(*r_alledge, sizeof(MEdge) * (totedge + totedge_new)) :
-                              MEM_calloc_arrayN(totedge_new, sizeof(MEdge), __func__));
+    *r_alledge = medge = (MEdge *)(*r_alledge ?
+                                       MEM_reallocN(*r_alledge,
+                                                    sizeof(MEdge) * (totedge + totedge_new)) :
+                                       MEM_calloc_arrayN(totedge_new, sizeof(MEdge), __func__));
    medge += totedge;

    totedge += totedge_new;
@@ -209,7 +211,7 @@ static void make_edges_mdata_extend(
    }
  }

-  BLI_edgehash_free(eh, NULL);
+  BLI_edgehash_free(eh, nullptr);
 }

 /* Initialize mverts, medges and, faces for converting nurbs to mesh and derived mesh */
@@ -229,7 +231,7 @@ static int mesh_nurbs_displist_to_mdata(const Curve *cu,
  MVert *mvert;
  MPoly *mpoly;
  MLoop *mloop;
-  MLoopUV *mloopuv = NULL;
+  MLoopUV *mloopuv = nullptr;
  MEdge *medge;
  const float *data;
  int a, b, ofs, vertcount, startvert, totvert = 0, totedge = 0, totloop = 0, totpoly = 0;
@@ -277,14 +279,15 @@ static int mesh_nurbs_displist_to_mdata(const Curve *cu,
    return -1;
  }

-  *r_allvert = mvert = MEM_calloc_arrayN(totvert, sizeof(MVert), "nurbs_init mvert");
-  *r_alledge = medge = MEM_calloc_arrayN(totedge, sizeof(MEdge), "nurbs_init medge");
-  *r_allloop = mloop = MEM_calloc_arrayN(
+  *r_allvert = mvert = (MVert *)MEM_calloc_arrayN(totvert, sizeof(MVert), "nurbs_init mvert");
+  *r_alledge = medge = (MEdge *)MEM_calloc_arrayN(totedge, sizeof(MEdge), "nurbs_init medge");
+  *r_allloop = mloop = (MLoop *)MEM_calloc_arrayN(
      totpoly, sizeof(MLoop[4]), "nurbs_init mloop"); /* totloop */
-  *r_allpoly = mpoly = MEM_calloc_arrayN(totpoly, sizeof(MPoly), "nurbs_init mloop");
+  *r_allpoly = mpoly = (MPoly *)MEM_calloc_arrayN(totpoly, sizeof(MPoly), "nurbs_init mloop");

  if (r_alluv) {
-    *r_alluv = mloopuv = MEM_calloc_arrayN(totpoly, sizeof(MLoopUV[4]), "nurbs_init mloopuv");
+    *r_alluv = mloopuv = (MLoopUV *)MEM_calloc_arrayN(
+        totpoly, sizeof(MLoopUV[4]), "nurbs_init mloopuv");
  }

  /* verts and faces */
@@ -500,13 +503,13 @@ static void mesh_copy_texture_space_from_curve_type(const Curve *cu, Mesh *me)

 Mesh *BKE_mesh_new_nomain_from_curve_displist(const Object *ob, const ListBase *dispbase)
 {
-  const Curve *cu = ob->data;
+  const Curve *cu = (const Curve *)ob->data;
  Mesh *mesh;
  MVert *allvert;
  MEdge *alledge;
  MLoop *allloop;
  MPoly *allpoly;
-  MLoopUV *alluv = NULL;
+  MLoopUV *alluv = nullptr;
  int totvert, totedge, totloop, totpoly;

  if (mesh_nurbs_displist_to_mdata(cu,
@@ -561,7 +564,7 @@ Mesh *BKE_mesh_new_nomain_from_curve_displist(const Object *ob, const ListBase *

 Mesh *BKE_mesh_new_nomain_from_curve(const Object *ob)
 {
-  ListBase disp = {NULL, NULL};
+  ListBase disp = {nullptr, nullptr};

  if (ob->runtime.curve_cache) {
    disp = ob->runtime.curve_cache->disp;
@@ -578,16 +581,16 @@ static void mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, const char

  Mesh *me_eval = (Mesh *)ob->runtime.data_eval;
  Mesh *me;
-  MVert *allvert = NULL;
-  MEdge *alledge = NULL;
-  MLoop *allloop = NULL;
-  MLoopUV *alluv = NULL;
-  MPoly *allpoly = NULL;
+  MVert *allvert = nullptr;
+  MEdge *alledge = nullptr;
+  MLoop *allloop = nullptr;
+  MLoopUV *alluv = nullptr;
+  MPoly *allpoly = nullptr;
  int totvert, totedge, totloop, totpoly;

-  Curve *cu = ob->data;
+  Curve *cu = (Curve *)ob->data;

-  if (me_eval == NULL) {
+  if (me_eval == nullptr) {
    if (mesh_nurbs_displist_to_mdata(cu,
                                     dispbase,
                                     &allvert,
@@ -604,30 +607,34 @@ static void mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, const char
    }

    /* make mesh */
-    me = BKE_id_new_nomain(ID_ME, obdata_name);
+    me = (Mesh *)BKE_id_new_nomain(ID_ME, obdata_name);

    me->totvert = totvert;
    me->totedge = totedge;
    me->totloop = totloop;
    me->totpoly = totpoly;

-    me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, allvert, me->totvert);
-    me->medge = CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, alledge, me->totedge);
-    me->mloop = CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, allloop, me->totloop);
-    me->mpoly = CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, allpoly, me->totpoly);
+    me->mvert = (MVert *)CustomData_add_layer(
+        &me->vdata, CD_MVERT, CD_ASSIGN, allvert, me->totvert);
+    me->medge = (MEdge *)CustomData_add_layer(
+        &me->edata, CD_MEDGE, CD_ASSIGN, alledge, me->totedge);
+    me->mloop = (MLoop *)CustomData_add_layer(
+        &me->ldata, CD_MLOOP, CD_ASSIGN, allloop, me->totloop);
+    me->mpoly = (MPoly *)CustomData_add_layer(
+        &me->pdata, CD_MPOLY, CD_ASSIGN, allpoly, me->totpoly);

    if (alluv) {
      const char *uvname = "UVMap";
-      me->mloopuv = CustomData_add_layer_named(
+      me->mloopuv = (MLoopUV *)CustomData_add_layer_named(
          &me->ldata, CD_MLOOPUV, CD_ASSIGN, alluv, me->totloop, uvname);
    }

    BKE_mesh_calc_normals(me);
  }
  else {
-    me = BKE_id_new_nomain(ID_ME, obdata_name);
+    me = (Mesh *)BKE_id_new_nomain(ID_ME, obdata_name);

-    ob->runtime.data_eval = NULL;
+    ob->runtime.data_eval = nullptr;
    BKE_mesh_nomain_to_mesh(me_eval, me, ob, &CD_MASK_MESH, true);
  }

@@ -636,7 +643,7 @@ static void mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, const char

  mesh_copy_texture_space_from_curve_type(cu, me);

-  cu->mat = NULL;
+  cu->mat = nullptr;
  cu->totcol = 0;

  /* Do not decrement ob->data usercount here,
@@ -647,29 +654,29 @@ static void mesh_from_nurbs_displist(Object *ob, ListBase *dispbase, const char
  /* For temporary objects in BKE_mesh_new_from_object don't remap
   * the entire scene with associated depsgraph updates, which are
   * problematic for renderers exporting data. */
-  BKE_id_free(NULL, cu);
+  BKE_id_free(nullptr, cu);
 }

-typedef struct EdgeLink {
+struct EdgeLink {
  struct EdgeLink *next, *prev;
  void *edge;
-} EdgeLink;
+};

-typedef struct VertLink {
+struct VertLink {
  Link *next, *prev;
  uint index;
-} VertLink;
+};

 static void prependPolyLineVert(ListBase *lb, uint index)
 {
-  VertLink *vl = MEM_callocN(sizeof(VertLink), "VertLink");
+  VertLink *vl = (VertLink *)MEM_callocN(sizeof(VertLink), "VertLink");
  vl->index = index;
  BLI_addhead(lb, vl);
 }

 static void appendPolyLineVert(ListBase *lb, uint index)
 {
-  VertLink *vl = MEM_callocN(sizeof(VertLink), "VertLink");
+  VertLink *vl = (VertLink *)MEM_callocN(sizeof(VertLink), "VertLink");
  vl->index = index;
  BLI_addtail(lb, vl);
 }
@@ -689,10 +696,10 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
  /* only to detect edge polylines */
  int *edge_users;

-  ListBase edges = {NULL, NULL};
+  ListBase edges = {nullptr, nullptr};

  /* get boundary edges */
-  edge_users = MEM_calloc_arrayN(medge_len, sizeof(int), __func__);
+  edge_users = (int *)MEM_calloc_arrayN(medge_len, sizeof(int), __func__);
  for (i = 0, mp = mpoly; i < mpoly_len; i++, mp++) {
    MLoop *ml = &mloop[mp->loopstart];
    int j;
@@ -705,7 +712,7 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
  med = medge;
  for (i = 0; i < medge_len; i++, med++) {
    if (edge_users[i] == edge_users_test) {
-      EdgeLink *edl = MEM_callocN(sizeof(EdgeLink), "EdgeLink");
+      EdgeLink *edl = (EdgeLink *)MEM_callocN(sizeof(EdgeLink), "EdgeLink");
      edl->edge = med;

      BLI_addtail(&edges, edl);
@@ -718,10 +725,10 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
    while (edges.first) {
      /* each iteration find a polyline and add this as a nurbs poly spline */

-      ListBase polyline = {NULL, NULL}; /* store a list of VertLink's */
+      ListBase polyline = {nullptr, nullptr}; /* store a list of VertLink's */
      bool closed = false;
      int totpoly = 0;
-      MEdge *med_current = ((EdgeLink *)edges.last)->edge;
+      MEdge *med_current = (MEdge *)((EdgeLink *)edges.last)->edge;
      uint startVert = med_current->v1;
      uint endVert = med_current->v2;
      bool ok = true;
@@ -734,12 +741,12 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
      totedges--;

      while (ok) { /* while connected edges are found... */
-        EdgeLink *edl = edges.last;
+        EdgeLink *edl = (EdgeLink *)edges.last;
        ok = false;
        while (edl) {
          EdgeLink *edl_prev = edl->prev;

-          med = edl->edge;
+          med = (MEdge *)edl->edge;

          if (med->v1 == endVert) {
            endVert = med->v2;
@@ -803,7 +810,7 @@ void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int ed
        nu->bp = (BPoint *)MEM_calloc_arrayN(totpoly, sizeof(BPoint), "bpoints");

        /* add points */
-        vl = polyline.first;
+        vl = (VertLink *)polyline.first;
        for (i = 0, bp = nu->bp; i < totpoly; i++, bp++, vl = (VertLink *)vl->next) {
          copy_v3_v3(bp->vec, mvert[vl->index].co);
          bp->f1 = SELECT;
@@ -825,7 +832,7 @@ void BKE_mesh_to_curve(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene),
  Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
  Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
  Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
-  ListBase nurblist = {NULL, NULL};
+  ListBase nurblist = {nullptr, nullptr};

  BKE_mesh_to_curve_nurblist(me_eval, &nurblist, 0);
  BKE_mesh_to_curve_nurblist(me_eval, &nurblist, 1);
@@ -846,16 +853,13 @@ void BKE_mesh_to_curve(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(scene),

 void BKE_pointcloud_from_mesh(Mesh *me, PointCloud *pointcloud)
 {
-  BLI_assert(me != NULL);
+  BLI_assert(me != nullptr);

  pointcloud->totpoint = me->totvert;
  CustomData_realloc(&pointcloud->pdata, pointcloud->totpoint);

  /* Copy over all attributes. */
-  const CustomData_MeshMasks mask = {
-      .vmask = CD_MASK_PROP_ALL,
-  };
-  CustomData_merge(&me->vdata, &pointcloud->pdata, mask.vmask, CD_DUPLICATE, me->totvert);
+  CustomData_merge(&me->vdata, &pointcloud->pdata, CD_MASK_PROP_ALL, CD_DUPLICATE, me->totvert);
  BKE_pointcloud_update_customdata_pointers(pointcloud);
  CustomData_update_typemap(&pointcloud->pdata);

@@ -874,7 +878,7 @@ void BKE_mesh_to_pointcloud(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(sce
  Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
  Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);

-  PointCloud *pointcloud = BKE_pointcloud_add(bmain, ob->id.name + 2);
+  PointCloud *pointcloud = (PointCloud *)BKE_pointcloud_add(bmain, ob->id.name + 2);

  BKE_pointcloud_from_mesh(me_eval, pointcloud);

@@ -889,24 +893,22 @@ void BKE_mesh_to_pointcloud(Main *bmain, Depsgraph *depsgraph, Scene *UNUSED(sce

 void BKE_mesh_from_pointcloud(const PointCloud *pointcloud, Mesh *me)
 {
-  BLI_assert(pointcloud != NULL);
+  BLI_assert(pointcloud != nullptr);

  me->totvert = pointcloud->totpoint;

  /* Merge over all attributes. */
-  const CustomData_MeshMasks mask = {
-      .vmask = CD_MASK_PROP_ALL,
-  };
-  CustomData_merge(&pointcloud->pdata, &me->vdata, mask.vmask, CD_DUPLICATE, pointcloud->totpoint);
+  CustomData_merge(
+      &pointcloud->pdata, &me->vdata, CD_MASK_PROP_ALL, CD_DUPLICATE, pointcloud->totpoint);

  /* Convert the Position attribute to a mesh vertex. */
-  me->mvert = CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, NULL, me->totvert);
+  me->mvert = (MVert *)CustomData_add_layer(&me->vdata, CD_MVERT, CD_CALLOC, nullptr, me->totvert);
  CustomData_update_typemap(&me->vdata);

  const int layer_idx = CustomData_get_named_layer_index(
      &me->vdata, CD_PROP_FLOAT3, POINTCLOUD_ATTR_POSITION);
  CustomDataLayer *pos_layer = &me->vdata.layers[layer_idx];
-  float(*positions)[3] = pos_layer->data;
+  float(*positions)[3] = (float(*)[3])pos_layer->data;

  MVert *mvert;
  mvert = me->mvert;
@@ -956,7 +958,8 @@ static Object *object_for_curve_to_mesh_create(Object *object)
  Curve *curve = (Curve *)object->data;

  /* Create object itself. */
-  Object *temp_object = (Object *)BKE_id_copy_ex(NULL, &object->id, NULL, LIB_ID_COPY_LOCALIZE);
+  Object *temp_object = (Object *)BKE_id_copy_ex(
+      nullptr, &object->id, nullptr, LIB_ID_COPY_LOCALIZE);

  /* Remove all modifiers, since we don't want them to be applied. */
  BKE_object_free_modifiers(temp_object, LIB_ID_CREATE_NO_USER_REFCOUNT);
@@ -965,26 +968,27 @@ static Object *object_for_curve_to_mesh_create(Object *object)
   *
   * Note that there are extra fields in there like bevel and path, but those are not needed during
   * conversion, so they are not copied to save unnecessary allocations. */
-  if (temp_object->runtime.curve_cache == NULL) {
-    temp_object->runtime.curve_cache = MEM_callocN(sizeof(CurveCache),
-                                                   "CurveCache for curve types");
+  if (temp_object->runtime.curve_cache == nullptr) {
+    temp_object->runtime.curve_cache = (CurveCache *)MEM_callocN(sizeof(CurveCache),
+                                                                 "CurveCache for curve types");
  }

-  if (object->runtime.curve_cache != NULL) {
+  if (object->runtime.curve_cache != nullptr) {
    BKE_displist_copy(&temp_object->runtime.curve_cache->disp, &object->runtime.curve_cache->disp);
  }

  /* Constructive modifiers will use mesh to store result. */
-  if (object->runtime.data_eval != NULL) {
+  if (object->runtime.data_eval != nullptr) {
    BKE_id_copy_ex(
-        NULL, object->runtime.data_eval, &temp_object->runtime.data_eval, LIB_ID_COPY_LOCALIZE);
+        nullptr, object->runtime.data_eval, &temp_object->runtime.data_eval, LIB_ID_COPY_LOCALIZE);
  }

  /* Need to create copy of curve itself as well, it will be freed by underlying conversion
   * functions.
   *
   * NOTE: Copies the data, but not the shapekeys. */
-  BKE_id_copy_ex(NULL, object->data, (ID **)&temp_object->data, LIB_ID_COPY_LOCALIZE);
+  BKE_id_copy_ex(
+      nullptr, (const ID *)object->data, (ID **)&temp_object->data, LIB_ID_COPY_LOCALIZE);
  Curve *temp_curve = (Curve *)temp_object->data;

  /* Make sure texture space is calculated for a copy of curve, it will be used for the final
@@ -1011,8 +1015,9 @@ static void curve_to_mesh_eval_ensure(Object *object)

  remapped_object.data = &remapped_curve;

-  if (object->runtime.curve_cache == NULL) {
-    object->runtime.curve_cache = MEM_callocN(sizeof(CurveCache), "CurveCache for Curve");
+  if (object->runtime.curve_cache == nullptr) {
+    object->runtime.curve_cache = (CurveCache *)MEM_callocN(sizeof(CurveCache),
+                                                            "CurveCache for Curve");
  }

  /* Temporarily share the curve-cache with the temporary object, owned by `object`. */
@@ -1025,8 +1030,8 @@ static void curve_to_mesh_eval_ensure(Object *object)
   *
   * So we create temporary copy of the object which will use same data as the original bevel, but
   * will have no modifiers. */
-  Object bevel_object = {{NULL}};
-  if (remapped_curve.bevobj != NULL) {
+  Object bevel_object = {{nullptr}};
+  if (remapped_curve.bevobj != nullptr) {
    bevel_object = *remapped_curve.bevobj;
    BLI_listbase_clear(&bevel_object.modifiers);
    BKE_object_runtime_reset(&bevel_object);
@@ -1034,34 +1039,34 @@ static void curve_to_mesh_eval_ensure(Object *object)
  }

  /* Same thing for taper. */
-  Object taper_object = {{NULL}};
-  if (remapped_curve.taperobj != NULL) {
+  Object taper_object = {{nullptr}};
+  if (remapped_curve.taperobj != nullptr) {
    taper_object = *remapped_curve.taperobj;
    BLI_listbase_clear(&taper_object.modifiers);
    BKE_object_runtime_reset(&taper_object);
    remapped_curve.taperobj = &taper_object;
  }

-  /* NOTE: We don't have dependency graph or scene here, so we pass NULL. This is all fine since
+  /* NOTE: We don't have dependency graph or scene here, so we pass nullptr. This is all fine since
   * they are only used for modifier stack, which we have explicitly disabled for all objects.
   *
   * TODO(sergey): This is a very fragile logic, but proper solution requires re-writing quite a
   * bit of internal functions (#mesh_from_nurbs_displist, BKE_mesh_nomain_to_mesh) and also
   * Mesh From Curve operator.
   * Brecht says hold off with that. */
-  Mesh *mesh_eval = NULL;
+  Mesh *mesh_eval = nullptr;
  BKE_displist_make_curveTypes_forRender(
-      NULL, NULL, &remapped_object, &remapped_object.runtime.curve_cache->disp, &mesh_eval);
+      nullptr, nullptr, &remapped_object, &remapped_object.runtime.curve_cache->disp, &mesh_eval);

  /* NOTE: this is to be consistent with `BKE_displist_make_curveTypes()`, however that is not a
   * real issue currently, code here is broken in more than one way, fix(es) will be done
   * separately. */
-  if (mesh_eval != NULL) {
+  if (mesh_eval != nullptr) {
    BKE_object_eval_assign_data(&remapped_object, &mesh_eval->id, true);
  }

  /* Owned by `object` & needed by the caller to create the mesh. */
-  remapped_object.runtime.curve_cache = NULL;
+  remapped_object.runtime.curve_cache = nullptr;

  BKE_object_runtime_free_data(&remapped_object);
  BKE_object_runtime_free_data(&taper_object);
@@ -1070,7 +1075,7 @@ static void curve_to_mesh_eval_ensure(Object *object)

 static Mesh *mesh_new_from_curve_type_object(Object *object)
 {
-  Curve *curve = object->data;
+  Curve *curve = (Curve *)object->data;
  Object *temp_object = object_for_curve_to_mesh_create(object);
  Curve *temp_curve = (Curve *)temp_object->data;

@@ -1081,8 +1086,8 @@ static Mesh *mesh_new_from_curve_type_object(Object *object)
  }

  /* Reset pointers before conversion. */
-  temp_curve->editfont = NULL;
-  temp_curve->editnurb = NULL;
+  temp_curve->editfont = nullptr;
+  temp_curve->editnurb = nullptr;

  /* Convert to mesh. */
  mesh_from_nurbs_displist(
@@ -1091,14 +1096,14 @@ static Mesh *mesh_new_from_curve_type_object(Object *object)
  /* #mesh_from_nurbs_displist changes the type to a mesh, check it worked. If it didn't
   * the curve did not have any segments or otherwise would have generated an empty mesh. */
  if (temp_object->type != OB_MESH) {
-    BKE_id_free(NULL, temp_object->data);
-    BKE_id_free(NULL, temp_object);
-    return NULL;
+    BKE_id_free(nullptr, temp_object->data);
+    BKE_id_free(nullptr, temp_object);
+    return nullptr;
  }

-  Mesh *mesh_result = temp_object->data;
+  Mesh *mesh_result = (Mesh *)temp_object->data;

-  BKE_id_free(NULL, temp_object);
+  BKE_id_free(nullptr, temp_object);

  /* NOTE: Materials are copied in #mesh_from_nurbs_displist(). */

@@ -1114,19 +1119,19 @@ static Mesh *mesh_new_from_mball_object(Object *object)
   * ball).
   *
   * We create empty mesh so scripters don't run into None objects. */
-  if (!DEG_is_evaluated_object(object) || object->runtime.curve_cache == NULL ||
+  if (!DEG_is_evaluated_object(object) || object->runtime.curve_cache == nullptr ||
      BLI_listbase_is_empty(&object->runtime.curve_cache->disp)) {
-    return BKE_id_new_nomain(ID_ME, ((ID *)object->data)->name + 2);
+    return (Mesh *)BKE_id_new_nomain(ID_ME, ((ID *)object->data)->name + 2);
  }

-  Mesh *mesh_result = BKE_id_new_nomain(ID_ME, ((ID *)object->data)->name + 2);
+  Mesh *mesh_result = (Mesh *)BKE_id_new_nomain(ID_ME, ((ID *)object->data)->name + 2);
  BKE_mesh_from_metaball(&object->runtime.curve_cache->disp, mesh_result);
  BKE_mesh_texspace_copy_from_object(mesh_result, object);

  /* Copy materials. */
  mesh_result->totcol = mball->totcol;
-  mesh_result->mat = MEM_dupallocN(mball->mat);
-  if (mball->mat != NULL) {
+  mesh_result->mat = (Material **)MEM_dupallocN(mball->mat);
+  if (mball->mat != nullptr) {
    for (int i = mball->totcol; i-- > 0;) {
      mesh_result->mat[i] = BKE_object_material_get(object, i + 1);
    }
@@ -1142,7 +1147,7 @@ static Mesh *mesh_new_from_mesh(Object *object, Mesh *mesh)
  BKE_mesh_wrapper_ensure_mdata(mesh);

  Mesh *mesh_result = (Mesh *)BKE_id_copy_ex(
-      NULL, &mesh->id, NULL, LIB_ID_CREATE_NO_MAIN | LIB_ID_CREATE_NO_USER_REFCOUNT);
+      nullptr, &mesh->id, nullptr, LIB_ID_CREATE_NO_MAIN | LIB_ID_CREATE_NO_USER_REFCOUNT);
  /* NOTE: Materials should already be copied. */
  /* Copy original mesh name. This is because edit meshes might not have one properly set name. */
  BLI_strncpy(mesh_result->id.name, ((ID *)object->data)->name, sizeof(mesh_result->id.name));
@@ -1157,12 +1162,12 @@ static Mesh *mesh_new_from_mesh_object_with_layers(Depsgraph *depsgraph,
    return mesh_new_from_mesh(object, (Mesh *)object->data);
  }

-  if (depsgraph == NULL) {
-    return NULL;
+  if (depsgraph == nullptr) {
+    return nullptr;
  }

  Object object_for_eval = *object;
-  if (object_for_eval.runtime.data_orig != NULL) {
+  if (object_for_eval.runtime.data_orig != nullptr) {
    object_for_eval.data = object_for_eval.runtime.data_orig;
  }

@@ -1186,10 +1191,10 @@ static Mesh *mesh_new_from_mesh_object(Depsgraph *depsgraph,
  if (preserve_all_data_layers || preserve_origindex) {
    return mesh_new_from_mesh_object_with_layers(depsgraph, object, preserve_origindex);
  }
-  Mesh *mesh_input = object->data;
+  Mesh *mesh_input = (Mesh *)object->data;
  /* If we are in edit mode, use evaluated mesh from edit structure, matching to what
   * viewport is using for visualization. */
-  if (mesh_input->edit_mesh != NULL && mesh_input->edit_mesh->mesh_eval_final) {
+  if (mesh_input->edit_mesh != nullptr && mesh_input->edit_mesh->mesh_eval_final) {
    mesh_input = mesh_input->edit_mesh->mesh_eval_final;
  }
  return mesh_new_from_mesh(object, mesh_input);
@@ -1200,7 +1205,7 @@ Mesh *BKE_mesh_new_from_object(Depsgraph *depsgraph,
                               const bool preserve_all_data_layers,
                               const bool preserve_origindex)
 {
-  Mesh *new_mesh = NULL;
+  Mesh *new_mesh = nullptr;
  switch (object->type) {
    case OB_FONT:
    case OB_CURVE:
@@ -1216,11 +1221,11 @@ Mesh *BKE_mesh_new_from_object(Depsgraph *depsgraph,
      break;
    default:
      /* Object does not have geometry data. */
-      return NULL;
+      return nullptr;
  }
-  if (new_mesh == NULL) {
+  if (new_mesh == nullptr) {
    /* Happens in special cases like request of mesh for non-mother meta ball. */
-    return NULL;
+    return nullptr;
  }

  /* The result must have 0 users, since it's just a mesh which is free-dangling data-block.
@@ -1233,9 +1238,9 @@ Mesh *BKE_mesh_new_from_object(Depsgraph *depsgraph,
   * ownership.
   *
   * Here we are constructing a mesh which is supposed to be independent, which means no shared
-   * ownership is allowed, so we make sure edit mesh is reset to NULL (which is similar to as if
+   * ownership is allowed, so we make sure edit mesh is reset to nullptr (which is similar to as if
   * one duplicates the objects and applies all the modifiers). */
-  new_mesh->edit_mesh = NULL;
+  new_mesh->edit_mesh = nullptr;

  return new_mesh;
 }
@@ -1243,7 +1248,7 @@ Mesh *BKE_mesh_new_from_object(Depsgraph *depsgraph,
 static int foreach_libblock_make_original_callback(LibraryIDLinkCallbackData *cb_data)
 {
  ID **id_p = cb_data->id_pointer;
-  if (*id_p == NULL) {
+  if (*id_p == nullptr) {
    return IDWALK_RET_NOP;
  }
  *id_p = DEG_get_original_id(*id_p);
@@ -1254,7 +1259,7 @@ static int foreach_libblock_make_original_callback(LibraryIDLinkCallbackData *cb
 static int foreach_libblock_make_usercounts_callback(LibraryIDLinkCallbackData *cb_data)
 {
  ID **id_p = cb_data->id_pointer;
-  if (*id_p == NULL) {
+  if (*id_p == nullptr) {
    return IDWALK_RET_NOP;
  }

@@ -1278,7 +1283,7 @@ Mesh *BKE_mesh_new_from_object_to_bmain(Main *bmain,
  BLI_assert(ELEM(object->type, OB_FONT, OB_CURVE, OB_SURF, OB_MBALL, OB_MESH));

  Mesh *mesh = BKE_mesh_new_from_object(depsgraph, object, preserve_all_data_layers, false);
-  if (mesh == NULL) {
+  if (mesh == nullptr) {
    /* Unable to convert the object to a mesh, return an empty one. */
    Mesh *mesh_in_bmain = BKE_mesh_add(bmain, ((ID *)object->data)->name + 2);
    id_us_min(&mesh_in_bmain->id);
@@ -1294,7 +1299,7 @@ Mesh *BKE_mesh_new_from_object_to_bmain(Main *bmain,
   * Note that user-count updates has to be done *after* mesh has been transferred to Main database
   * (since doing refcounting on non-Main IDs is forbidden). */
  BKE_library_foreach_ID_link(
-      NULL, &mesh->id, foreach_libblock_make_original_callback, NULL, IDWALK_NOP);
+      nullptr, &mesh->id, foreach_libblock_make_original_callback, nullptr, IDWALK_NOP);

  /* Append the mesh to 'bmain'.
   * We do it a bit longer way since there is no simple and clear way of adding existing data-block
@@ -1311,14 +1316,14 @@ Mesh *BKE_mesh_new_from_object_to_bmain(Main *bmain,
  mesh_in_bmain->totcol = mesh->totcol;
  mesh_in_bmain->flag = mesh->flag;
  mesh_in_bmain->smoothresh = mesh->smoothresh;
-  mesh->mat = NULL;
+  mesh->mat = nullptr;

-  BKE_mesh_nomain_to_mesh(mesh, mesh_in_bmain, NULL, &CD_MASK_MESH, true);
+  BKE_mesh_nomain_to_mesh(mesh, mesh_in_bmain, nullptr, &CD_MASK_MESH, true);

  /* User-count is required because so far mesh was in a limbo, where library management does
   * not perform any user management (i.e. copy of a mesh will not increase users of materials). */
  BKE_library_foreach_ID_link(
-      NULL, &mesh_in_bmain->id, foreach_libblock_make_usercounts_callback, NULL, IDWALK_NOP);
+      nullptr, &mesh_in_bmain->id, foreach_libblock_make_usercounts_callback, nullptr, IDWALK_NOP);

  /* Make sure user count from BKE_mesh_add() is the one we expect here and bring it down to 0. */
  BLI_assert(mesh_in_bmain->id.us == 1);
@@ -1347,7 +1352,7 @@ static void add_shapekey_layers(Mesh *mesh_dest, Mesh *mesh_src)
    return;
  }

-  for (i = 0, kb = key->block.first; kb; kb = kb->next, i++) {
+  for (i = 0, kb = (KeyBlock *)key->block.first; kb; kb = kb->next, i++) {
    int ci;
    float *array;

@@ -1358,10 +1363,10 @@ static void add_shapekey_layers(Mesh *mesh_dest, Mesh *mesh_src)
                 mesh_src->totvert,
                 kb->name,
                 kb->totelem);
-      array = MEM_calloc_arrayN((size_t)mesh_src->totvert, sizeof(float[3]), __func__);
+      array = (float *)MEM_calloc_arrayN((size_t)mesh_src->totvert, sizeof(float[3]), __func__);
    }
    else {
-      array = MEM_malloc_arrayN((size_t)mesh_src->totvert, sizeof(float[3]), __func__);
+      array = (float *)MEM_malloc_arrayN((size_t)mesh_src->totvert, sizeof(float[3]), __func__);
      memcpy(array, kb->data, sizeof(float[3]) * (size_t)mesh_src->totvert);
    }

@@ -1379,9 +1384,10 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
                                           ModifierData *md_eval,
                                           const bool build_shapekey_layers)
 {
-  Mesh *me = ob_eval->runtime.data_orig ? ob_eval->runtime.data_orig : ob_eval->data;
-  const ModifierTypeInfo *mti = BKE_modifier_get_info(md_eval->type);
-  Mesh *result = NULL;
+  Mesh *me = ob_eval->runtime.data_orig ? (Mesh *)ob_eval->runtime.data_orig :
+                                          (Mesh *)ob_eval->data;
+  const ModifierTypeInfo *mti = BKE_modifier_get_info((ModifierType)md_eval->type);
+  Mesh *result = nullptr;
  KeyBlock *kb;
  ModifierEvalContext mectx = {depsgraph, ob_eval, MOD_APPLY_TO_BASE_MESH};

@@ -1389,12 +1395,12 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
    return result;
  }

-  if (mti->isDisabled && mti->isDisabled(scene, md_eval, 0)) {
+  if (mti->isDisabled && mti->isDisabled(scene, md_eval, false)) {
    return result;
  }

  if (build_shapekey_layers && me->key &&
-      (kb = BLI_findlink(&me->key->block, ob_eval->shapenr - 1))) {
+      (kb = (KeyBlock *)BLI_findlink(&me->key->block, ob_eval->shapenr - 1))) {
    BKE_keyblock_convert_to_mesh(kb, me);
  }

@@ -1402,7 +1408,7 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
    int numVerts;
    float(*deformedVerts)[3] = BKE_mesh_vert_coords_alloc(me, &numVerts);

-    result = (Mesh *)BKE_id_copy_ex(NULL, &me->id, NULL, LIB_ID_COPY_LOCALIZE);
+    result = (Mesh *)BKE_id_copy_ex(nullptr, &me->id, nullptr, LIB_ID_COPY_LOCALIZE);
    mti->deformVerts(md_eval, &mectx, result, deformedVerts, numVerts);
    BKE_mesh_vert_coords_apply(result, deformedVerts);

@@ -1413,7 +1419,7 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
    MEM_freeN(deformedVerts);
  }
  else {
-    Mesh *mesh_temp = (Mesh *)BKE_id_copy_ex(NULL, &me->id, NULL, LIB_ID_COPY_LOCALIZE);
+    Mesh *mesh_temp = (Mesh *)BKE_id_copy_ex(nullptr, &me->id, nullptr, LIB_ID_COPY_LOCALIZE);

    if (build_shapekey_layers) {
      add_shapekey_layers(mesh_temp, me);
@@ -1423,7 +1429,7 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph,
    ASSERT_IS_VALID_MESH(result);

    if (mesh_temp != result) {
-      BKE_id_free(NULL, mesh_temp);
+      BKE_id_free(nullptr, mesh_temp);
    }
  }

@@ -1446,7 +1452,7 @@ static void shapekey_layers_to_keyblocks(Mesh *mesh_src, Mesh *mesh_dst, int act
        &mesh_src->vdata.layers[CustomData_get_layer_index_n(&mesh_src->vdata, CD_SHAPEKEY, i)];
    float(*cos)[3], (*kbcos)[3];

-    for (kb = mesh_dst->key->block.first; kb; kb = kb->next) {
+    for (kb = (KeyBlock *)mesh_dst->key->block.first; kb; kb = kb->next) {
      if (kb->uid == layer->uid) {
        break;
      }
@@ -1461,10 +1467,10 @@ static void shapekey_layers_to_keyblocks(Mesh *mesh_src, Mesh *mesh_dst, int act
      MEM_freeN(kb->data);
    }

-    cos = CustomData_get_layer_n(&mesh_src->vdata, CD_SHAPEKEY, i);
+    cos = (float(*)[3])CustomData_get_layer_n(&mesh_src->vdata, CD_SHAPEKEY, i);
    kb->totelem = mesh_src->totvert;

-    kb->data = kbcos = MEM_malloc_arrayN(kb->totelem, sizeof(float[3]), __func__);
+    kb->data = kbcos = (float(*)[3])MEM_malloc_arrayN(kb->totelem, sizeof(float[3]), __func__);
    if (kb->uid == actshape_uid) {
      MVert *mvert = mesh_src->mvert;

@@ -1479,7 +1485,7 @@ static void shapekey_layers_to_keyblocks(Mesh *mesh_src, Mesh *mesh_dst, int act
    }
  }

-  for (kb = mesh_dst->key->block.first; kb; kb = kb->next) {
+  for (kb = (KeyBlock *)mesh_dst->key->block.first; kb; kb = kb->next) {
    if (kb->totelem != mesh_src->totvert) {
      if (kb->data) {
        MEM_freeN(kb->data);
@@ -1544,7 +1550,7 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src,
    int uid;

    if (ob) {
-      kb = BLI_findlink(&mesh_dst->key->block, ob->shapenr - 1);
+      kb = (KeyBlock *)BLI_findlink(&mesh_dst->key->block, ob->shapenr - 1);
      if (kb) {
        uid = kb->uid;
      }
@@ -1607,11 +1613,11 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src,
  /* NOTE(nazgul): maybe some other layers should be copied? */
  if (CustomData_has_layer(&mesh_dst->ldata, CD_MDISPS)) {
    if (totloop == mesh_dst->totloop) {
-      MDisps *mdisps = CustomData_get_layer(&mesh_dst->ldata, CD_MDISPS);
+      MDisps *mdisps = (MDisps *)CustomData_get_layer(&mesh_dst->ldata, CD_MDISPS);
      CustomData_add_layer(&tmp.ldata, CD_MDISPS, alloctype, mdisps, totloop);
      if (alloctype == CD_ASSIGN) {
-        /* Assign NULL to prevent double-free. */
-        CustomData_set_layer(&mesh_dst->ldata, CD_MDISPS, NULL);
+        /* Assign nullptr to prevent double-free. */
+        CustomData_set_layer(&mesh_dst->ldata, CD_MDISPS, nullptr);
      }
    }
  }
@@ -1633,7 +1639,7 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src,
    if (tmp.key && !(tmp.id.tag & LIB_TAG_NO_MAIN)) {
      id_us_min(&tmp.key->id);
    }
-    tmp.key = NULL;
+    tmp.key = nullptr;
  }

  /* Clear selection history */
@@ -1660,7 +1666,7 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src,
      CustomData_free_typemask(&mesh_src->ldata, mesh_src->totloop, ~mask->lmask);
      CustomData_free_typemask(&mesh_src->pdata, mesh_src->totpoly, ~mask->pmask);
    }
-    BKE_id_free(NULL, mesh_src);
+    BKE_id_free(nullptr, mesh_src);
  }
 }

@@ -1682,7 +1688,7 @@ void BKE_mesh_nomain_to_meshkey(Mesh *mesh_src, Mesh *mesh_dst, KeyBlock *kb)
  kb->data = MEM_malloc_arrayN(mesh_dst->key->elemsize, mesh_dst->totvert, "kb->data");
  kb->totelem = totvert;

-  fp = kb->data;
+  fp = (float *)kb->data;
  mvert = mesh_src->mvert;

  for (a = 0; a < kb->totelem; a++, fp += 3, mvert++) {