Cleanup: Clang-Tidy modernize-use-nullptr

Replace `NULL` with `nullptr` in C++ code.

No functional changes.

.clang-tidy

@@ -38,7 +38,6 @@ Checks:  >
   -modernize-deprecated-headers,
   -modernize-avoid-c-arrays,
   -modernize-use-equals-default,
-  -modernize-use-nullptr,
   -modernize-concat-nested-namespaces,
   -modernize-use-nodiscard,
   -modernize-use-using,

source/blender/blenkernel/intern/fcurve_test.cc

@@ -290,7 +290,7 @@ TEST(fcurve_active_keyframe, ActiveKeyframe)
   EXPECT_EQ(BKE_fcurve_active_keyframe_index(fcu), 2);
 
   /* Check clearing the index. */
-  BKE_fcurve_active_keyframe_set(fcu, NULL);
+  BKE_fcurve_active_keyframe_set(fcu, nullptr);
   EXPECT_EQ(fcu->active_keyframe_index, FCURVE_ACTIVE_KEYFRAME_NONE);
   EXPECT_EQ(BKE_fcurve_active_keyframe_index(fcu), FCURVE_ACTIVE_KEYFRAME_NONE);
 

source/blender/blenkernel/intern/lattice_deform_test.cc

@@ -83,7 +83,7 @@ static void test_lattice_deform_free(LatticeDeformTestContext *ctx)
 TEST(lattice_deform_performance, performance_no_dvert_1)
 {
   const int32_t num_items = 1;
-  LatticeDeformTestContext ctx = {{{0}}};
+  LatticeDeformTestContext ctx = {{{nullptr}}};
   RandomNumberGenerator rng;
   test_lattice_deform_init(&ctx, &rng, num_items);
   test_lattice_deform(&ctx, num_items);
@@ -92,7 +92,7 @@ TEST(lattice_deform_performance, performance_no_dvert_1)
 TEST(lattice_deform_performance, performance_no_dvert_1000)
 {
   const int32_t num_items = 1000;
-  LatticeDeformTestContext ctx = {{{0}}};
+  LatticeDeformTestContext ctx = {{{nullptr}}};
   RandomNumberGenerator rng;
   test_lattice_deform_init(&ctx, &rng, num_items);
   test_lattice_deform(&ctx, num_items);
@@ -101,7 +101,7 @@ TEST(lattice_deform_performance, performance_no_dvert_1000)
 TEST(lattice_deform_performance, performance_no_dvert_10000)
 {
   const int32_t num_items = 10000;
-  LatticeDeformTestContext ctx = {{{0}}};
+  LatticeDeformTestContext ctx = {{{nullptr}}};
   RandomNumberGenerator rng;
   test_lattice_deform_init(&ctx, &rng, num_items);
   test_lattice_deform(&ctx, num_items);
@@ -110,7 +110,7 @@ TEST(lattice_deform_performance, performance_no_dvert_10000)
 TEST(lattice_deform_performance, performance_no_dvert_100000)
 {
   const int32_t num_items = 100000;
-  LatticeDeformTestContext ctx = {{{0}}};
+  LatticeDeformTestContext ctx = {{{nullptr}}};
   RandomNumberGenerator rng;
   test_lattice_deform_init(&ctx, &rng, num_items);
   test_lattice_deform(&ctx, num_items);
@@ -119,7 +119,7 @@ TEST(lattice_deform_performance, performance_no_dvert_100000)
 TEST(lattice_deform_performance, performance_no_dvert_1000000)
 {
   const int32_t num_items = 1000000;
-  LatticeDeformTestContext ctx = {{{0}}};
+  LatticeDeformTestContext ctx = {{{nullptr}}};
   RandomNumberGenerator rng;
   test_lattice_deform_init(&ctx, &rng, num_items);
   test_lattice_deform(&ctx, num_items);
@@ -128,7 +128,7 @@ TEST(lattice_deform_performance, performance_no_dvert_1000000)
 TEST(lattice_deform_performance, performance_no_dvert_10000000)
 {
   const int32_t num_items = 10000000;
-  LatticeDeformTestContext ctx = {{{0}}};
+  LatticeDeformTestContext ctx = {{{nullptr}}};
   RandomNumberGenerator rng;
   test_lattice_deform_init(&ctx, &rng, num_items);
   test_lattice_deform(&ctx, num_items);

source/blender/blenkernel/intern/simulation.cc

@@ -165,14 +165,14 @@ IDTypeInfo IDType_ID_SIM = {
     /* free_data */ simulation_free_data,
     /* make_local */ nullptr,
     /* foreach_id */ simulation_foreach_id,
-    /* foreach_cache */ NULL,
+    /* foreach_cache */ nullptr,
 
     /* blend_write */ simulation_blend_write,
     /* blend_read_data */ simulation_blend_read_data,
     /* blend_read_lib */ simulation_blend_read_lib,
     /* blend_read_expand */ simulation_blend_read_expand,
 
-    /* blend_read_undo_preserve */ NULL,
+    /* blend_read_undo_preserve */ nullptr,
 };
 
 void *BKE_simulation_add(Main *bmain, const char *name)

source/blender/blenkernel/intern/volume.cc

@@ -265,12 +265,12 @@ static struct VolumeFileCache {
 
 struct VolumeGrid {
   VolumeGrid(const VolumeFileCache::Entry &template_entry, const int simplify_level)
-      : entry(NULL), simplify_level(simplify_level), is_loaded(false)
+      : entry(nullptr), simplify_level(simplify_level), is_loaded(false)
   {
     entry = GLOBAL_CACHE.add_metadata_user(template_entry);
   }
 
-  VolumeGrid(const openvdb::GridBase::Ptr &grid) : entry(NULL), local_grid(grid), is_loaded(true)
+  VolumeGrid(const openvdb::GridBase::Ptr &grid) : entry(nullptr), local_grid(grid), is_loaded(true)
   {
   }
 
@@ -295,7 +295,7 @@ struct VolumeGrid {
   void load(const char *volume_name, const char *filepath)
   {
     /* If already loaded or not file-backed, nothing to do. */
-    if (is_loaded || entry == NULL) {
+    if (is_loaded || entry == nullptr) {
       return;
     }
 
@@ -337,7 +337,7 @@ struct VolumeGrid {
   void unload(const char *volume_name)
   {
     /* Not loaded or not file-backed, nothing to do. */
-    if (!is_loaded || entry == NULL) {
+    if (!is_loaded || entry == nullptr) {
       return;
     }
 
@@ -364,7 +364,7 @@ struct VolumeGrid {
     local_grid = grid()->copyGridWithNewTree();
     if (entry) {
       GLOBAL_CACHE.remove_user(*entry, is_loaded);
-      entry = NULL;
+      entry = nullptr;
     }
     is_loaded = true;
   }
@@ -378,7 +378,7 @@ struct VolumeGrid {
     local_grid = grid()->deepCopyGrid();
     if (entry) {
       GLOBAL_CACHE.remove_user(*entry, is_loaded);
-      entry = NULL;
+      entry = nullptr;
     }
     is_loaded = true;
   }
@@ -398,7 +398,7 @@ struct VolumeGrid {
       return entry->error_msg.c_str();
     }
 
-    return NULL;
+    return nullptr;
   }
 
   bool grid_is_loaded() const
@@ -562,7 +562,7 @@ static void volume_blend_write(BlendWriter *writer, ID *id, const void *id_addre
   Volume *volume = (Volume *)id;
   if (volume->id.us > 0 || BLO_write_is_undo(writer)) {
     /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    volume->runtime.grids = 0;
+    volume->runtime.grids = nullptr;
 
     /* write LibData */
     BLO_write_id_struct(writer, Volume, id_address, &volume->id);
@@ -634,13 +634,13 @@ IDTypeInfo IDType_ID_VO = {
     /* blend_read_lib */ volume_blend_read_lib,
     /* blend_read_expand */ volume_blend_read_expand,
 
-    /* blend_read_undo_preserve */ NULL,
+    /* blend_read_undo_preserve */ nullptr,
 };
 
 void BKE_volume_init_grids(Volume *volume)
 {
 #ifdef WITH_OPENVDB
-  if (volume->runtime.grids == NULL) {
+  if (volume->runtime.grids == nullptr) {
     volume->runtime.grids = OBJECT_GUARDED_NEW(VolumeGridVector);
   }
 #else
@@ -871,11 +871,11 @@ BoundBox *BKE_volume_boundbox_get(Object *ob)
 {
   BLI_assert(ob->type == OB_VOLUME);
 
-  if (ob->runtime.bb != NULL && (ob->runtime.bb->flag & BOUNDBOX_DIRTY) == 0) {
+  if (ob->runtime.bb != nullptr && (ob->runtime.bb->flag & BOUNDBOX_DIRTY) == 0) {
     return ob->runtime.bb;
   }
 
-  if (ob->runtime.bb == NULL) {
+  if (ob->runtime.bb == nullptr) {
     Volume *volume = (Volume *)ob->data;
 
     ob->runtime.bb = (BoundBox *)MEM_callocN(sizeof(BoundBox), "volume boundbox");
@@ -1006,7 +1006,7 @@ static Volume *volume_evaluate_modifiers(struct Depsgraph *depsgraph,
       if (volume_next && volume_next != volume) {
         /* If the modifier returned a new volume, release the old one. */
         if (volume != volume_input) {
-          BKE_id_free(NULL, volume);
+          BKE_id_free(nullptr, volume);
         }
         volume = volume_next;
       }
@@ -1057,7 +1057,7 @@ void BKE_volume_grids_backup_restore(Volume *volume, VolumeGridVector *grids, co
   /* Restore grids after datablock was re-copied from original by depsgraph,
    * we don't want to load them again if possible. */
   BLI_assert(volume->id.tag & LIB_TAG_COPIED_ON_WRITE);
-  BLI_assert(volume->runtime.grids != NULL && grids != NULL);
+  BLI_assert(volume->runtime.grids != nullptr && grids != nullptr);
 
   if (!grids->is_loaded()) {
     /* No grids loaded in CoW datablock, nothing lost by discarding. */
@@ -1080,8 +1080,8 @@ void BKE_volume_grids_backup_restore(Volume *volume, VolumeGridVector *grids, co
 
 /* Draw Cache */
 
-void (*BKE_volume_batch_cache_dirty_tag_cb)(Volume *volume, int mode) = NULL;
+void (*BKE_volume_batch_cache_dirty_tag_cb)(Volume *volume, int mode) = nullptr;
-void (*BKE_volume_batch_cache_free_cb)(Volume *volume) = NULL;
+void (*BKE_volume_batch_cache_free_cb)(Volume *volume) = nullptr;
 
 void BKE_volume_batch_cache_dirty_tag(Volume *volume, int mode)
 {
@@ -1138,7 +1138,7 @@ VolumeGrid *BKE_volume_grid_get(const Volume *volume, int grid_index)
       return &grid;
     }
   }
-  return NULL;
+  return nullptr;
 #else
   UNUSED_VARS(volume, grid_index);
   return NULL;
@@ -1149,7 +1149,7 @@ VolumeGrid *BKE_volume_grid_active_get(const Volume *volume)
 {
   const int num_grids = BKE_volume_num_grids(volume);
   if (num_grids == 0) {
-    return NULL;
+    return nullptr;
   }
 
   const int index = clamp_i(volume->active_grid, 0, num_grids - 1);
@@ -1167,7 +1167,7 @@ VolumeGrid *BKE_volume_grid_find(const Volume *volume, const char *name)
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 /* Grid Loading */
@@ -1352,7 +1352,7 @@ bool BKE_volume_grid_bounds(const VolumeGrid *volume_grid, float min[3], float m
 
 Volume *BKE_volume_new_for_eval(const Volume *volume_src)
 {
-  Volume *volume_dst = (Volume *)BKE_id_new_nomain(ID_VO, NULL);
+  Volume *volume_dst = (Volume *)BKE_id_new_nomain(ID_VO, nullptr);
 
   STRNCPY(volume_dst->id.name, volume_src->id.name);
   volume_dst->mat = (Material **)MEM_dupallocN(volume_src->mat);
@@ -1372,7 +1372,7 @@ Volume *BKE_volume_copy_for_eval(Volume *volume_src, bool reference)
     flags |= LIB_ID_COPY_CD_REFERENCE;
   }
 
-  Volume *result = (Volume *)BKE_id_copy_ex(NULL, &volume_src->id, NULL, flags);
+  Volume *result = (Volume *)BKE_id_copy_ex(nullptr, &volume_src->id, nullptr, flags);
 
   return result;
 }
@@ -1395,12 +1395,12 @@ VolumeGrid *BKE_volume_grid_add(Volume *volume, const char *name, VolumeGridType
 {
 #ifdef WITH_OPENVDB
   VolumeGridVector &grids = *volume->runtime.grids;
-  BLI_assert(BKE_volume_grid_find(volume, name) == NULL);
+  BLI_assert(BKE_volume_grid_find(volume, name) == nullptr);
   BLI_assert(type != VOLUME_GRID_UNKNOWN);
 
   openvdb::GridBase::Ptr vdb_grid = BKE_volume_grid_type_operation(type, CreateGridOp{});
   if (!vdb_grid) {
-    return NULL;
+    return nullptr;
   }
 
   vdb_grid->setName(name);

source/blender/blenkernel/intern/volume_render.cc

@@ -123,7 +123,7 @@ bool BKE_volume_grid_dense_floats(const Volume *volume,
   const int channels = BKE_volume_grid_channels(volume_grid);
   const int elem_size = sizeof(float) * channels;
   float *voxels = static_cast<float *>(MEM_malloc_arrayN(num_voxels, elem_size, __func__));
-  if (voxels == NULL) {
+  if (voxels == nullptr) {
     return false;
   }
 
@@ -143,7 +143,7 @@ bool BKE_volume_grid_dense_floats(const Volume *volume,
 
 void BKE_volume_dense_float_grid_clear(DenseFloatVolumeGrid *dense_grid)
 {
-  if (dense_grid->voxels != NULL) {
+  if (dense_grid->voxels != nullptr) {
     MEM_freeN(dense_grid->voxels);
   }
 }
@@ -339,7 +339,7 @@ void BKE_volume_grid_wireframe(const Volume *volume,
                                void *cb_userdata)
 {
   if (volume->display.wireframe_type == VOLUME_WIREFRAME_NONE) {
-    cb(cb_userdata, NULL, NULL, 0, 0);
+    cb(cb_userdata, nullptr, nullptr, 0, 0);
     return;
   }
 

source/blender/blenlib/intern/delaunay_2d.cc

@@ -654,12 +654,12 @@ template<typename T> inline bool is_border_edge(const CDTEdge<T> *e, const CDT_s
 
 template<typename T> inline bool is_constrained_edge(const CDTEdge<T> *e)
 {
-  return e->input_ids != NULL;
+  return e->input_ids != nullptr;
 }
 
 template<typename T> inline bool is_deleted_edge(const CDTEdge<T> *e)
 {
-  return e->symedges[0].next == NULL;
+  return e->symedges[0].next == nullptr;
 }
 
 template<typename T> inline bool is_original_vert(const CDTVert<T> *v, CDT_state<T> *cdt)
@@ -1386,8 +1386,8 @@ void fill_crossdata_for_through_vert(CDTVert<T> *v,
 
   cd_next->lambda = T(0);
   cd_next->vert = v;
-  cd_next->in = NULL;
+  cd_next->in = nullptr;
-  cd_next->out = NULL;
+  cd_next->out = nullptr;
   if (cd->lambda == 0) {
     cd->out = cd_out;
   }
@@ -1630,10 +1630,10 @@ void add_edge_constraint(
   if (dbg_level > 0) {
     std::cout << "\nADD EDGE CONSTRAINT\n" << vertname(v1) << " " << vertname(v2) << "\n";
   }
-  LinkNodePair edge_list = {NULL, NULL};
+  LinkNodePair edge_list = {nullptr, nullptr};
 
   if (r_edges) {
-    *r_edges = NULL;
+    *r_edges = nullptr;
   }
 
   /*
@@ -1648,7 +1648,7 @@ void add_edge_constraint(
   if (t != nullptr) {
     /* Segment already there. */
     add_to_input_ids(&t->edge->input_ids, input_id);
-    if (r_edges != NULL) {
+    if (r_edges != nullptr) {
       BLI_linklist_append(&edge_list, t->edge);
       *r_edges = edge_list.list;
     }
@@ -1736,15 +1736,15 @@ void add_edge_constraint(
         SymEdge<T> *se;
         if (cd_prev->lambda == 0.0) {
           se = find_symedge_between_verts(cd_prev->vert, v);
-          if (se == NULL) {
+          if (se == nullptr) {
             return;
           }
           cd_prev->out = se;
-          cd->in = NULL;
+          cd->in = nullptr;
         }
         else {
           se = find_symedge_with_face(v, sym(cd_prev->in)->face);
-          if (se == NULL) {
+          if (se == nullptr) {
             return;
           }
           cd->in = se;
@@ -1783,7 +1783,7 @@ void add_edge_constraint(
     if (cd->lambda == -1.0) {
       continue; /* This crossing was deleted. */
     }
-    t = NULL;
+    t = nullptr;
     SymEdge<T> *tnext = t;
     CDTEdge<T> *edge;
     if (cd->lambda != 0.0) {
@@ -1795,7 +1795,7 @@ void add_edge_constraint(
     else if (cd->lambda == 0.0) {
       t = cd->in;
       tnext = cd->out;
-      if (t == NULL) {
+      if (t == nullptr) {
         /* Previous non-deleted crossing must also have been a vert, and segment should exist. */
         int j;
         CrossData<T> *cd_prev;
@@ -1809,12 +1809,12 @@ void add_edge_constraint(
         BLI_assert(cd_prev->out->next->vert == cd->vert);
         edge = cd_prev->out->edge;
         add_to_input_ids(&edge->input_ids, input_id);
-        if (r_edges != NULL) {
+        if (r_edges != nullptr) {
           BLI_linklist_append(&edge_list, edge);
         }
       }
     }
-    if (t != NULL) {
+    if (t != nullptr) {
       if (tstart->next->vert == t->vert) {
         edge = tstart->edge;
       }
@@ -1822,7 +1822,7 @@ void add_edge_constraint(
         edge = cdt_state->cdt.add_diagonal(tstart, t);
       }
       add_to_input_ids(&edge->input_ids, input_id);
-      if (r_edges != NULL) {
+      if (r_edges != nullptr) {
         BLI_linklist_append(&edge_list, edge);
       }
       /* Now retriangulate upper and lower gaps. */
@@ -1830,7 +1830,7 @@ void add_edge_constraint(
       re_delaunay_triangulate(&cdt_state->cdt, &edge->symedges[1]);
     }
     if (i < ncrossings - 1) {
-      if (tnext != NULL) {
+      if (tnext != nullptr) {
         tstart = tnext;
       }
     }
@@ -2011,7 +2011,7 @@ template<typename T> void dissolve_symedge(CDT_state<T> *cdt_state, SymEdge<T> *
   if (ELEM(cdt->outer_face->symedge, se, symse)) {
     /* Advancing by 2 to get past possible 'sym(se)'. */
     if (se->next->next == se) {
-      cdt->outer_face->symedge = NULL;
+      cdt->outer_face->symedge = nullptr;
     }
     else {
       cdt->outer_face->symedge = se->next->next;
@@ -2177,9 +2177,9 @@ template<typename T> void remove_outer_edges_until_constraints(CDT_state<T> *cdt
       }
       se = se->next;
     } while (se != se_start);
-    while (to_dissolve != NULL) {
+    while (to_dissolve != nullptr) {
       se = static_cast<SymEdge<T> *>(BLI_linklist_pop(&to_dissolve));
-      if (se->next != NULL) {
+      if (se->next != nullptr) {
         dissolve_symedge(cdt_state, se);
       }
     }

source/blender/blenlib/intern/mesh_intersect.cc

@@ -1137,7 +1137,7 @@ static bool non_trivially_2d_hex_overlap(int orients[2][3][3])
   for (int ab = 0; ab < 2; ++ab) {
     for (int i = 0; i < 3; ++i) {
       bool ok = orients[ab][i][0] + orients[ab][i][1] + orients[ab][i][2] == 1 &&
-                orients[ab][i][0] != 0 && orients[ab][i][1] != 0 && orients[i][2] != 0;
+                orients[ab][i][0] != 0 && orients[ab][i][1] != 0 && orients[i][2] != nullptr;
       if (!ok) {
         return false;
       }
@@ -2460,12 +2460,12 @@ class TriOverlaps {
     if (two_trees_no_self) {
       BLI_bvhtree_balance(tree_b_);
       /* Don't expect a lot of trivial intersects in this case. */
-      overlap_ = BLI_bvhtree_overlap(tree_, tree_b_, &overlap_tot_, NULL, NULL);
+      overlap_ = BLI_bvhtree_overlap(tree_, tree_b_, &overlap_tot_, nullptr, nullptr);
     }
     else {
       CBData cbdata{tm, shape_fn, nshapes, use_self};
       if (nshapes == 1) {
-        overlap_ = BLI_bvhtree_overlap(tree_, tree_, &overlap_tot_, NULL, NULL);
+        overlap_ = BLI_bvhtree_overlap(tree_, tree_, &overlap_tot_, nullptr, nullptr);
       }
       else {
         overlap_ = BLI_bvhtree_overlap(

source/blender/blenlib/intern/task_pool.cc

@@ -83,11 +83,11 @@ class Task {
         free_taskdata(other.free_taskdata),
         freedata(other.freedata)
   {
-    other.pool = NULL;
+    other.pool = nullptr;
-    other.run = NULL;
+    other.run = nullptr;
-    other.taskdata = NULL;
+    other.taskdata = nullptr;
     other.free_taskdata = false;
-    other.freedata = NULL;
+    other.freedata = nullptr;
   }
 
 #if defined(WITH_TBB) && TBB_INTERFACE_VERSION_MAJOR < 10
@@ -302,7 +302,7 @@ static void *background_task_run(void *userdata)
     task->~Task();
     MEM_freeN(task);
   }
-  return NULL;
+  return nullptr;
 }
 
 static void background_task_pool_create(TaskPool *pool)

source/blender/blenlib/intern/task_range.cc

@@ -70,7 +70,7 @@ struct RangeTask {
 
   ~RangeTask()
   {
-    if (settings->func_free != NULL) {
+    if (settings->func_free != nullptr) {
       settings->func_free(userdata, userdata_chunk);
     }
     MEM_SAFE_FREE(userdata_chunk);
@@ -83,7 +83,7 @@ struct RangeTask {
       memcpy(userdata_chunk, from_chunk, settings->userdata_chunk_size);
     }
     else {
-      userdata_chunk = NULL;
+      userdata_chunk = nullptr;
     }
   }
 
@@ -139,7 +139,7 @@ void BLI_task_parallel_range(const int start,
   for (int i = start; i < stop; i++) {
     func(userdata, i, &tls);
   }
-  if (settings->func_free != NULL) {
+  if (settings->func_free != nullptr) {
     settings->func_free(userdata, settings->userdata_chunk);
   }
 }

source/blender/blenlib/tests/BLI_array_store_test.cc

@@ -125,7 +125,7 @@ static TestBuffer *testbuffer_list_add(ListBase *lb, const void *data, size_t da
   TestBuffer *tb = (TestBuffer *)MEM_mallocN(sizeof(*tb), __func__);
   tb->data = data;
   tb->data_len = data_len;
-  tb->state = NULL;
+  tb->state = nullptr;
   BLI_addtail(lb, tb);
   return tb;
 }
@@ -244,10 +244,10 @@ static void testbuffer_list_data_randomize(ListBase *lb, unsigned int random_see
 
 static void testbuffer_list_store_populate(BArrayStore *bs, ListBase *lb)
 {
-  for (TestBuffer *tb = (TestBuffer *)lb->first, *tb_prev = NULL; tb;
+  for (TestBuffer *tb = (TestBuffer *)lb->first, *tb_prev = nullptr; tb;
        tb_prev = tb, tb = tb->next) {
     tb->state = BLI_array_store_state_add(
-        bs, tb->data, tb->data_len, (tb_prev ? tb_prev->state : NULL));
+        bs, tb->data, tb->data_len, (tb_prev ? tb_prev->state : nullptr));
   }
 }
 
@@ -255,7 +255,7 @@ static void testbuffer_list_store_clear(BArrayStore *bs, ListBase *lb)
 {
   for (TestBuffer *tb = (TestBuffer *)lb->first; tb; tb = tb->next) {
     BLI_array_store_state_remove(bs, tb->state);
-    tb->state = NULL;
+    tb->state = nullptr;
   }
 }
 
@@ -313,7 +313,7 @@ TEST(array_store, NopState)
 {
   BArrayStore *bs = BLI_array_store_create(1, 32);
   const unsigned char data[] = "test";
-  BArrayState *state = BLI_array_store_state_add(bs, data, sizeof(data) - 1, NULL);
+  BArrayState *state = BLI_array_store_state_add(bs, data, sizeof(data) - 1, nullptr);
   EXPECT_EQ(BLI_array_store_state_size_get(state), sizeof(data) - 1);
   BLI_array_store_state_remove(bs, state);
   BLI_array_store_destroy(bs);
@@ -324,7 +324,7 @@ TEST(array_store, Single)
   BArrayStore *bs = BLI_array_store_create(1, 32);
   const char data_src[] = "test";
   const char *data_dst;
-  BArrayState *state = BLI_array_store_state_add(bs, data_src, sizeof(data_src), NULL);
+  BArrayState *state = BLI_array_store_state_add(bs, data_src, sizeof(data_src), nullptr);
   size_t data_dst_len;
   data_dst = (char *)BLI_array_store_state_data_get_alloc(state, &data_dst_len);
   EXPECT_STREQ(data_src, data_dst);
@@ -339,7 +339,7 @@ TEST(array_store, DoubleNop)
   const char data_src[] = "test";
   const char *data_dst;
 
-  BArrayState *state_a = BLI_array_store_state_add(bs, data_src, sizeof(data_src), NULL);
+  BArrayState *state_a = BLI_array_store_state_add(bs, data_src, sizeof(data_src), nullptr);
   BArrayState *state_b = BLI_array_store_state_add(bs, data_src, sizeof(data_src), state_a);
 
   EXPECT_EQ(BLI_array_store_calc_size_compacted_get(bs), sizeof(data_src));
@@ -366,7 +366,7 @@ TEST(array_store, DoubleDiff)
   const char data_src_b[] = "####";
   const char *data_dst;
 
-  BArrayState *state_a = BLI_array_store_state_add(bs, data_src_a, sizeof(data_src_a), NULL);
+  BArrayState *state_a = BLI_array_store_state_add(bs, data_src_a, sizeof(data_src_a), nullptr);
   BArrayState *state_b = BLI_array_store_state_add(bs, data_src_b, sizeof(data_src_b), state_a);
   size_t data_dst_len;
 
@@ -594,7 +594,7 @@ static void testbuffer_list_state_random_data(ListBase *lb,
   size_t data_len = rand_range_i(rng, data_min_len, data_max_len + stride, stride);
   char *data = (char *)MEM_mallocN(data_len, __func__);
 
-  if (lb->last == NULL) {
+  if (lb->last == nullptr) {
     BLI_rng_get_char_n(rng, data, data_len);
   }
   else {

source/blender/blenlib/tests/BLI_array_utils_test.cc

@@ -91,7 +91,7 @@ TEST(array_utils, FindIndexInt4_DupeMid)
 
 TEST(array_utils, FindIndexPointer)
 {
-  const char *data[4] = {NULL};
+  const char *data[4] = {nullptr};
   STACK_DECLARE(data);
 
   STACK_INIT(data, ARRAY_SIZE(data));

source/blender/blenlib/tests/BLI_delaunay_2d_test.cc

@@ -1513,7 +1513,7 @@ TEST(delaunay_d, CintTwoFace)
   input.edges_len = 0;
   input.faces_len = 2;
   input.vert_coords = vert_coords;
-  input.edges = NULL;
+  input.edges = nullptr;
   input.faces = faces;
   input.faces_len_table = faces_len;
   input.faces_start_table = faces_start;

source/blender/blenlib/tests/BLI_expr_pylike_eval_test.cc

@@ -12,7 +12,7 @@
 
 static void expr_pylike_parse_fail_test(const char *str)
 {
-  ExprPyLike_Parsed *expr = BLI_expr_pylike_parse(str, NULL, 0);
+  ExprPyLike_Parsed *expr = BLI_expr_pylike_parse(str, nullptr, 0);
 
   EXPECT_FALSE(BLI_expr_pylike_is_valid(expr));
 
@@ -21,7 +21,7 @@ static void expr_pylike_parse_fail_test(const char *str)
 
 static void expr_pylike_const_test(const char *str, double value, bool force_const)
 {
-  ExprPyLike_Parsed *expr = BLI_expr_pylike_parse(str, NULL, 0);
+  ExprPyLike_Parsed *expr = BLI_expr_pylike_parse(str, nullptr, 0);
 
   if (force_const) {
     EXPECT_TRUE(BLI_expr_pylike_is_constant(expr));
@@ -32,7 +32,7 @@ static void expr_pylike_const_test(const char *str, double value, bool force_con
   }
 
   double result;
-  eExprPyLike_EvalStatus status = BLI_expr_pylike_eval(expr, NULL, 0, &result);
+  eExprPyLike_EvalStatus status = BLI_expr_pylike_eval(expr, nullptr, 0, &result);
 
   EXPECT_EQ(status, EXPR_PYLIKE_SUCCESS);
   EXPECT_EQ(result, value);
@@ -344,10 +344,10 @@ TEST_ERROR(Mixed3, "sqrt(x) + 1 / max(0, x)", 1.0, EXPR_PYLIKE_SUCCESS)
 
 TEST(expr_pylike, Error_Invalid)
 {
-  ExprPyLike_Parsed *expr = BLI_expr_pylike_parse("", NULL, 0);
+  ExprPyLike_Parsed *expr = BLI_expr_pylike_parse("", nullptr, 0);
   double result;
 
-  EXPECT_EQ(BLI_expr_pylike_eval(expr, NULL, 0, &result), EXPR_PYLIKE_INVALID);
+  EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID);
 
   BLI_expr_pylike_free(expr);
 }
@@ -357,7 +357,7 @@ TEST(expr_pylike, Error_ArgumentCount)
   ExprPyLike_Parsed *expr = parse_for_eval("x", false);
   double result;
 
-  EXPECT_EQ(BLI_expr_pylike_eval(expr, NULL, 0, &result), EXPR_PYLIKE_FATAL_ERROR);
+  EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_FATAL_ERROR);
 
   BLI_expr_pylike_free(expr);
 }

source/blender/blenlib/tests/BLI_ghash_test.cc

@@ -77,7 +77,7 @@ TEST(ghash, InsertLookup)
     EXPECT_EQ(POINTER_AS_UINT(v), *k);
   }
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
 }
 
 /* Here we simply insert and then remove all keys, ensuring we do get an empty,
@@ -98,14 +98,14 @@ TEST(ghash, InsertRemove)
   bkt_size = BLI_ghash_buckets_len(ghash);
 
   for (i = TESTCASE_SIZE, k = keys; i--; k++) {
-    void *v = BLI_ghash_popkey(ghash, POINTER_FROM_UINT(*k), NULL);
+    void *v = BLI_ghash_popkey(ghash, POINTER_FROM_UINT(*k), nullptr);
     EXPECT_EQ(POINTER_AS_UINT(v), *k);
   }
 
   EXPECT_EQ(BLI_ghash_len(ghash), 0);
   EXPECT_EQ(BLI_ghash_buckets_len(ghash), bkt_size);
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
 }
 
 /* Same as above, but this time we allow ghash to shrink. */
@@ -126,14 +126,14 @@ TEST(ghash, InsertRemoveShrink)
   bkt_size = BLI_ghash_buckets_len(ghash);
 
   for (i = TESTCASE_SIZE, k = keys; i--; k++) {
-    void *v = BLI_ghash_popkey(ghash, POINTER_FROM_UINT(*k), NULL);
+    void *v = BLI_ghash_popkey(ghash, POINTER_FROM_UINT(*k), nullptr);
     EXPECT_EQ(POINTER_AS_UINT(v), *k);
   }
 
   EXPECT_EQ(BLI_ghash_len(ghash), 0);
   EXPECT_LT(BLI_ghash_buckets_len(ghash), bkt_size);
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
 }
 
 /* Check copy. */
@@ -152,7 +152,7 @@ TEST(ghash, Copy)
 
   EXPECT_EQ(BLI_ghash_len(ghash), TESTCASE_SIZE);
 
-  ghash_copy = BLI_ghash_copy(ghash, NULL, NULL);
+  ghash_copy = BLI_ghash_copy(ghash, nullptr, nullptr);
 
   EXPECT_EQ(BLI_ghash_len(ghash_copy), TESTCASE_SIZE);
   EXPECT_EQ(BLI_ghash_buckets_len(ghash_copy), BLI_ghash_buckets_len(ghash));
@@ -162,8 +162,8 @@ TEST(ghash, Copy)
     EXPECT_EQ(POINTER_AS_UINT(v), *k);
   }
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
-  BLI_ghash_free(ghash_copy, NULL, NULL);
+  BLI_ghash_free(ghash_copy, nullptr, nullptr);
 }
 
 /* Check pop. */
@@ -205,5 +205,5 @@ TEST(ghash, Pop)
   }
   EXPECT_EQ(BLI_ghash_len(ghash), 0);
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
 }

source/blender/blenlib/tests/BLI_heap_simple_test.cc

@@ -29,7 +29,7 @@ TEST(heap, SimpleEmpty)
   heap = BLI_heapsimple_new();
   EXPECT_TRUE(BLI_heapsimple_is_empty(heap));
   EXPECT_EQ(BLI_heapsimple_len(heap), 0);
-  BLI_heapsimple_free(heap, NULL);
+  BLI_heapsimple_free(heap, nullptr);
 }
 
 TEST(heap, SimpleOne)
@@ -45,7 +45,7 @@ TEST(heap, SimpleOne)
   EXPECT_EQ(in, BLI_heapsimple_pop_min(heap));
   EXPECT_TRUE(BLI_heapsimple_is_empty(heap));
   EXPECT_EQ(BLI_heapsimple_len(heap), 0);
-  BLI_heapsimple_free(heap, NULL);
+  BLI_heapsimple_free(heap, nullptr);
 }
 
 TEST(heap, SimpleRange)
@@ -59,7 +59,7 @@ TEST(heap, SimpleRange)
     EXPECT_EQ(out_test, POINTER_AS_INT(BLI_heapsimple_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heapsimple_is_empty(heap));
-  BLI_heapsimple_free(heap, NULL);
+  BLI_heapsimple_free(heap, nullptr);
 }
 
 TEST(heap, SimpleRangeReverse)
@@ -73,7 +73,7 @@ TEST(heap, SimpleRangeReverse)
     EXPECT_EQ(-out_test, POINTER_AS_INT(BLI_heapsimple_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heapsimple_is_empty(heap));
-  BLI_heapsimple_free(heap, NULL);
+  BLI_heapsimple_free(heap, nullptr);
 }
 
 TEST(heap, SimpleDuplicates)
@@ -81,13 +81,13 @@ TEST(heap, SimpleDuplicates)
   const int items_total = SIZE;
   HeapSimple *heap = BLI_heapsimple_new();
   for (int in = 0; in < items_total; in++) {
-    BLI_heapsimple_insert(heap, 1.0f, 0);
+    BLI_heapsimple_insert(heap, 1.0f, nullptr);
   }
   for (int out_test = 0; out_test < items_total; out_test++) {
     EXPECT_EQ(0, POINTER_AS_INT(BLI_heapsimple_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heapsimple_is_empty(heap));
-  BLI_heapsimple_free(heap, NULL);
+  BLI_heapsimple_free(heap, nullptr);
 }
 
 static void random_heapsimple_helper(const int items_total, const int random_seed)
@@ -103,7 +103,7 @@ static void random_heapsimple_helper(const int items_total, const int random_see
     EXPECT_EQ(out_test, POINTER_AS_INT(BLI_heapsimple_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heapsimple_is_empty(heap));
-  BLI_heapsimple_free(heap, NULL);
+  BLI_heapsimple_free(heap, nullptr);
   MEM_freeN(values);
 }
 

source/blender/blenlib/tests/BLI_heap_test.cc

@@ -28,7 +28,7 @@ TEST(heap, Empty)
   heap = BLI_heap_new();
   EXPECT_TRUE(BLI_heap_is_empty(heap));
   EXPECT_EQ(BLI_heap_len(heap), 0);
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
 }
 
 TEST(heap, One)
@@ -44,7 +44,7 @@ TEST(heap, One)
   EXPECT_EQ(in, BLI_heap_pop_min(heap));
   EXPECT_TRUE(BLI_heap_is_empty(heap));
   EXPECT_EQ(BLI_heap_len(heap), 0);
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
 }
 
 TEST(heap, Range)
@@ -58,7 +58,7 @@ TEST(heap, Range)
     EXPECT_EQ(out_test, POINTER_AS_INT(BLI_heap_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
 }
 
 TEST(heap, RangeReverse)
@@ -72,7 +72,7 @@ TEST(heap, RangeReverse)
     EXPECT_EQ(-out_test, POINTER_AS_INT(BLI_heap_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
 }
 
 TEST(heap, RangeRemove)
@@ -85,13 +85,13 @@ TEST(heap, RangeRemove)
   }
   for (int i = 0; i < items_total; i += 2) {
     BLI_heap_remove(heap, nodes[i]);
-    nodes[i] = NULL;
+    nodes[i] = nullptr;
   }
   for (int out_test = 1; out_test < items_total; out_test += 2) {
     EXPECT_EQ(out_test, POINTER_AS_INT(BLI_heap_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
   MEM_freeN(nodes);
 }
 
@@ -100,13 +100,13 @@ TEST(heap, Duplicates)
   const int items_total = SIZE;
   Heap *heap = BLI_heap_new();
   for (int in = 0; in < items_total; in++) {
-    BLI_heap_insert(heap, 1.0f, 0);
+    BLI_heap_insert(heap, 1.0f, nullptr);
   }
   for (int out_test = 0; out_test < items_total; out_test++) {
     EXPECT_EQ(0, POINTER_AS_INT(BLI_heap_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
 }
 
 static void random_heap_helper(const int items_total, const int random_seed)
@@ -122,7 +122,7 @@ static void random_heap_helper(const int items_total, const int random_seed)
     EXPECT_EQ(out_test, POINTER_AS_INT(BLI_heap_pop_min(heap)));
   }
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
   MEM_freeN(values);
 }
 
@@ -156,7 +156,7 @@ TEST(heap, ReInsertSimple)
   }
 
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
   MEM_freeN(nodes);
 }
 
@@ -181,7 +181,7 @@ static void random_heap_reinsert_helper(const int items_total, const int random_
     BLI_heap_pop_min(heap);
   }
   EXPECT_TRUE(BLI_heap_is_empty(heap));
-  BLI_heap_free(heap, NULL);
+  BLI_heap_free(heap, nullptr);
   MEM_freeN(nodes);
 }
 

source/blender/blenlib/tests/BLI_kdopbvh_test.cc

@@ -82,11 +82,11 @@ static void find_nearest_points_test(
   BLI_bvhtree_balance(tree);
 
   /* first find each point */
-  BVHTree_NearestPointCallback callback = optimal ? optimal_check_callback : NULL;
+  BVHTree_NearestPointCallback callback = optimal ? optimal_check_callback : nullptr;
   int flags = optimal ? BVH_NEAREST_OPTIMAL_ORDER : 0;
 
   for (int i = 0; i < points_len; i++) {
-    const int j = BLI_bvhtree_find_nearest_ex(tree, points[i], NULL, callback, points, flags);
+    const int j = BLI_bvhtree_find_nearest_ex(tree, points[i], nullptr, callback, points, flags);
     if (j != i) {
 #if 0
       const float dist = len_v3v3(points[i], points[j]);

source/blender/blenlib/tests/BLI_linklist_lockfree_test.cc

@@ -15,7 +15,7 @@ TEST(LockfreeLinkList, Init)
   BLI_linklist_lockfree_init(&list);
   EXPECT_EQ(list.head, &list.dummy_node);
   EXPECT_EQ(list.tail, &list.dummy_node);
-  BLI_linklist_lockfree_free(&list, NULL);
+  BLI_linklist_lockfree_free(&list, nullptr);
 }
 
 TEST(LockfreeLinkList, InsertSingle)
@@ -27,7 +27,7 @@ TEST(LockfreeLinkList, InsertSingle)
   EXPECT_EQ(list.head, &list.dummy_node);
   EXPECT_EQ(list.head->next, &node);
   EXPECT_EQ(list.tail, &node);
-  BLI_linklist_lockfree_free(&list, NULL);
+  BLI_linklist_lockfree_free(&list, nullptr);
 }
 
 TEST(LockfreeLinkList, InsertMultiple)
@@ -45,7 +45,7 @@ TEST(LockfreeLinkList, InsertMultiple)
   EXPECT_EQ(list.tail, &nodes[num_nodes - 1]);
   /* Check rest of the nodes. */
   int node_index = 0;
-  for (LockfreeLinkNode *node = BLI_linklist_lockfree_begin(&list); node != NULL;
+  for (LockfreeLinkNode *node = BLI_linklist_lockfree_begin(&list); node != nullptr;
        node = node->next, ++node_index) {
     EXPECT_EQ(node, &nodes[node_index]);
     if (node_index != num_nodes - 1) {
@@ -53,7 +53,7 @@ TEST(LockfreeLinkList, InsertMultiple)
     }
   }
   /* Free list. */
-  BLI_linklist_lockfree_free(&list, NULL);
+  BLI_linklist_lockfree_free(&list, nullptr);
 }
 
 namespace {
@@ -84,7 +84,7 @@ TEST(LockfreeLinkList, InsertMultipleConcurrent)
   TaskPool *pool = BLI_task_pool_create_suspended(&list, TASK_PRIORITY_HIGH);
   /* Push tasks to the pool. */
   for (int i = 0; i < num_nodes; ++i) {
-    BLI_task_pool_push(pool, concurrent_insert, POINTER_FROM_INT(i), false, NULL);
+    BLI_task_pool_push(pool, concurrent_insert, POINTER_FROM_INT(i), false, nullptr);
   }
   /* Run all the tasks. */
   BLI_task_pool_work_and_wait(pool);
@@ -92,7 +92,7 @@ TEST(LockfreeLinkList, InsertMultipleConcurrent)
   EXPECT_EQ(list.head, &list.dummy_node);
   bool *visited_nodes = (bool *)MEM_callocN(sizeof(bool) * num_nodes, "visited nodes");
   /* First, we make sure that none of the nodes are added twice. */
-  for (LockfreeLinkNode *node_v = BLI_linklist_lockfree_begin(&list); node_v != NULL;
+  for (LockfreeLinkNode *node_v = BLI_linklist_lockfree_begin(&list); node_v != nullptr;
        node_v = node_v->next) {
     IndexedNode *node = (IndexedNode *)node_v;
     EXPECT_GE(node->index, 0);

source/blender/blenlib/tests/BLI_listbase_test.cc

@@ -22,19 +22,19 @@ static bool listbase_is_valid(const ListBase *listbase)
   if (listbase->first) {
     const Link *prev, *link;
     link = (Link *)listbase->first;
-    TESTFAIL(link->prev == NULL);
+    TESTFAIL(link->prev == nullptr);
 
     link = (Link *)listbase->last;
-    TESTFAIL(link->next == NULL);
+    TESTFAIL(link->next == nullptr);
 
-    prev = NULL;
+    prev = nullptr;
     link = (Link *)listbase->first;
     do {
       TESTFAIL(link->prev == prev);
     } while ((void)(prev = link), (link = link->next));
     TESTFAIL(prev == listbase->last);
 
-    prev = NULL;
+    prev = nullptr;
     link = (Link *)listbase->last;
     do {
       TESTFAIL(link->next == prev);
@@ -42,7 +42,7 @@ static bool listbase_is_valid(const ListBase *listbase)
     TESTFAIL(prev == listbase->first);
   }
   else {
-    TESTFAIL(listbase->last == NULL);
+    TESTFAIL(listbase->last == nullptr);
   }
 #undef TESTFAIL
 
@@ -73,12 +73,12 @@ TEST(listbase, FindLinkOrIndex)
 
   /* Empty list */
   BLI_listbase_clear(&lb);
-  EXPECT_EQ(BLI_findlink(&lb, -1), (void *)NULL);
+  EXPECT_EQ(BLI_findlink(&lb, -1), (void *)nullptr);
-  EXPECT_EQ(BLI_findlink(&lb, 0), (void *)NULL);
+  EXPECT_EQ(BLI_findlink(&lb, 0), (void *)nullptr);
-  EXPECT_EQ(BLI_findlink(&lb, 1), (void *)NULL);
+  EXPECT_EQ(BLI_findlink(&lb, 1), (void *)nullptr);
-  EXPECT_EQ(BLI_rfindlink(&lb, -1), (void *)NULL);
+  EXPECT_EQ(BLI_rfindlink(&lb, -1), (void *)nullptr);
-  EXPECT_EQ(BLI_rfindlink(&lb, 0), (void *)NULL);
+  EXPECT_EQ(BLI_rfindlink(&lb, 0), (void *)nullptr);
-  EXPECT_EQ(BLI_rfindlink(&lb, 1), (void *)NULL);
+  EXPECT_EQ(BLI_rfindlink(&lb, 1), (void *)nullptr);
   EXPECT_EQ(BLI_findindex(&lb, link1), -1);
 
   /* One link */

source/blender/blenlib/tests/BLI_path_util_test.cc

@@ -18,46 +18,46 @@ TEST(path_util, Clean)
   /* "/./" -> "/" */
   {
     char path[FILE_MAX] = "/a/./b/./c/./";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("/a/b/c/", path);
   }
 
   {
     char path[FILE_MAX] = "/./././";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("/", path);
   }
 
   {
     char path[FILE_MAX] = "/a/./././b/";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("/a/b/", path);
   }
 
   /* "//" -> "/" */
   {
     char path[FILE_MAX] = "a////";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("a/", path);
   }
 
   if (false) /* FIXME */
   {
     char path[FILE_MAX] = "./a////";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("./a/", path);
   }
 
   /* "foo/bar/../" -> "foo/" */
   {
     char path[FILE_MAX] = "/a/b/c/../../../";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("/", path);
   }
 
   {
     char path[FILE_MAX] = "/a/../a/b/../b/c/../c/";
-    BLI_path_normalize(NULL, path);
+    BLI_path_normalize(nullptr, path);
     EXPECT_STREQ("/a/b/c/", path);
   }
 
@@ -96,10 +96,10 @@ TEST(path_util, NameAtIndex_Single)
   AT_INDEX("//a//", 0, "a");
   AT_INDEX("a/b", 0, "a");
 
-  AT_INDEX("/a", 1, NULL);
+  AT_INDEX("/a", 1, nullptr);
-  AT_INDEX("/a/", 1, NULL);
+  AT_INDEX("/a/", 1, nullptr);
-  AT_INDEX("a/", 1, NULL);
+  AT_INDEX("a/", 1, nullptr);
-  AT_INDEX("//a//", 1, NULL);
+  AT_INDEX("//a//", 1, nullptr);
 }
 TEST(path_util, NameAtIndex_SingleNeg)
 {
@@ -109,10 +109,10 @@ TEST(path_util, NameAtIndex_SingleNeg)
   AT_INDEX("//a//", -1, "a");
   AT_INDEX("a/b", -1, "b");
 
-  AT_INDEX("/a", -2, NULL);
+  AT_INDEX("/a", -2, nullptr);
-  AT_INDEX("/a/", -2, NULL);
+  AT_INDEX("/a/", -2, nullptr);
-  AT_INDEX("a/", -2, NULL);
+  AT_INDEX("a/", -2, nullptr);
-  AT_INDEX("//a//", -2, NULL);
+  AT_INDEX("//a//", -2, nullptr);
 }
 
 TEST(path_util, NameAtIndex_Double)
@@ -123,10 +123,10 @@ TEST(path_util, NameAtIndex_Double)
   AT_INDEX("//ab//", 0, "ab");
   AT_INDEX("ab/c", 0, "ab");
 
-  AT_INDEX("/ab", 1, NULL);
+  AT_INDEX("/ab", 1, nullptr);
-  AT_INDEX("/ab/", 1, NULL);
+  AT_INDEX("/ab/", 1, nullptr);
-  AT_INDEX("ab/", 1, NULL);
+  AT_INDEX("ab/", 1, nullptr);
-  AT_INDEX("//ab//", 1, NULL);
+  AT_INDEX("//ab//", 1, nullptr);
 }
 
 TEST(path_util, NameAtIndex_DoublNeg)
@@ -137,10 +137,10 @@ TEST(path_util, NameAtIndex_DoublNeg)
   AT_INDEX("//ab//", -1, "ab");
   AT_INDEX("ab/c", -1, "c");
 
-  AT_INDEX("/ab", -2, NULL);
+  AT_INDEX("/ab", -2, nullptr);
-  AT_INDEX("/ab/", -2, NULL);
+  AT_INDEX("/ab/", -2, nullptr);
-  AT_INDEX("ab/", -2, NULL);
+  AT_INDEX("ab/", -2, nullptr);
-  AT_INDEX("//ab//", -2, NULL);
+  AT_INDEX("//ab//", -2, nullptr);
 }
 
 TEST(path_util, NameAtIndex_Misc)
@@ -149,8 +149,8 @@ TEST(path_util, NameAtIndex_Misc)
   AT_INDEX("/how/now/brown/cow", 1, "now");
   AT_INDEX("/how/now/brown/cow", 2, "brown");
   AT_INDEX("/how/now/brown/cow", 3, "cow");
-  AT_INDEX("/how/now/brown/cow", 4, NULL);
+  AT_INDEX("/how/now/brown/cow", 4, nullptr);
-  AT_INDEX("/how/now/brown/cow/", 4, NULL);
+  AT_INDEX("/how/now/brown/cow/", 4, nullptr);
 }
 
 TEST(path_util, NameAtIndex_MiscNeg)
@@ -159,8 +159,8 @@ TEST(path_util, NameAtIndex_MiscNeg)
   AT_INDEX("/how/now/brown/cow", 1, "now");
   AT_INDEX("/how/now/brown/cow", 2, "brown");
   AT_INDEX("/how/now/brown/cow", 3, "cow");
-  AT_INDEX("/how/now/brown/cow", 4, NULL);
+  AT_INDEX("/how/now/brown/cow", 4, nullptr);
-  AT_INDEX("/how/now/brown/cow/", 4, NULL);
+  AT_INDEX("/how/now/brown/cow/", 4, nullptr);
 }
 
 TEST(path_util, NameAtIndex_MiscComplex)
@@ -169,8 +169,8 @@ TEST(path_util, NameAtIndex_MiscComplex)
   AT_INDEX("//how///now\\/brown/cow", 1, "now");
   AT_INDEX("/how/now\\//brown\\/cow", 2, "brown");
   AT_INDEX("/how/now/brown/cow//\\", 3, "cow");
-  AT_INDEX("/how/now/brown/\\cow", 4, NULL);
+  AT_INDEX("/how/now/brown/\\cow", 4, nullptr);
-  AT_INDEX("how/now/brown/\\cow\\", 4, NULL);
+  AT_INDEX("how/now/brown/\\cow\\", 4, nullptr);
 }
 
 TEST(path_util, NameAtIndex_MiscComplexNeg)
@@ -179,24 +179,24 @@ TEST(path_util, NameAtIndex_MiscComplexNeg)
   AT_INDEX("//how///now\\/brown/cow", -3, "now");
   AT_INDEX("/how/now\\//brown\\/cow", -2, "brown");
   AT_INDEX("/how/now/brown/cow//\\", -1, "cow");
-  AT_INDEX("/how/now/brown/\\cow", -5, NULL);
+  AT_INDEX("/how/now/brown/\\cow", -5, nullptr);
-  AT_INDEX("how/now/brown/\\cow\\", -5, NULL);
+  AT_INDEX("how/now/brown/\\cow\\", -5, nullptr);
 }
 
 TEST(path_util, NameAtIndex_NoneComplex)
 {
-  AT_INDEX("", 0, NULL);
+  AT_INDEX("", 0, nullptr);
-  AT_INDEX("/", 0, NULL);
+  AT_INDEX("/", 0, nullptr);
-  AT_INDEX("//", 0, NULL);
+  AT_INDEX("//", 0, nullptr);
-  AT_INDEX("///", 0, NULL);
+  AT_INDEX("///", 0, nullptr);
 }
 
 TEST(path_util, NameAtIndex_NoneComplexNeg)
 {
-  AT_INDEX("", -1, NULL);
+  AT_INDEX("", -1, nullptr);
-  AT_INDEX("/", -1, NULL);
+  AT_INDEX("/", -1, nullptr);
-  AT_INDEX("//", -1, NULL);
+  AT_INDEX("//", -1, nullptr);
-  AT_INDEX("///", -1, NULL);
+  AT_INDEX("///", -1, nullptr);
 }
 
 #undef AT_INDEX
@@ -590,9 +590,9 @@ TEST(path_util, PathFrameGet)
 /* BLI_path_extension */
 TEST(path_util, PathExtension)
 {
-  EXPECT_EQ(NULL, BLI_path_extension("some.def/file"));
+  EXPECT_EQ(nullptr, BLI_path_extension("some.def/file"));
-  EXPECT_EQ(NULL, BLI_path_extension("Text"));
+  EXPECT_EQ(nullptr, BLI_path_extension("Text"));
-  EXPECT_EQ(NULL, BLI_path_extension("Text…001"));
+  EXPECT_EQ(nullptr, BLI_path_extension("Text…001"));
 
   EXPECT_STREQ(".", BLI_path_extension("some/file."));
   EXPECT_STREQ(".gz", BLI_path_extension("some/file.tar.gz"));

source/blender/blenlib/tests/BLI_polyfill_2d_test.cc

@@ -118,7 +118,7 @@ static void test_polyfill_topology(const float /*poly*/[][2],
   }
 
   BLI_edgehashIterator_free(ehi);
-  BLI_edgehash_free(edgehash, NULL);
+  BLI_edgehash_free(edgehash, nullptr);
 }
 
 /**
@@ -205,7 +205,7 @@ static void test_polyfill_template(const char *id,
     test_polyfill_template_check(id, is_degenerate, poly, poly_tot, tris, tris_tot);
 
     BLI_memarena_free(pf_arena);
-    BLI_heap_free(pf_heap, NULL);
+    BLI_heap_free(pf_heap, nullptr);
   }
 #endif
 }

source/blender/blenlib/tests/BLI_string_test.cc

@@ -66,8 +66,8 @@ TEST(string, StrPartition)
     /* "" -> "", NULL, NULL, 0 */
     pre_ln = BLI_str_partition(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 0);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 
   {
@@ -76,8 +76,8 @@ TEST(string, StrPartition)
     /* "material" -> "material", NULL, NULL, 8 */
     pre_ln = BLI_str_partition(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 8);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 }
 
@@ -125,8 +125,8 @@ TEST(string, StrRPartition)
     /* "" -> "", NULL, NULL, 0 */
     pre_ln = BLI_str_rpartition(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 0);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 
   {
@@ -135,8 +135,8 @@ TEST(string, StrRPartition)
     /* "material" -> "material", NULL, NULL, 8 */
     pre_ln = BLI_str_rpartition(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 8);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 }
 
@@ -166,8 +166,8 @@ TEST(string, StrPartitionEx)
     /* "mate.rial" over "mate" -> "mate.rial", NULL, NULL, 4 */
     pre_ln = BLI_str_partition_ex(str, str + 4, delim, &sep, &suf, true);
     EXPECT_EQ(pre_ln, 4);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 }
 
@@ -215,8 +215,8 @@ TEST(string, StrPartitionUtf8)
     /* "" -> "", NULL, NULL, 0 */
     pre_ln = BLI_str_partition_utf8(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 0);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 
   {
@@ -225,8 +225,8 @@ TEST(string, StrPartitionUtf8)
     /* "material" -> "material", NULL, NULL, 8 */
     pre_ln = BLI_str_partition_utf8(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 8);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 }
 
@@ -274,8 +274,8 @@ TEST(string, StrRPartitionUtf8)
     /* "" -> "", NULL, NULL, 0 */
     pre_ln = BLI_str_rpartition_utf8(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 0);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 
   {
@@ -284,8 +284,8 @@ TEST(string, StrRPartitionUtf8)
     /* "material" -> "material", NULL, NULL, 8 */
     pre_ln = BLI_str_rpartition_utf8(str, delim, &sep, &suf);
     EXPECT_EQ(pre_ln, 8);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 }
 
@@ -316,8 +316,8 @@ TEST(string, StrPartitionExUtf8)
     /* "mate\xe2\x98\xafrial" over "mate" -> "mate\xe2\x98\xafrial", NULL, NULL, 4 */
     pre_ln = BLI_str_partition_ex_utf8(str, str + 4, delim, &sep, &suf, true);
     EXPECT_EQ(pre_ln, 4);
-    EXPECT_EQ(sep, (void *)NULL);
+    EXPECT_EQ(sep, (void *)nullptr);
-    EXPECT_EQ(suf, (void *)NULL);
+    EXPECT_EQ(suf, (void *)nullptr);
   }
 }
 
@@ -567,7 +567,7 @@ TEST(string, StringStrncasestr)
   EXPECT_EQ(res, str_test0 + 1);
 
   res = BLI_strncasestr(str_test0, "not there", 9);
-  EXPECT_EQ(res, (void *)NULL);
+  EXPECT_EQ(res, (void *)nullptr);
 }
 
 /* BLI_string_max_possible_word_count */

source/blender/blenlib/tests/BLI_string_utf8_test.cc

@@ -262,14 +262,14 @@ const char *utf8_invalid_tests[][3] = {
     /* For now, we ignore those, they do not seem to be crucial anyway... */
 /*    5.3.3  U+FDD0 .. U+FDEF
  *    5.3.4  U+nFFFE U+nFFFF (for n = 1..10) */
-    {NULL, NULL, NULL},
+    {nullptr, nullptr, nullptr},
 };
 /* clang-format on */
 
 /* BLI_utf8_invalid_strip (and indirectly, BLI_utf8_invalid_byte). */
 TEST(string, Utf8InvalidBytes)
 {
-  for (int i = 0; utf8_invalid_tests[i][0] != NULL; i++) {
+  for (int i = 0; utf8_invalid_tests[i][0] != nullptr; i++) {
     const char *tst = utf8_invalid_tests[i][0];
     const char *tst_stripped = utf8_invalid_tests[i][1];
     const int num_errors = (int)utf8_invalid_tests[i][2][0];

source/blender/blenlib/tests/BLI_task_graph_test.cc

@@ -52,16 +52,16 @@ TEST(task, GraphSequential)
   TaskGraph *graph = BLI_task_graph_create();
 
   /* 0 => 1 */
-  TaskNode *node_a = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, NULL);
+  TaskNode *node_a = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, nullptr);
   /* 1 => 2 */
   TaskNode *node_b = BLI_task_graph_node_create(
-      graph, TaskData_multiply_by_two_value, &data, NULL);
+      graph, TaskData_multiply_by_two_value, &data, nullptr);
   /* 2 => 1 */
-  TaskNode *node_c = BLI_task_graph_node_create(graph, TaskData_decrease_value, &data, NULL);
+  TaskNode *node_c = BLI_task_graph_node_create(graph, TaskData_decrease_value, &data, nullptr);
   /* 2 => 1 */
-  TaskNode *node_d = BLI_task_graph_node_create(graph, TaskData_square_value, &data, NULL);
+  TaskNode *node_d = BLI_task_graph_node_create(graph, TaskData_square_value, &data, nullptr);
   /* 1 => 1 */
-  TaskNode *node_e = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, NULL);
+  TaskNode *node_e = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, nullptr);
   /* 1 => 2 */
   const int expected_value = 2;
 
@@ -82,12 +82,12 @@ TEST(task, GraphStartAtAnyNode)
   TaskData data = {4};
   TaskGraph *graph = BLI_task_graph_create();
 
-  TaskNode *node_a = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, NULL);
+  TaskNode *node_a = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, nullptr);
   TaskNode *node_b = BLI_task_graph_node_create(
-      graph, TaskData_multiply_by_two_value, &data, NULL);
+      graph, TaskData_multiply_by_two_value, &data, nullptr);
-  TaskNode *node_c = BLI_task_graph_node_create(graph, TaskData_decrease_value, &data, NULL);
+  TaskNode *node_c = BLI_task_graph_node_create(graph, TaskData_decrease_value, &data, nullptr);
-  TaskNode *node_d = BLI_task_graph_node_create(graph, TaskData_square_value, &data, NULL);
+  TaskNode *node_d = BLI_task_graph_node_create(graph, TaskData_square_value, &data, nullptr);
-  TaskNode *node_e = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, NULL);
+  TaskNode *node_e = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, nullptr);
 
   // ((4 - 1) * (4 - 1)) + 1
   const int expected_value = 10;
@@ -109,11 +109,11 @@ TEST(task, GraphSplit)
   TaskData data = {1};
 
   TaskGraph *graph = BLI_task_graph_create();
-  TaskNode *node_a = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, NULL);
+  TaskNode *node_a = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, nullptr);
-  TaskNode *node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data, NULL);
+  TaskNode *node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data, nullptr);
-  TaskNode *node_c = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, NULL);
+  TaskNode *node_c = BLI_task_graph_node_create(graph, TaskData_increase_value, &data, nullptr);
   TaskNode *node_d = BLI_task_graph_node_create(
-      graph, TaskData_multiply_by_two_store, &data, NULL);
+      graph, TaskData_multiply_by_two_store, &data, nullptr);
   BLI_task_graph_edge_create(node_a, node_b);
   BLI_task_graph_edge_create(node_b, node_c);
   BLI_task_graph_edge_create(node_b, node_d);
@@ -134,12 +134,12 @@ TEST(task, GraphForest)
 
   {
     TaskNode *tree1_node_a = BLI_task_graph_node_create(
-        graph, TaskData_increase_value, &data1, NULL);
+        graph, TaskData_increase_value, &data1, nullptr);
-    TaskNode *tree1_node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data1, NULL);
+    TaskNode *tree1_node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data1, nullptr);
     TaskNode *tree1_node_c = BLI_task_graph_node_create(
-        graph, TaskData_increase_value, &data1, NULL);
+        graph, TaskData_increase_value, &data1, nullptr);
     TaskNode *tree1_node_d = BLI_task_graph_node_create(
-        graph, TaskData_multiply_by_two_store, &data1, NULL);
+        graph, TaskData_multiply_by_two_store, &data1, nullptr);
     BLI_task_graph_edge_create(tree1_node_a, tree1_node_b);
     BLI_task_graph_edge_create(tree1_node_b, tree1_node_c);
     BLI_task_graph_edge_create(tree1_node_b, tree1_node_d);
@@ -148,12 +148,12 @@ TEST(task, GraphForest)
 
   {
     TaskNode *tree2_node_a = BLI_task_graph_node_create(
-        graph, TaskData_increase_value, &data2, NULL);
+        graph, TaskData_increase_value, &data2, nullptr);
-    TaskNode *tree2_node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data2, NULL);
+    TaskNode *tree2_node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data2, nullptr);
     TaskNode *tree2_node_c = BLI_task_graph_node_create(
-        graph, TaskData_increase_value, &data2, NULL);
+        graph, TaskData_increase_value, &data2, nullptr);
     TaskNode *tree2_node_d = BLI_task_graph_node_create(
-        graph, TaskData_multiply_by_two_store, &data2, NULL);
+        graph, TaskData_multiply_by_two_store, &data2, nullptr);
     BLI_task_graph_edge_create(tree2_node_a, tree2_node_b);
     BLI_task_graph_edge_create(tree2_node_b, tree2_node_c);
     BLI_task_graph_edge_create(tree2_node_b, tree2_node_d);
@@ -175,7 +175,7 @@ TEST(task, GraphTaskData)
   TaskGraph *graph = BLI_task_graph_create();
   TaskNode *node_a = BLI_task_graph_node_create(
       graph, TaskData_store_value, &data, TaskData_increase_value);
-  TaskNode *node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data, NULL);
+  TaskNode *node_b = BLI_task_graph_node_create(graph, TaskData_store_value, &data, nullptr);
   BLI_task_graph_edge_create(node_a, node_b);
   EXPECT_TRUE(BLI_task_graph_node_push_work(node_a));
   BLI_task_graph_work_and_wait(graph);

source/blender/blenlib/tests/BLI_task_test.cc

@@ -72,7 +72,7 @@ static void task_mempool_iter_func(void *userdata, MempoolIterData *item)
   int *data = (int *)item;
   int *count = (int *)userdata;
 
-  EXPECT_TRUE(data != NULL);
+  EXPECT_TRUE(data != nullptr);
 
   *data += 1;
   atomic_sub_and_fetch_uint32((uint32_t *)count, 1);
@@ -97,12 +97,12 @@ TEST(task, MempoolIter)
 
   for (i = 0; i < NUM_ITEMS; i += 3) {
     BLI_mempool_free(mempool, data[i]);
-    data[i] = NULL;
+    data[i] = nullptr;
     num_items--;
   }
 
   for (i = 0; i < NUM_ITEMS; i += 7) {
-    if (data[i] == NULL) {
+    if (data[i] == nullptr) {
       data[i] = (int *)BLI_mempool_alloc(mempool);
       *data[i] = i - 1;
       num_items++;
@@ -111,9 +111,9 @@ TEST(task, MempoolIter)
 
   for (i = 0; i < NUM_ITEMS - 5; i += 23) {
     for (int j = 0; j < 5; j++) {
-      if (data[i + j] != NULL) {
+      if (data[i + j] != nullptr) {
         BLI_mempool_free(mempool, data[i + j]);
-        data[i + j] = NULL;
+        data[i + j] = nullptr;
         num_items--;
       }
     }
@@ -125,7 +125,7 @@ TEST(task, MempoolIter)
    * expected. */
   EXPECT_EQ(num_items, 0);
   for (i = 0; i < NUM_ITEMS; i++) {
-    if (data[i] != NULL) {
+    if (data[i] != nullptr) {
       EXPECT_EQ(*data[i], i);
     }
   }
@@ -150,7 +150,7 @@ static void task_listbase_iter_func(void *userdata,
 
 TEST(task, ListBaseIter)
 {
-  ListBase list = {NULL, NULL};
+  ListBase list = {nullptr, nullptr};
   LinkData *items_buffer = (LinkData *)MEM_calloc_arrayN(
       NUM_ITEMS, sizeof(*items_buffer), __func__);
   BLI_threadapi_init();
@@ -172,7 +172,7 @@ TEST(task, ListBaseIter)
    * as expected. */
   EXPECT_EQ(num_items, 0);
   LinkData *item;
-  for (i = 0, item = (LinkData *)list.first; i < NUM_ITEMS && item != NULL;
+  for (i = 0, item = (LinkData *)list.first; i < NUM_ITEMS && item != nullptr;
        i++, item = item->next) {
     EXPECT_EQ(POINTER_AS_INT(item->data), i);
   }

source/blender/blenlib/tests/BLI_vector_test.cc

@@ -79,11 +79,11 @@ struct TestListValue {
 
 TEST(vector, ListBaseConstructor)
 {
-  TestListValue *value1 = new TestListValue{0, 0, 4};
+  TestListValue *value1 = new TestListValue{nullptr, nullptr, 4};
-  TestListValue *value2 = new TestListValue{0, 0, 5};
+  TestListValue *value2 = new TestListValue{nullptr, nullptr, 5};
-  TestListValue *value3 = new TestListValue{0, 0, 6};
+  TestListValue *value3 = new TestListValue{nullptr, nullptr, 6};
 
-  ListBase list = {NULL, NULL};
+  ListBase list = {nullptr, nullptr};
   BLI_addtail(&list, value1);
   BLI_addtail(&list, value2);
   BLI_addtail(&list, value3);

source/blender/blenlib/tests/performance/BLI_ghash_performance_test.cc

@@ -152,7 +152,7 @@ static void str_ghash_tests(GHash *ghash, const char *id)
     TIMEIT_END(string_lookup);
   }
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
   MEM_freeN(data);
   MEM_freeN(data_p);
   MEM_freeN(data_w);
@@ -227,7 +227,7 @@ static void int_ghash_tests(GHash *ghash, const char *id, const unsigned int nbr
   }
   EXPECT_EQ(BLI_ghash_len(ghash), 0);
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
 
   printf("========== ENDED %s ==========\n\n", id);
 }
@@ -309,7 +309,7 @@ static void randint_ghash_tests(GHash *ghash, const char *id, const unsigned int
     TIMEIT_END(int_lookup);
   }
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
   MEM_freeN(data);
 
   printf("========== ENDED %s ==========\n\n", id);
@@ -421,7 +421,7 @@ static void int4_ghash_tests(GHash *ghash, const char *id, const unsigned int nb
     TIMEIT_END(int_v4_lookup);
   }
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
   MEM_freeN(data);
 
   printf("========== ENDED %s ==========\n\n", id);
@@ -506,7 +506,7 @@ static void multi_small_ghash_tests_one(GHash *ghash, RNG *rng, const unsigned i
     EXPECT_EQ(POINTER_AS_UINT(v), *dt);
   }
 
-  BLI_ghash_clear(ghash, NULL, NULL);
+  BLI_ghash_clear(ghash, nullptr, nullptr);
   MEM_freeN(data);
 }
 
@@ -538,7 +538,7 @@ static void multi_small_ghash_tests(GHash *ghash, const char *id, const unsigned
 
   TIMEIT_END(multi_small2_ghash);
 
-  BLI_ghash_free(ghash, NULL, NULL);
+  BLI_ghash_free(ghash, nullptr, nullptr);
   BLI_rng_free(rng);
 
   printf("========== ENDED %s ==========\n\n", id);

source/blender/blenlib/tests/performance/BLI_task_performance_test.cc

@@ -119,7 +119,7 @@ static void task_listbase_test_do(ListBase *list,
     }
     LinkData *item;
     int j;
-    for (j = 0, item = (LinkData *)list->first; j < num_items && item != NULL;
+    for (j = 0, item = (LinkData *)list->first; j < num_items && item != nullptr;
          j++, item = item->next) {
       EXPECT_EQ(POINTER_AS_INT(item->data), j);
       item->data = POINTER_FROM_INT(0);
@@ -139,7 +139,7 @@ static void task_listbase_test(const char *id, const int nbr, const bool use_thr
 {
   printf("\n========== STARTING %s ==========\n", id);
 
-  ListBase list = {NULL, NULL};
+  ListBase list = {nullptr, nullptr};
   LinkData *items_buffer = (LinkData *)MEM_calloc_arrayN(nbr, sizeof(*items_buffer), __func__);
 
   BLI_threadapi_init();

source/blender/blenloader/tests/blendfile_loading_base_test.cc

@@ -127,7 +127,7 @@ bool BlendfileLoadingBaseTest::blendfile_load(const char *filepath)
   char abspath[FILENAME_MAX];
   BLI_path_join(abspath, sizeof(abspath), test_assets_dir.c_str(), filepath, NULL);
 
-  bfile = BLO_read_from_file(abspath, BLO_READ_SKIP_NONE, NULL /* reports */);
+  bfile = BLO_read_from_file(abspath, BLO_READ_SKIP_NONE, nullptr /* reports */);
   if (bfile == nullptr) {
     ADD_FAILURE() << "Unable to load file '" << filepath << "' from test assets dir '"
                   << test_assets_dir << "'";
@@ -144,7 +144,7 @@ void BlendfileLoadingBaseTest::blendfile_free()
 
   wmWindowManager *wm = static_cast<wmWindowManager *>(bfile->main->wm.first);
   if (wm != nullptr) {
-    wm_close_and_free(NULL, wm);
+    wm_close_and_free(nullptr, wm);
   }
   BLO_blendfiledata_free(bfile);
   bfile = nullptr;

source/blender/bmesh/tests/bmesh_core_test.cc

@@ -16,8 +16,8 @@ TEST(bmesh_core, BMVertCreate)
   EXPECT_EQ(bm->totvert, 0);
   /* make a custom layer so we can see if it is copied properly */
   BM_data_layer_add(bm, &bm->vdata, CD_PROP_FLOAT);
-  bv1 = BM_vert_create(bm, co1, NULL, BM_CREATE_NOP);
+  bv1 = BM_vert_create(bm, co1, nullptr, BM_CREATE_NOP);
-  ASSERT_TRUE(bv1 != NULL);
+  ASSERT_TRUE(bv1 != nullptr);
   EXPECT_EQ(bv1->co[0], 1.0f);
   EXPECT_EQ(bv1->co[1], 2.0f);
   EXPECT_EQ(bv1->co[2], 0.0f);
@@ -25,14 +25,14 @@ TEST(bmesh_core, BMVertCreate)
   EXPECT_EQ(bv1->head.htype, (char)BM_VERT);
   EXPECT_EQ(bv1->head.hflag, 0);
   EXPECT_EQ(bv1->head.api_flag, 0);
-  bv2 = BM_vert_create(bm, NULL, NULL, BM_CREATE_NOP);
+  bv2 = BM_vert_create(bm, nullptr, nullptr, BM_CREATE_NOP);
-  ASSERT_TRUE(bv2 != NULL);
+  ASSERT_TRUE(bv2 != nullptr);
   EXPECT_TRUE(is_zero_v3(bv2->co));
   /* create with example should copy custom data but not select flag */
   BM_vert_select_set(bm, bv2, true);
   BM_elem_float_data_set(&bm->vdata, bv2, CD_PROP_FLOAT, 1.5f);
   bv3 = BM_vert_create(bm, co1, bv2, BM_CREATE_NOP);
-  ASSERT_TRUE(bv3 != NULL);
+  ASSERT_TRUE(bv3 != nullptr);
   EXPECT_FALSE(BM_elem_flag_test((BMElem *)bv3, BM_ELEM_SELECT));
   EXPECT_EQ(BM_elem_float_data_get(&bm->vdata, bv3, CD_PROP_FLOAT), 1.5f);
   EXPECT_EQ(BM_mesh_elem_count(bm, BM_VERT), 3);

source/blender/bmesh/tools/bmesh_boolean.cc

@@ -121,7 +121,7 @@ static bool face_has_verts_in_order(BMesh *bm, BMFace *bmf, const BMVert *v1, co
 {
   BMIter liter;
   BMLoop *l = static_cast<BMLoop *>(BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, bmf));
-  while (l != NULL) {
+  while (l != nullptr) {
     if (l->v == v1 && l->next->v == v2) {
       return true;
     }
@@ -184,7 +184,7 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out)
       for (int i = 0; i < 3; ++i) {
         co[i] = static_cast<float>(d_co[i]);
       }
-      BMVert *bmv = BM_vert_create(bm, co, NULL, BM_CREATE_NOP);
+      BMVert *bmv = BM_vert_create(bm, co, nullptr, BM_CREATE_NOP);
       new_bmvs[v] = bmv;
       BM_elem_flag_enable(bmv, KEEP_FLAG);
       any_change = true;
@@ -231,7 +231,7 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out)
     BMFace *bmf = BM_face_exists(face_bmverts.data(), flen);
     /* #BM_face_exists checks if the face exists with the vertices in either order.
      * We can only reuse the face if the orientations are the same. */
-    if (bmf != NULL && face_has_verts_in_order(bm, bmf, face_bmverts[0], face_bmverts[1])) {
+    if (bmf != nullptr && face_has_verts_in_order(bm, bmf, face_bmverts[0], face_bmverts[1])) {
       BM_elem_flag_enable(bmf, KEEP_FLAG);
     }
     else {
@@ -242,20 +242,20 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out)
         orig_face = old_bmfs[orig];
       }
       else {
-        orig_face = NULL;
+        orig_face = nullptr;
       }
       /* Make or find #BMEdge's. */
       for (int i = 0; i < flen; ++i) {
         BMVert *bmv1 = face_bmverts[i];
         BMVert *bmv2 = face_bmverts[(i + 1) % flen];
         BMEdge *bme = BM_edge_exists(bmv1, bmv2);
-        if (bme == NULL) {
+        if (bme == nullptr) {
-          BMEdge *orig_edge = NULL;
+          BMEdge *orig_edge = nullptr;
           if (face.edge_orig[i] != NO_INDEX) {
             orig_edge = old_edges[face.edge_orig[i]];
           }
           bme = BM_edge_create(bm, bmv1, bmv2, orig_edge, BM_CREATE_NOP);
-          if (orig_edge != NULL) {
+          if (orig_edge != nullptr) {
             BM_elem_select_copy(bm, bme, orig_edge);
           }
         }
@@ -269,15 +269,15 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out)
       }
       BMFace *bmf = BM_face_create(
           bm, face_bmverts.data(), face_bmedges.data(), flen, orig_face, BM_CREATE_NOP);
-      if (orig_face != NULL) {
+      if (orig_face != nullptr) {
         BM_elem_select_copy(bm, bmf, orig_face);
       }
       BM_elem_flag_enable(bmf, KEEP_FLAG);
       /* Now do interpolation of loop data (e.g., UV's) using the example face. */
-      if (orig_face != NULL) {
+      if (orig_face != nullptr) {
         BMIter liter;
         BMLoop *l = static_cast<BMLoop *>(BM_iter_new(&liter, bm, BM_LOOPS_OF_FACE, bmf));
-        while (l != NULL) {
+        while (l != nullptr) {
           BM_loop_interp_from_face(bm, l, orig_face, true, true);
           l = static_cast<BMLoop *>(BM_iter_step(&liter));
         }
@@ -290,8 +290,8 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out)
   /* #BM_ITER_MESH_MUTABLE macro needs type casts for C++, so expand here.
    * TODO(howard): make some nice C++ iterators for #BMesh. */
   BMIter iter;
-  BMFace *bmf = static_cast<BMFace *>(BM_iter_new(&iter, bm, BM_FACES_OF_MESH, NULL));
+  BMFace *bmf = static_cast<BMFace *>(BM_iter_new(&iter, bm, BM_FACES_OF_MESH, nullptr));
-  while (bmf != NULL) {
+  while (bmf != nullptr) {
 #  ifdef DEBUG
     iter.count = BM_iter_mesh_count(BM_FACES_OF_MESH, bm);
 #  endif
@@ -308,8 +308,8 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out)
     }
     bmf = bmf_next;
   }
-  BMVert *bmv = static_cast<BMVert *>(BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL));
+  BMVert *bmv = static_cast<BMVert *>(BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, nullptr));
-  while (bmv != NULL) {
+  while (bmv != nullptr) {
 #  ifdef DEBUG
     iter.count = BM_iter_mesh_count(BM_VERTS_OF_MESH, bm);
 #  endif

source/blender/compositor/intern/COM_CPUDevice.cpp

@@ -32,5 +32,5 @@ void CPUDevice::execute(WorkPackage *work)
 
   executionGroup->getOutputOperation()->executeRegion(&rect, chunkNumber);
 
-  executionGroup->finalizeChunkExecution(chunkNumber, NULL);
+  executionGroup->finalizeChunkExecution(chunkNumber, nullptr);
 }

source/blender/compositor/intern/COM_CompositorContext.cpp

@@ -22,13 +22,13 @@
 
 CompositorContext::CompositorContext()
 {
-  this->m_scene = NULL;
+  this->m_scene = nullptr;
-  this->m_rd = NULL;
+  this->m_rd = nullptr;
   this->m_quality = COM_QUALITY_HIGH;
   this->m_hasActiveOpenCLDevices = false;
   this->m_fastCalculation = false;
-  this->m_viewSettings = NULL;
+  this->m_viewSettings = nullptr;
-  this->m_displaySettings = NULL;
+  this->m_displaySettings = nullptr;
 }
 
 int CompositorContext::getFramenumber() const

source/blender/compositor/intern/COM_Converter.cpp

@@ -133,11 +133,11 @@ bool Converter::is_fast_node(bNode *b_node)
 
 Node *Converter::convert(bNode *b_node)
 {
-  Node *node = NULL;
+  Node *node = nullptr;
 
   /* ignore undefined nodes with missing or invalid node data */
   if (!nodeIsRegistered(b_node)) {
-    return NULL;
+    return nullptr;
   }
 
   switch (b_node->type) {
@@ -439,7 +439,7 @@ NodeOperation *Converter::convertDataType(NodeOperationOutput *from, NodeOperati
     return new ConvertVectorToColorOperation();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void Converter::convertResolution(NodeOperationBuilder &builder,
@@ -498,8 +498,8 @@ void Converter::convertResolution(NodeOperationBuilder &builder,
   }
 
   if (doCenter) {
-    NodeOperation *first = NULL;
+    NodeOperation *first = nullptr;
-    ScaleOperation *scaleOperation = NULL;
+    ScaleOperation *scaleOperation = nullptr;
     if (doScale) {
       scaleOperation = new ScaleOperation();
       scaleOperation->getInputSocket(1)->setResizeMode(COM_SC_NO_RESIZE);

source/blender/compositor/intern/COM_ExecutionGroup.cpp

@@ -45,8 +45,8 @@ ExecutionGroup::ExecutionGroup()
 {
   this->m_isOutput = false;
   this->m_complex = false;
-  this->m_chunkExecutionStates = NULL;
+  this->m_chunkExecutionStates = nullptr;
-  this->m_bTree = NULL;
+  this->m_bTree = nullptr;
   this->m_height = 0;
   this->m_width = 0;
   this->m_cachedMaxReadBufferOffset = 0;
@@ -121,13 +121,13 @@ NodeOperation *ExecutionGroup::getOutputOperation() const
 
 void ExecutionGroup::initExecution()
 {
-  if (this->m_chunkExecutionStates != NULL) {
+  if (this->m_chunkExecutionStates != nullptr) {
     MEM_freeN(this->m_chunkExecutionStates);
   }
   unsigned int index;
   determineNumberOfChunks();
 
-  this->m_chunkExecutionStates = NULL;
+  this->m_chunkExecutionStates = nullptr;
   if (this->m_numberOfChunks != 0) {
     this->m_chunkExecutionStates = (ChunkExecutionState *)MEM_mallocN(
         sizeof(ChunkExecutionState) * this->m_numberOfChunks, __func__);
@@ -152,15 +152,15 @@ void ExecutionGroup::initExecution()
 
 void ExecutionGroup::deinitExecution()
 {
-  if (this->m_chunkExecutionStates != NULL) {
+  if (this->m_chunkExecutionStates != nullptr) {
     MEM_freeN(this->m_chunkExecutionStates);
-    this->m_chunkExecutionStates = NULL;
+    this->m_chunkExecutionStates = nullptr;
   }
   this->m_numberOfChunks = 0;
   this->m_numberOfXChunks = 0;
   this->m_numberOfYChunks = 0;
   this->m_cachedReadOperations.clear();
-  this->m_bTree = NULL;
+  this->m_bTree = nullptr;
 }
 void ExecutionGroup::determineResolution(unsigned int resolution[2])
 {
@@ -415,7 +415,7 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
       MemoryBuffer *buffer = memoryBuffers[index];
       if (buffer) {
         if (buffer->isTemporarily()) {
-          memoryBuffers[index] = NULL;
+          memoryBuffers[index] = nullptr;
           delete buffer;
         }
       }
@@ -478,7 +478,7 @@ MemoryBuffer *ExecutionGroup::allocateOutputBuffer(int /*chunkNumber*/, rcti *re
     MemoryBuffer *buffer = new MemoryBuffer(writeOperation->getMemoryProxy(), rect);
     return buffer;
   }
-  return NULL;
+  return nullptr;
 }
 
 bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area)
@@ -562,7 +562,7 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChun
     determineDependingAreaOfInterest(&rect, readOperation, &area);
     ExecutionGroup *group = memoryProxy->getExecutor();
 
-    if (group != NULL) {
+    if (group != nullptr) {
       if (!group->scheduleAreaWhenPossible(graph, &area)) {
         canBeExecuted = false;
       }

source/blender/compositor/intern/COM_MemoryBuffer.cpp

@@ -83,7 +83,7 @@ MemoryBuffer::MemoryBuffer(DataType dataType, rcti *rect)
   this->m_width = BLI_rcti_size_x(&this->m_rect);
   this->m_height = BLI_rcti_size_y(&this->m_rect);
   this->m_height = this->m_rect.ymax - this->m_rect.ymin;
-  this->m_memoryProxy = NULL;
+  this->m_memoryProxy = nullptr;
   this->m_chunkNumber = -1;
   this->m_num_channels = determine_num_channels(dataType);
   this->m_buffer = (float *)MEM_mallocN_aligned(
@@ -145,7 +145,7 @@ MemoryBuffer::~MemoryBuffer()
 {
   if (this->m_buffer) {
     MEM_freeN(this->m_buffer);
-    this->m_buffer = NULL;
+    this->m_buffer = nullptr;
   }
 }
 

source/blender/compositor/intern/COM_MemoryProxy.cpp

@@ -20,8 +20,8 @@
 
 MemoryProxy::MemoryProxy(DataType datatype)
 {
-  this->m_writeBufferOperation = NULL;
+  this->m_writeBufferOperation = nullptr;
-  this->m_executor = NULL;
+  this->m_executor = nullptr;
   this->m_datatype = datatype;
 }
 
@@ -40,6 +40,6 @@ void MemoryProxy::free()
 {
   if (this->m_buffer) {
     delete this->m_buffer;
-    this->m_buffer = NULL;
+    this->m_buffer = nullptr;
   }
 }

source/blender/compositor/intern/COM_Node.cpp

@@ -37,14 +37,14 @@
  **************/
 
 Node::Node(bNode *editorNode, bool create_sockets)
-    : m_editorNodeTree(NULL),
+    : m_editorNodeTree(nullptr),
       m_editorNode(editorNode),
       m_inActiveGroup(false),
       m_instanceKey(NODE_INSTANCE_KEY_NONE)
 {
   if (create_sockets) {
     bNodeSocket *input = (bNodeSocket *)editorNode->inputs.first;
-    while (input != NULL) {
+    while (input != nullptr) {
       DataType dt = COM_DT_VALUE;
       if (input->type == SOCK_RGBA) {
         dt = COM_DT_COLOR;
@@ -57,7 +57,7 @@ Node::Node(bNode *editorNode, bool create_sockets)
       input = input->next;
     }
     bNodeSocket *output = (bNodeSocket *)editorNode->outputs.first;
-    while (output != NULL) {
+    while (output != nullptr) {
       DataType dt = COM_DT_VALUE;
       if (output->type == SOCK_RGBA) {
         dt = COM_DT_COLOR;
@@ -86,7 +86,7 @@ Node::~Node()
 
 void Node::addInputSocket(DataType datatype)
 {
-  this->addInputSocket(datatype, NULL);
+  this->addInputSocket(datatype, nullptr);
 }
 
 void Node::addInputSocket(DataType datatype, bNodeSocket *bSocket)
@@ -97,7 +97,7 @@ void Node::addInputSocket(DataType datatype, bNodeSocket *bSocket)
 
 void Node::addOutputSocket(DataType datatype)
 {
-  this->addOutputSocket(datatype, NULL);
+  this->addOutputSocket(datatype, nullptr);
 }
 void Node::addOutputSocket(DataType datatype, bNodeSocket *bSocket)
 {
@@ -121,27 +121,27 @@ bNodeSocket *Node::getEditorInputSocket(int editorNodeInputSocketIndex)
 {
   bNodeSocket *bSock = (bNodeSocket *)this->getbNode()->inputs.first;
   int index = 0;
-  while (bSock != NULL) {
+  while (bSock != nullptr) {
     if (index == editorNodeInputSocketIndex) {
       return bSock;
     }
     index++;
     bSock = bSock->next;
   }
-  return NULL;
+  return nullptr;
 }
 bNodeSocket *Node::getEditorOutputSocket(int editorNodeOutputSocketIndex)
 {
   bNodeSocket *bSock = (bNodeSocket *)this->getbNode()->outputs.first;
   int index = 0;
-  while (bSock != NULL) {
+  while (bSock != nullptr) {
     if (index == editorNodeOutputSocketIndex) {
       return bSock;
     }
     index++;
     bSock = bSock->next;
   }
-  return NULL;
+  return nullptr;
 }
 
 /*******************
@@ -149,7 +149,7 @@ bNodeSocket *Node::getEditorOutputSocket(int editorNodeOutputSocketIndex)
  *******************/
 
 NodeInput::NodeInput(Node *node, bNodeSocket *b_socket, DataType datatype)
-    : m_node(node), m_editorSocket(b_socket), m_datatype(datatype), m_link(NULL)
+    : m_node(node), m_editorSocket(b_socket), m_datatype(datatype), m_link(nullptr)
 {
 }
 

source/blender/compositor/intern/COM_NodeGraph.cpp

@@ -61,7 +61,7 @@ bNodeSocket *NodeGraph::find_b_node_input(bNode *b_node, const char *identifier)
       return b_sock;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 bNodeSocket *NodeGraph::find_b_node_output(bNode *b_node, const char *identifier)
@@ -71,7 +71,7 @@ bNodeSocket *NodeGraph::find_b_node_output(bNode *b_node, const char *identifier
       return b_sock;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 void NodeGraph::add_node(Node *node,
@@ -179,7 +179,7 @@ NodeOutput *NodeGraph::find_output(const NodeRange &node_range, bNodeSocket *b_s
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 void NodeGraph::add_bNodeLink(const NodeRange &node_range, bNodeLink *b_nodelink)

source/blender/compositor/intern/COM_NodeOperation.cpp

@@ -36,7 +36,7 @@ NodeOperation::NodeOperation()
   this->m_height = 0;
   this->m_isResolutionSet = false;
   this->m_openCL = false;
-  this->m_btree = NULL;
+  this->m_btree = nullptr;
 }
 
 NodeOperation::~NodeOperation()
@@ -146,7 +146,7 @@ NodeOperation *NodeOperation::getInputOperation(unsigned int inputSocketIndex)
     return &input->getLink()->getOperation();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void NodeOperation::getConnectedInputSockets(Inputs *sockets)
@@ -199,7 +199,7 @@ bool NodeOperation::determineDependingAreaOfInterest(rcti *input,
 NodeOperationInput::NodeOperationInput(NodeOperation *op,
                                        DataType datatype,
                                        InputResizeMode resizeMode)
-    : m_operation(op), m_datatype(datatype), m_resizeMode(resizeMode), m_link(NULL)
+    : m_operation(op), m_datatype(datatype), m_resizeMode(resizeMode), m_link(nullptr)
 {
 }
 
@@ -209,7 +209,7 @@ SocketReader *NodeOperationInput::getReader()
     return &m_link->getOperation();
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void NodeOperationInput::determineResolution(unsigned int resolution[2],

source/blender/compositor/intern/COM_NodeOperationBuilder.cpp

@@ -38,7 +38,7 @@
 #include "COM_NodeOperationBuilder.h" /* own include */
 
 NodeOperationBuilder::NodeOperationBuilder(const CompositorContext *context, bNodeTree *b_nodetree)
-    : m_context(context), m_current_node(NULL), m_active_viewer(NULL)
+    : m_context(context), m_current_node(nullptr), m_active_viewer(nullptr)
 {
   m_graph.from_bNodeTree(*context, b_nodetree);
 }
@@ -61,7 +61,7 @@ void NodeOperationBuilder::convertToOperations(ExecutionSystem *system)
     node->convertToOperations(converter, *m_context);
   }
 
-  m_current_node = NULL;
+  m_current_node = nullptr;
 
   /* The input map constructed by nodes maps operation inputs to node inputs.
    * Inverting yields a map of node inputs to all connected operation inputs,
@@ -168,7 +168,7 @@ void NodeOperationBuilder::removeInputLink(NodeOperationInput *to)
     Link &link = *it;
     if (link.to() == to) {
       /* unregister with the input */
-      to->setLink(NULL);
+      to->setLink(nullptr);
 
       m_links.erase(it);
       return;
@@ -203,15 +203,15 @@ PreviewOperation *NodeOperationBuilder::make_preview_operation() const
   BLI_assert(m_current_node);
 
   if (!(m_current_node->getbNode()->flag & NODE_PREVIEW)) {
-    return NULL;
+    return nullptr;
   }
   /* previews only in the active group */
   if (!m_current_node->isInActiveGroup()) {
-    return NULL;
+    return nullptr;
   }
   /* do not calculate previews of hidden nodes */
   if (m_current_node->getbNode()->flag & NODE_HIDDEN) {
-    return NULL;
+    return nullptr;
   }
 
   bNodeInstanceHash *previews = m_context->getPreviewHash();
@@ -223,7 +223,7 @@ PreviewOperation *NodeOperationBuilder::make_preview_operation() const
     return operation;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void NodeOperationBuilder::addPreview(NodeOperationOutput *output)
@@ -476,7 +476,7 @@ WriteBufferOperation *NodeOperationBuilder::find_attached_write_buffer_operation
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 void NodeOperationBuilder::add_input_buffers(NodeOperation * /*operation*/,
@@ -526,13 +526,13 @@ void NodeOperationBuilder::add_output_buffers(NodeOperation *operation,
     return;
   }
 
-  WriteBufferOperation *writeOperation = NULL;
+  WriteBufferOperation *writeOperation = nullptr;
   for (OpInputs::const_iterator it = targets.begin(); it != targets.end(); ++it) {
     NodeOperationInput *target = *it;
 
     /* try to find existing write buffer operation */
     if (target->getOperation().isWriteBufferOperation()) {
-      BLI_assert(writeOperation == NULL); /* there should only be one write op connected */
+      BLI_assert(writeOperation == nullptr); /* there should only be one write op connected */
       writeOperation = (WriteBufferOperation *)(&target->getOperation());
     }
     else {
@@ -728,7 +728,7 @@ void NodeOperationBuilder::group_operations()
       ReadBufferOperation *read_op = (ReadBufferOperation *)op;
       MemoryProxy *memproxy = read_op->getMemoryProxy();
 
-      if (memproxy->getExecutor() == NULL) {
+      if (memproxy->getExecutor() == nullptr) {
         ExecutionGroup *group = make_group(memproxy->getWriteBufferOperation());
         memproxy->setExecutor(group);
       }

source/blender/compositor/intern/COM_OpenCLDevice.cpp

@@ -41,7 +41,7 @@ OpenCLDevice::OpenCLDevice(cl_context context,
   this->m_device = device;
   this->m_context = context;
   this->m_program = program;
-  this->m_queue = NULL;
+  this->m_queue = nullptr;
   this->m_vendorID = vendorId;
 }
 
@@ -196,7 +196,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel, MemoryBuffer *outputMemo
       (size_t)outputMemoryBuffer->getHeight(),
   };
 
-  error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
+  error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, nullptr, size, nullptr, 0, nullptr, nullptr);
   if (error != CL_SUCCESS) {
     printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
   }
@@ -243,7 +243,7 @@ void OpenCLDevice::COM_clEnqueueRange(cl_kernel kernel,
       if (error != CL_SUCCESS) {
         printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
       }
-      error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, NULL, size, 0, 0, 0, NULL);
+      error = clEnqueueNDRangeKernel(this->m_queue, kernel, 2, nullptr, size, nullptr, 0, nullptr, nullptr);
       if (error != CL_SUCCESS) {
         printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
       }

source/blender/compositor/intern/COM_SingleThreadedOperation.cpp

@@ -20,7 +20,7 @@
 
 SingleThreadedOperation::SingleThreadedOperation()
 {
-  this->m_cachedInstance = NULL;
+  this->m_cachedInstance = nullptr;
   setComplex(true);
 }
 
@@ -39,7 +39,7 @@ void SingleThreadedOperation::deinitExecution()
   deinitMutex();
   if (this->m_cachedInstance) {
     delete this->m_cachedInstance;
-    this->m_cachedInstance = NULL;
+    this->m_cachedInstance = nullptr;
   }
 }
 void *SingleThreadedOperation::initializeTileData(rcti *rect)
@@ -49,7 +49,7 @@ void *SingleThreadedOperation::initializeTileData(rcti *rect)
   }
 
   lockMutex();
-  if (this->m_cachedInstance == NULL) {
+  if (this->m_cachedInstance == nullptr) {
     //
     this->m_cachedInstance = createMemoryBuffer(rect);
   }

source/blender/compositor/intern/COM_WorkScheduler.cpp

@@ -80,7 +80,7 @@ void *WorkScheduler::thread_execute_cpu(void *data)
     delete work;
   }
 
-  return NULL;
+  return nullptr;
 }
 
 void *WorkScheduler::thread_execute_gpu(void *data)
@@ -93,7 +93,7 @@ void *WorkScheduler::thread_execute_gpu(void *data)
     delete work;
   }
 
-  return NULL;
+  return nullptr;
 }
 #endif
 
@@ -166,13 +166,13 @@ void WorkScheduler::stop()
   BLI_thread_queue_nowait(g_cpuqueue);
   BLI_threadpool_end(&g_cputhreads);
   BLI_thread_queue_free(g_cpuqueue);
-  g_cpuqueue = NULL;
+  g_cpuqueue = nullptr;
 #  ifdef COM_OPENCL_ENABLED
   if (g_openclActive) {
     BLI_thread_queue_nowait(g_gpuqueue);
     BLI_threadpool_end(&g_gputhreads);
     BLI_thread_queue_free(g_gpuqueue);
-    g_gpuqueue = NULL;
+    g_gpuqueue = nullptr;
   }
 #  endif
 #endif
@@ -234,8 +234,8 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
 #  ifdef COM_OPENCL_ENABLED
   /* deinitialize OpenCL GPU's */
   if (use_opencl && !g_openclInitialized) {
-    g_context = NULL;
+    g_context = nullptr;
-    g_program = NULL;
+    g_program = nullptr;
 
     /* This will check for errors and skip if already initialized. */
     if (clewInit() != CLEW_SUCCESS) {
@@ -245,7 +245,7 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
     if (clCreateContextFromType) {
       cl_uint numberOfPlatforms = 0;
       cl_int error;
-      error = clGetPlatformIDs(0, 0, &numberOfPlatforms);
+      error = clGetPlatformIDs(0, nullptr, &numberOfPlatforms);
       if (error == -1001) {
       } /* GPU not supported */
       else if (error != CL_SUCCESS) {
@@ -256,40 +256,40 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
       }
       cl_platform_id *platforms = (cl_platform_id *)MEM_mallocN(
           sizeof(cl_platform_id) * numberOfPlatforms, __func__);
-      error = clGetPlatformIDs(numberOfPlatforms, platforms, 0);
+      error = clGetPlatformIDs(numberOfPlatforms, platforms, nullptr);
       unsigned int indexPlatform;
       for (indexPlatform = 0; indexPlatform < numberOfPlatforms; indexPlatform++) {
         cl_platform_id platform = platforms[indexPlatform];
         cl_uint numberOfDevices = 0;
-        clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, 0, &numberOfDevices);
+        clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, nullptr, &numberOfDevices);
         if (numberOfDevices <= 0) {
           continue;
         }
 
         cl_device_id *cldevices = (cl_device_id *)MEM_mallocN(
             sizeof(cl_device_id) * numberOfDevices, __func__);
-        clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numberOfDevices, cldevices, 0);
+        clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, numberOfDevices, cldevices, nullptr);
 
         g_context = clCreateContext(
-            NULL, numberOfDevices, cldevices, clContextError, NULL, &error);
+            nullptr, numberOfDevices, cldevices, clContextError, nullptr, &error);
         if (error != CL_SUCCESS) {
           printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
         }
-        const char *cl_str[2] = {datatoc_COM_OpenCLKernels_cl, NULL};
+        const char *cl_str[2] = {datatoc_COM_OpenCLKernels_cl, nullptr};
-        g_program = clCreateProgramWithSource(g_context, 1, cl_str, 0, &error);
+        g_program = clCreateProgramWithSource(g_context, 1, cl_str, nullptr, &error);
-        error = clBuildProgram(g_program, numberOfDevices, cldevices, 0, 0, 0);
+        error = clBuildProgram(g_program, numberOfDevices, cldevices, nullptr, nullptr, nullptr);
         if (error != CL_SUCCESS) {
           cl_int error2;
           size_t ret_val_size = 0;
           printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
           error2 = clGetProgramBuildInfo(
-              g_program, cldevices[0], CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
+              g_program, cldevices[0], CL_PROGRAM_BUILD_LOG, 0, nullptr, &ret_val_size);
           if (error2 != CL_SUCCESS) {
             printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
           }
           char *build_log = (char *)MEM_mallocN(sizeof(char) * ret_val_size + 1, __func__);
           error2 = clGetProgramBuildInfo(
-              g_program, cldevices[0], CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
+              g_program, cldevices[0], CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, nullptr);
           if (error2 != CL_SUCCESS) {
             printf("CLERROR[%d]: %s\n", error, clewErrorString(error));
           }
@@ -303,7 +303,7 @@ void WorkScheduler::initialize(bool use_opencl, int num_cpu_threads)
             cl_device_id device = cldevices[indexDevices];
             cl_int vendorID = 0;
             cl_int error2 = clGetDeviceInfo(
-                device, CL_DEVICE_VENDOR_ID, sizeof(cl_int), &vendorID, NULL);
+                device, CL_DEVICE_VENDOR_ID, sizeof(cl_int), &vendorID, nullptr);
             if (error2 != CL_SUCCESS) {
               printf("CLERROR[%d]: %s\n", error2, clewErrorString(error2));
             }
@@ -351,11 +351,11 @@ void WorkScheduler::deinitialize()
     }
     if (g_program) {
       clReleaseProgram(g_program);
-      g_program = NULL;
+      g_program = nullptr;
     }
     if (g_context) {
       clReleaseContext(g_context);
-      g_context = NULL;
+      g_context = nullptr;
     }
 
     g_openclInitialized = false;

source/blender/compositor/nodes/COM_BlurNode.cpp

@@ -46,7 +46,7 @@ void BlurNode::convertToOperations(NodeConverter &converter,
   const bool extend_bounds = (editorNode->custom1 & CMP_NODEFLAG_BLUR_EXTEND_BOUNDS) != 0;
 
   CompositorQuality quality = context.getQuality();
-  NodeOperation *input_operation = NULL, *output_operation = NULL;
+  NodeOperation *input_operation = nullptr, *output_operation = nullptr;
 
   if (data->filtertype == R_FILTER_FAST_GAUSS) {
     FastGaussianBlurOperation *operationfgb = new FastGaussianBlurOperation();

source/blender/compositor/nodes/COM_ChannelMatteNode.cpp

@@ -36,7 +36,7 @@ void ChannelMatteNode::convertToOperations(NodeConverter &converter,
   NodeOutput *outputSocketImage = this->getOutputSocket(0);
   NodeOutput *outputSocketMatte = this->getOutputSocket(1);
 
-  NodeOperation *convert = NULL, *inv_convert = NULL;
+  NodeOperation *convert = nullptr, *inv_convert = nullptr;
   /* colorspace */
   switch (node->custom1) {
     case CMP_NODE_CHANNEL_MATTE_CS_RGB:
@@ -67,7 +67,7 @@ void ChannelMatteNode::convertToOperations(NodeConverter &converter,
   SetAlphaOperation *operationAlpha = new SetAlphaOperation();
   converter.addOperation(operationAlpha);
 
-  if (convert != NULL) {
+  if (convert != nullptr) {
     converter.addOperation(convert);
 
     converter.mapInputSocket(inputSocketImage, convert->getInputSocket(0));
@@ -82,7 +82,7 @@ void ChannelMatteNode::convertToOperations(NodeConverter &converter,
   converter.mapOutputSocket(outputSocketMatte, operation->getOutputSocket(0));
   converter.addLink(operation->getOutputSocket(), operationAlpha->getInputSocket(1));
 
-  if (inv_convert != NULL) {
+  if (inv_convert != nullptr) {
     converter.addOperation(inv_convert);
     converter.addLink(operationAlpha->getOutputSocket(0), inv_convert->getInputSocket(0));
     converter.mapOutputSocket(outputSocketImage, inv_convert->getOutputSocket());

source/blender/compositor/nodes/COM_CombineColorNode.cpp

@@ -67,7 +67,7 @@ void CombineColorNode::convertToOperations(NodeConverter &converter,
 
 NodeOperation *CombineRGBANode::getColorConverter(const CompositorContext & /*context*/) const
 {
-  return NULL; /* no conversion needed */
+  return nullptr; /* no conversion needed */
 }
 
 NodeOperation *CombineHSVANode::getColorConverter(const CompositorContext & /*context*/) const

source/blender/compositor/nodes/COM_ConvertAlphaNode.cpp

@@ -23,7 +23,7 @@
 void ConvertAlphaNode::convertToOperations(NodeConverter &converter,
                                            const CompositorContext & /*context*/) const
 {
-  NodeOperation *operation = NULL;
+  NodeOperation *operation = nullptr;
   bNode *node = this->getbNode();
 
   /* value hardcoded in rna_nodetree.c */

source/blender/compositor/nodes/COM_DefocusNode.cpp

@@ -41,7 +41,7 @@ void DefocusNode::convertToOperations(NodeConverter &converter,
   bNode *node = this->getbNode();
   NodeDefocus *data = (NodeDefocus *)node->storage;
   Scene *scene = node->id ? (Scene *)node->id : context.getScene();
-  Object *camob = scene ? scene->camera : NULL;
+  Object *camob = scene ? scene->camera : nullptr;
 
   NodeOperation *radiusOperation;
   if (data->no_zbuf) {

source/blender/compositor/nodes/COM_FilterNode.cpp

@@ -34,7 +34,7 @@ void FilterNode::convertToOperations(NodeConverter &converter,
   NodeInput *inputSocket = this->getInputSocket(0);
   NodeInput *inputImageSocket = this->getInputSocket(1);
   NodeOutput *outputSocket = this->getOutputSocket(0);
-  ConvolutionFilterOperation *operation = NULL;
+  ConvolutionFilterOperation *operation = nullptr;
 
   switch (this->getbNode()->custom1) {
     case CMP_FILT_SOFT:

source/blender/compositor/nodes/COM_GlareNode.cpp

@@ -38,7 +38,7 @@ void GlareNode::convertToOperations(NodeConverter &converter,
   bNode *node = this->getbNode();
   NodeGlare *glare = (NodeGlare *)node->storage;
 
-  GlareBaseOperation *glareoperation = NULL;
+  GlareBaseOperation *glareoperation = nullptr;
   switch (glare->type) {
     default:
     case 3:

source/blender/compositor/nodes/COM_ImageNode.cpp

@@ -44,7 +44,7 @@ NodeOperation *ImageNode::doMultilayerCheck(NodeConverter &converter,
                                             DataType datatype) const
 {
   NodeOutput *outputSocket = this->getOutputSocket(outputsocketIndex);
-  MultilayerBaseOperation *operation = NULL;
+  MultilayerBaseOperation *operation = nullptr;
   switch (datatype) {
     case COM_DT_VALUE:
       operation = new MultilayerValueOperation(passindex, view);
@@ -84,7 +84,7 @@ void ImageNode::convertToOperations(NodeConverter &converter,
   /* force a load, we assume iuser index will be set OK anyway */
   if (image && image->type == IMA_TYPE_MULTILAYER) {
     bool is_multilayer_ok = false;
-    ImBuf *ibuf = BKE_image_acquire_ibuf(image, imageuser, NULL);
+    ImBuf *ibuf = BKE_image_acquire_ibuf(image, imageuser, nullptr);
     if (image->rr) {
       RenderLayer *rl = (RenderLayer *)BLI_findlink(&image->rr->layers, imageuser->layer);
       if (rl) {
@@ -94,7 +94,7 @@ void ImageNode::convertToOperations(NodeConverter &converter,
         is_multilayer_ok = true;
 
         for (index = 0; index < numberOfOutputs; index++) {
-          NodeOperation *operation = NULL;
+          NodeOperation *operation = nullptr;
           socket = this->getOutputSocket(index);
           bNodeSocket *bnodeSocket = socket->getbNodeSocket();
           NodeImageLayer *storage = (NodeImageLayer *)bnodeSocket->storage;
@@ -196,13 +196,13 @@ void ImageNode::convertToOperations(NodeConverter &converter,
           }
 
           /* In case we can't load the layer. */
-          if (operation == NULL) {
+          if (operation == nullptr) {
             converter.setInvalidOutput(getOutputSocket(index));
           }
         }
       }
     }
-    BKE_image_release_ibuf(image, ibuf, NULL);
+    BKE_image_release_ibuf(image, ibuf, nullptr);
 
     /* without this, multilayer that fail to load will crash blender T32490. */
     if (is_multilayer_ok == false) {
@@ -263,7 +263,7 @@ void ImageNode::convertToOperations(NodeConverter &converter,
       /* happens when unlinking image datablock from multilayer node */
       for (int i = 3; i < numberOfOutputs; i++) {
         NodeOutput *output = this->getOutputSocket(i);
-        NodeOperation *operation = NULL;
+        NodeOperation *operation = nullptr;
         switch (output->getDataType()) {
           case COM_DT_VALUE: {
             SetValueOperation *valueoperation = new SetValueOperation();

source/blender/compositor/nodes/COM_KeyingNode.cpp

@@ -228,7 +228,7 @@ void KeyingNode::convertToOperations(NodeConverter &converter,
   NodeOutput *outputImage = this->getOutputSocket(0);
   NodeOutput *outputMatte = this->getOutputSocket(1);
   NodeOutput *outputEdges = this->getOutputSocket(2);
-  NodeOperationOutput *postprocessedMatte = NULL, *postprocessedImage = NULL, *edgesMatte = NULL;
+  NodeOperationOutput *postprocessedMatte = nullptr, *postprocessedImage = nullptr, *edgesMatte = nullptr;
 
   /* keying operation */
   KeyingOperation *keyingOperation = new KeyingOperation();

source/blender/compositor/nodes/COM_MathNode.cpp

@@ -23,7 +23,7 @@
 void MathNode::convertToOperations(NodeConverter &converter,
                                    const CompositorContext & /*context*/) const
 {
-  MathBaseOperation *operation = NULL;
+  MathBaseOperation *operation = nullptr;
 
   switch (this->getbNode()->custom1) {
     case NODE_MATH_ADD:

source/blender/compositor/nodes/COM_MovieClipNode.cpp

@@ -49,7 +49,7 @@ void MovieClipNode::convertToOperations(NodeConverter &converter,
   MovieClipUser *movieClipUser = (MovieClipUser *)editorNode->storage;
   bool cacheFrame = !context.isRendering();
 
-  ImBuf *ibuf = NULL;
+  ImBuf *ibuf = nullptr;
   if (movieClip) {
     if (cacheFrame) {
       ibuf = BKE_movieclip_get_ibuf(movieClip, movieClipUser);

source/blender/compositor/nodes/COM_OutputFileNode.cpp

@@ -100,7 +100,7 @@ void OutputFileNode::convertToOperations(NodeConverter &converter,
         /* combine file path for the input */
         BLI_join_dirfile(path, FILE_MAX, storage->base_path, sockdata->path);
 
-        NodeOperation *outputOperation = NULL;
+        NodeOperation *outputOperation = nullptr;
 
         if (is_multiview && format->views_format == R_IMF_VIEWS_MULTIVIEW) {
           outputOperation = new OutputOpenExrSingleLayerMultiViewOperation(

source/blender/compositor/nodes/COM_RenderLayersNode.cpp

@@ -58,17 +58,17 @@ void RenderLayersNode::testRenderLink(NodeConverter &converter,
   Scene *scene = (Scene *)this->getbNode()->id;
   const short layerId = this->getbNode()->custom1;
   RenderResult *rr = RE_AcquireResultRead(re);
-  if (rr == NULL) {
+  if (rr == nullptr) {
     missingRenderLink(converter);
     return;
   }
   ViewLayer *view_layer = (ViewLayer *)BLI_findlink(&scene->view_layers, layerId);
-  if (view_layer == NULL) {
+  if (view_layer == nullptr) {
     missingRenderLink(converter);
     return;
   }
   RenderLayer *rl = RE_GetRenderLayer(rr, view_layer->name);
-  if (rl == NULL) {
+  if (rl == nullptr) {
     missingRenderLink(converter);
     return;
   }
@@ -78,7 +78,7 @@ void RenderLayersNode::testRenderLink(NodeConverter &converter,
     NodeImageLayer *storage = (NodeImageLayer *)output->getbNodeSocket()->storage;
     RenderPass *rpass = (RenderPass *)BLI_findstring(
         &rl->passes, storage->pass_name, offsetof(RenderPass, name));
-    if (rpass == NULL) {
+    if (rpass == nullptr) {
       missingSocketLink(converter, output);
       continue;
     }
@@ -164,9 +164,9 @@ void RenderLayersNode::convertToOperations(NodeConverter &converter,
                                            const CompositorContext &context) const
 {
   Scene *scene = (Scene *)this->getbNode()->id;
-  Render *re = (scene) ? RE_GetSceneRender(scene) : NULL;
+  Render *re = (scene) ? RE_GetSceneRender(scene) : nullptr;
 
-  if (re != NULL) {
+  if (re != nullptr) {
     testRenderLink(converter, context, re);
     RE_ReleaseResult(re);
   }

source/blender/compositor/nodes/COM_SeparateColorNode.cpp

@@ -99,7 +99,7 @@ void SeparateColorNode::convertToOperations(NodeConverter &converter,
 
 NodeOperation *SeparateRGBANode::getColorConverter(const CompositorContext & /*context*/) const
 {
-  return NULL; /* no conversion needed */
+  return nullptr; /* no conversion needed */
 }
 
 NodeOperation *SeparateHSVANode::getColorConverter(const CompositorContext & /*context*/) const

source/blender/compositor/nodes/COM_ZCombineNode.cpp

@@ -32,7 +32,7 @@ void ZCombineNode::convertToOperations(NodeConverter &converter,
                                        const CompositorContext &context) const
 {
   if ((context.getRenderData()->scemode & R_FULL_SAMPLE) || this->getbNode()->custom2) {
-    ZCombineOperation *operation = NULL;
+    ZCombineOperation *operation = nullptr;
     if (this->getbNode()->custom1) {
       operation = new ZCombineAlphaOperation();
     }

source/blender/compositor/operations/COM_AntiAliasOperation.cpp

@@ -116,7 +116,7 @@ AntiAliasOperation::AntiAliasOperation()
 {
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_valueReader = NULL;
+  this->m_valueReader = nullptr;
   this->setComplex(true);
 }
 
@@ -179,7 +179,7 @@ void AntiAliasOperation::executePixel(float output[4], int x, int y, void *data)
 
 void AntiAliasOperation::deinitExecution()
 {
-  this->m_valueReader = NULL;
+  this->m_valueReader = nullptr;
 }
 
 bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input,

source/blender/compositor/operations/COM_BilateralBlurOperation.cpp

@@ -28,8 +28,8 @@ BilateralBlurOperation::BilateralBlurOperation()
   this->addOutputSocket(COM_DT_COLOR);
   this->setComplex(true);
 
-  this->m_inputColorProgram = NULL;
+  this->m_inputColorProgram = nullptr;
-  this->m_inputDeterminatorProgram = NULL;
+  this->m_inputDeterminatorProgram = nullptr;
 }
 
 void BilateralBlurOperation::initExecution()
@@ -94,8 +94,8 @@ void BilateralBlurOperation::executePixel(float output[4], int x, int y, void *d
 
 void BilateralBlurOperation::deinitExecution()
 {
-  this->m_inputColorProgram = NULL;
+  this->m_inputColorProgram = nullptr;
-  this->m_inputDeterminatorProgram = NULL;
+  this->m_inputDeterminatorProgram = nullptr;
 }
 
 bool BilateralBlurOperation::determineDependingAreaOfInterest(rcti *input,

source/blender/compositor/operations/COM_BlurBaseOperation.cpp

@@ -29,7 +29,7 @@ BlurBaseOperation::BlurBaseOperation(DataType data_type)
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(data_type);
   this->setComplex(true);
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
   memset(&m_data, 0, sizeof(NodeBlurData));
   this->m_size = 1.0f;
   this->m_sizeavailable = false;
@@ -154,8 +154,8 @@ float *BlurBaseOperation::make_dist_fac_inverse(float rad, int size, int falloff
 
 void BlurBaseOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
-  this->m_inputSize = NULL;
+  this->m_inputSize = nullptr;
 }
 
 void BlurBaseOperation::setData(const NodeBlurData *data)

source/blender/compositor/operations/COM_BokehBlurOperation.cpp

@@ -34,9 +34,9 @@ BokehBlurOperation::BokehBlurOperation()
 
   this->m_size = 1.0f;
   this->m_sizeavailable = false;
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
-  this->m_inputBokehProgram = NULL;
+  this->m_inputBokehProgram = nullptr;
-  this->m_inputBoundingBoxReader = NULL;
+  this->m_inputBoundingBoxReader = nullptr;
 
   this->m_extend_bounds = false;
 }
@@ -47,7 +47,7 @@ void *BokehBlurOperation::initializeTileData(rcti * /*rect*/)
   if (!this->m_sizeavailable) {
     updateSize();
   }
-  void *buffer = getInputOperation(0)->initializeTileData(NULL);
+  void *buffer = getInputOperation(0)->initializeTileData(nullptr);
   unlockMutex();
   return buffer;
 }
@@ -133,9 +133,9 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data)
 void BokehBlurOperation::deinitExecution()
 {
   deinitMutex();
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
-  this->m_inputBokehProgram = NULL;
+  this->m_inputBokehProgram = nullptr;
-  this->m_inputBoundingBoxReader = NULL;
+  this->m_inputBoundingBoxReader = nullptr;
 }
 
 bool BokehBlurOperation::determineDependingAreaOfInterest(rcti *input,
@@ -196,7 +196,7 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice *device,
                                        list<cl_mem> *clMemToCleanUp,
                                        list<cl_kernel> * /*clKernelsToCleanUp*/)
 {
-  cl_kernel kernel = device->COM_clCreateKernel("bokehBlurKernel", NULL);
+  cl_kernel kernel = device->COM_clCreateKernel("bokehBlurKernel", nullptr);
   if (!this->m_sizeavailable) {
     updateSize();
   }

source/blender/compositor/operations/COM_BokehImageOperation.cpp

@@ -113,7 +113,7 @@ void BokehImageOperation::deinitExecution()
   if (this->m_deleteData) {
     if (this->m_data) {
       delete this->m_data;
-      this->m_data = NULL;
+      this->m_data = nullptr;
     }
   }
 }

source/blender/compositor/operations/COM_BoxMaskOperation.cpp

@@ -25,8 +25,8 @@ BoxMaskOperation::BoxMaskOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_inputMask = NULL;
+  this->m_inputMask = nullptr;
-  this->m_inputValue = NULL;
+  this->m_inputValue = nullptr;
   this->m_cosine = 0.0f;
   this->m_sine = 0.0f;
 }
@@ -105,6 +105,6 @@ void BoxMaskOperation::executePixelSampled(float output[4], float x, float y, Pi
 
 void BoxMaskOperation::deinitExecution()
 {
-  this->m_inputMask = NULL;
+  this->m_inputMask = nullptr;
-  this->m_inputValue = NULL;
+  this->m_inputValue = nullptr;
 }

source/blender/compositor/operations/COM_BrightnessOperation.cpp

@@ -24,7 +24,7 @@ BrightnessOperation::BrightnessOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
   this->m_use_premultiply = false;
 }
 
@@ -85,7 +85,7 @@ void BrightnessOperation::executePixelSampled(float output[4],
 
 void BrightnessOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
-  this->m_inputBrightnessProgram = NULL;
+  this->m_inputBrightnessProgram = nullptr;
-  this->m_inputContrastProgram = NULL;
+  this->m_inputContrastProgram = nullptr;
 }

source/blender/compositor/operations/COM_CalculateMeanOperation.cpp

@@ -26,7 +26,7 @@ CalculateMeanOperation::CalculateMeanOperation()
 {
   this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_imageReader = NULL;
+  this->m_imageReader = nullptr;
   this->m_iscalculated = false;
   this->m_setting = 1;
   this->setComplex(true);
@@ -45,7 +45,7 @@ void CalculateMeanOperation::executePixel(float output[4], int /*x*/, int /*y*/,
 
 void CalculateMeanOperation::deinitExecution()
 {
-  this->m_imageReader = NULL;
+  this->m_imageReader = nullptr;
   NodeOperation::deinitMutex();
 }
 
@@ -77,7 +77,7 @@ void *CalculateMeanOperation::initializeTileData(rcti *rect)
     this->m_iscalculated = true;
   }
   unlockMutex();
-  return NULL;
+  return nullptr;
 }
 
 void CalculateMeanOperation::calculateMean(MemoryBuffer *tile)

source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp

@@ -99,5 +99,5 @@ void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect)
     this->m_iscalculated = true;
   }
   unlockMutex();
-  return NULL;
+  return nullptr;
 }

source/blender/compositor/operations/COM_ChangeHSVOperation.cpp

@@ -25,7 +25,7 @@ ChangeHSVOperation::ChangeHSVOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 
 void ChangeHSVOperation::initExecution()
@@ -38,10 +38,10 @@ void ChangeHSVOperation::initExecution()
 
 void ChangeHSVOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
-  this->m_hueOperation = NULL;
+  this->m_hueOperation = nullptr;
-  this->m_saturationOperation = NULL;
+  this->m_saturationOperation = nullptr;
-  this->m_valueOperation = NULL;
+  this->m_valueOperation = nullptr;
 }
 
 void ChangeHSVOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_ChannelMatteOperation.cpp

@@ -24,7 +24,7 @@ ChannelMatteOperation::ChannelMatteOperation()
   addInputSocket(COM_DT_COLOR);
   addOutputSocket(COM_DT_VALUE);
 
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
 }
 
 void ChannelMatteOperation::initExecution()
@@ -77,7 +77,7 @@ void ChannelMatteOperation::initExecution()
 
 void ChannelMatteOperation::deinitExecution()
 {
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
 }
 
 void ChannelMatteOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_ChromaMatteOperation.cpp

@@ -25,8 +25,8 @@ ChromaMatteOperation::ChromaMatteOperation()
   addInputSocket(COM_DT_COLOR);
   addOutputSocket(COM_DT_VALUE);
 
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputKeyProgram = NULL;
+  this->m_inputKeyProgram = nullptr;
 }
 
 void ChromaMatteOperation::initExecution()
@@ -37,8 +37,8 @@ void ChromaMatteOperation::initExecution()
 
 void ChromaMatteOperation::deinitExecution()
 {
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputKeyProgram = NULL;
+  this->m_inputKeyProgram = nullptr;
 }
 
 void ChromaMatteOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp

@@ -36,8 +36,8 @@ ColorBalanceASCCDLOperation::ColorBalanceASCCDLOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputValueOperation = NULL;
+  this->m_inputValueOperation = nullptr;
-  this->m_inputColorOperation = NULL;
+  this->m_inputColorOperation = nullptr;
   this->setResolutionInputSocketIndex(1);
 }
 
@@ -76,6 +76,6 @@ void ColorBalanceASCCDLOperation::executePixelSampled(float output[4],
 
 void ColorBalanceASCCDLOperation::deinitExecution()
 {
-  this->m_inputValueOperation = NULL;
+  this->m_inputValueOperation = nullptr;
-  this->m_inputColorOperation = NULL;
+  this->m_inputColorOperation = nullptr;
 }

source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp

@@ -41,8 +41,8 @@ ColorBalanceLGGOperation::ColorBalanceLGGOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputValueOperation = NULL;
+  this->m_inputValueOperation = nullptr;
-  this->m_inputColorOperation = NULL;
+  this->m_inputColorOperation = nullptr;
   this->setResolutionInputSocketIndex(1);
 }
 
@@ -81,6 +81,6 @@ void ColorBalanceLGGOperation::executePixelSampled(float output[4],
 
 void ColorBalanceLGGOperation::deinitExecution()
 {
-  this->m_inputValueOperation = NULL;
+  this->m_inputValueOperation = nullptr;
-  this->m_inputColorOperation = NULL;
+  this->m_inputColorOperation = nullptr;
 }

source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp

@@ -26,8 +26,8 @@ ColorCorrectionOperation::ColorCorrectionOperation()
   this->addInputSocket(COM_DT_COLOR);
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputImage = NULL;
+  this->m_inputImage = nullptr;
-  this->m_inputMask = NULL;
+  this->m_inputMask = nullptr;
   this->m_redChannelEnabled = true;
   this->m_greenChannelEnabled = true;
   this->m_blueChannelEnabled = true;
@@ -157,6 +157,6 @@ void ColorCorrectionOperation::executePixelSampled(float output[4],
 
 void ColorCorrectionOperation::deinitExecution()
 {
-  this->m_inputImage = NULL;
+  this->m_inputImage = nullptr;
-  this->m_inputMask = NULL;
+  this->m_inputMask = nullptr;
 }

source/blender/compositor/operations/COM_ColorCurveOperation.cpp

@@ -30,10 +30,10 @@ ColorCurveOperation::ColorCurveOperation()
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
 
-  this->m_inputFacProgram = NULL;
+  this->m_inputFacProgram = nullptr;
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputBlackProgram = NULL;
+  this->m_inputBlackProgram = nullptr;
-  this->m_inputWhiteProgram = NULL;
+  this->m_inputWhiteProgram = nullptr;
 
   this->setResolutionInputSocketIndex(1);
 }
@@ -90,10 +90,10 @@ void ColorCurveOperation::executePixelSampled(float output[4],
 void ColorCurveOperation::deinitExecution()
 {
   CurveBaseOperation::deinitExecution();
-  this->m_inputFacProgram = NULL;
+  this->m_inputFacProgram = nullptr;
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputBlackProgram = NULL;
+  this->m_inputBlackProgram = nullptr;
-  this->m_inputWhiteProgram = NULL;
+  this->m_inputWhiteProgram = nullptr;
 }
 
 // Constant level curve mapping
@@ -104,8 +104,8 @@ ConstantLevelColorCurveOperation::ConstantLevelColorCurveOperation()
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
 
-  this->m_inputFacProgram = NULL;
+  this->m_inputFacProgram = nullptr;
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
 
   this->setResolutionInputSocketIndex(1);
 }
@@ -148,6 +148,6 @@ void ConstantLevelColorCurveOperation::executePixelSampled(float output[4],
 void ConstantLevelColorCurveOperation::deinitExecution()
 {
   CurveBaseOperation::deinitExecution();
-  this->m_inputFacProgram = NULL;
+  this->m_inputFacProgram = nullptr;
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
 }

source/blender/compositor/operations/COM_ColorMatteOperation.cpp

@@ -25,8 +25,8 @@ ColorMatteOperation::ColorMatteOperation()
   addInputSocket(COM_DT_COLOR);
   addOutputSocket(COM_DT_VALUE);
 
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputKeyProgram = NULL;
+  this->m_inputKeyProgram = nullptr;
 }
 
 void ColorMatteOperation::initExecution()
@@ -37,8 +37,8 @@ void ColorMatteOperation::initExecution()
 
 void ColorMatteOperation::deinitExecution()
 {
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputKeyProgram = NULL;
+  this->m_inputKeyProgram = nullptr;
 }
 
 void ColorMatteOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_ColorRampOperation.cpp

@@ -25,8 +25,8 @@ ColorRampOperation::ColorRampOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
 
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
-  this->m_colorBand = NULL;
+  this->m_colorBand = nullptr;
 }
 void ColorRampOperation::initExecution()
 {
@@ -46,5 +46,5 @@ void ColorRampOperation::executePixelSampled(float output[4],
 
 void ColorRampOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }

source/blender/compositor/operations/COM_ColorSpillOperation.cpp

@@ -26,8 +26,8 @@ ColorSpillOperation::ColorSpillOperation()
   addInputSocket(COM_DT_VALUE);
   addOutputSocket(COM_DT_COLOR);
 
-  this->m_inputImageReader = NULL;
+  this->m_inputImageReader = nullptr;
-  this->m_inputFacReader = NULL;
+  this->m_inputFacReader = nullptr;
   this->m_spillChannel = 1;  // GREEN
   this->m_spillMethod = 0;
 }
@@ -77,8 +77,8 @@ void ColorSpillOperation::initExecution()
 
 void ColorSpillOperation::deinitExecution()
 {
-  this->m_inputImageReader = NULL;
+  this->m_inputImageReader = nullptr;
-  this->m_inputFacReader = NULL;
+  this->m_inputFacReader = nullptr;
 }
 
 void ColorSpillOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_CompositorOperation.cpp

@@ -38,19 +38,19 @@ CompositorOperation::CompositorOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_VALUE);
 
-  this->setRenderData(NULL);
+  this->setRenderData(nullptr);
-  this->m_outputBuffer = NULL;
+  this->m_outputBuffer = nullptr;
-  this->m_depthBuffer = NULL;
+  this->m_depthBuffer = nullptr;
-  this->m_imageInput = NULL;
+  this->m_imageInput = nullptr;
-  this->m_alphaInput = NULL;
+  this->m_alphaInput = nullptr;
-  this->m_depthInput = NULL;
+  this->m_depthInput = nullptr;
 
   this->m_useAlphaInput = false;
   this->m_active = false;
 
-  this->m_scene = NULL;
+  this->m_scene = nullptr;
   this->m_sceneName[0] = '\0';
-  this->m_viewName = NULL;
+  this->m_viewName = nullptr;
 }
 
 void CompositorOperation::initExecution()
@@ -67,7 +67,7 @@ void CompositorOperation::initExecution()
     this->m_outputBuffer = (float *)MEM_callocN(
         sizeof(float[4]) * this->getWidth() * this->getHeight(), "CompositorOperation");
   }
-  if (this->m_depthInput != NULL) {
+  if (this->m_depthInput != nullptr) {
     this->m_depthBuffer = (float *)MEM_callocN(
         sizeof(float) * this->getWidth() * this->getHeight(), "CompositorOperation");
   }
@@ -86,11 +86,11 @@ void CompositorOperation::deinitExecution()
     if (rr) {
       RenderView *rv = RE_RenderViewGetByName(rr, this->m_viewName);
 
-      if (rv->rectf != NULL) {
+      if (rv->rectf != nullptr) {
         MEM_freeN(rv->rectf);
       }
       rv->rectf = this->m_outputBuffer;
-      if (rv->rectz != NULL) {
+      if (rv->rectz != nullptr) {
         MEM_freeN(rv->rectz);
       }
       rv->rectz = this->m_depthBuffer;
@@ -107,13 +107,13 @@ void CompositorOperation::deinitExecution()
 
     if (re) {
       RE_ReleaseResult(re);
-      re = NULL;
+      re = nullptr;
     }
 
     BLI_thread_lock(LOCK_DRAW_IMAGE);
     BKE_image_signal(G.main,
                      BKE_image_ensure_viewer(G.main, IMA_TYPE_R_RESULT, "Render Result"),
-                     NULL,
+                     nullptr,
                      IMA_SIGNAL_FREE);
     BLI_thread_unlock(LOCK_DRAW_IMAGE);
   }
@@ -126,11 +126,11 @@ void CompositorOperation::deinitExecution()
     }
   }
 
-  this->m_outputBuffer = NULL;
+  this->m_outputBuffer = nullptr;
-  this->m_depthBuffer = NULL;
+  this->m_depthBuffer = nullptr;
-  this->m_imageInput = NULL;
+  this->m_imageInput = nullptr;
-  this->m_alphaInput = NULL;
+  this->m_alphaInput = nullptr;
-  this->m_depthInput = NULL;
+  this->m_depthInput = nullptr;
 }
 
 void CompositorOperation::executeRegion(rcti *rect, unsigned int /*tileNumber*/)

source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp

@@ -24,7 +24,7 @@ ConvertColorProfileOperation::ConvertColorProfileOperation()
 {
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
   this->m_predivided = false;
 }
 
@@ -46,5 +46,5 @@ void ConvertColorProfileOperation::executePixelSampled(float output[4],
 
 void ConvertColorProfileOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }

source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp

@@ -25,11 +25,11 @@ ConvertDepthToRadiusOperation::ConvertDepthToRadiusOperation()
 {
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
   this->m_fStop = 128.0f;
-  this->m_cameraObject = NULL;
+  this->m_cameraObject = nullptr;
   this->m_maxRadius = 32.0f;
-  this->m_blurPostOperation = NULL;
+  this->m_blurPostOperation = nullptr;
 }
 
 float ConvertDepthToRadiusOperation::determineFocalDistance()
@@ -46,7 +46,7 @@ float ConvertDepthToRadiusOperation::determineFocalDistance()
 void ConvertDepthToRadiusOperation::initExecution()
 {
   float cam_sensor = DEFAULT_SENSOR_WIDTH;
-  Camera *camera = NULL;
+  Camera *camera = nullptr;
 
   if (this->m_cameraObject && this->m_cameraObject->type == OB_CAMERA) {
     camera = (Camera *)this->m_cameraObject->data;
@@ -111,5 +111,5 @@ void ConvertDepthToRadiusOperation::executePixelSampled(float output[4],
 
 void ConvertDepthToRadiusOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }

source/blender/compositor/operations/COM_ConvertOperation.cpp

@@ -22,7 +22,7 @@
 
 ConvertBaseOperation::ConvertBaseOperation()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 
 void ConvertBaseOperation::initExecution()
@@ -32,7 +32,7 @@ void ConvertBaseOperation::initExecution()
 
 void ConvertBaseOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 
 /* ******** Value to Color ******** */
@@ -401,7 +401,7 @@ SeparateChannelOperation::SeparateChannelOperation()
 {
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 void SeparateChannelOperation::initExecution()
 {
@@ -410,7 +410,7 @@ void SeparateChannelOperation::initExecution()
 
 void SeparateChannelOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 
 void SeparateChannelOperation::executePixelSampled(float output[4],
@@ -433,10 +433,10 @@ CombineChannelsOperation::CombineChannelsOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
   this->setResolutionInputSocketIndex(0);
-  this->m_inputChannel1Operation = NULL;
+  this->m_inputChannel1Operation = nullptr;
-  this->m_inputChannel2Operation = NULL;
+  this->m_inputChannel2Operation = nullptr;
-  this->m_inputChannel3Operation = NULL;
+  this->m_inputChannel3Operation = nullptr;
-  this->m_inputChannel4Operation = NULL;
+  this->m_inputChannel4Operation = nullptr;
 }
 
 void CombineChannelsOperation::initExecution()
@@ -449,10 +449,10 @@ void CombineChannelsOperation::initExecution()
 
 void CombineChannelsOperation::deinitExecution()
 {
-  this->m_inputChannel1Operation = NULL;
+  this->m_inputChannel1Operation = nullptr;
-  this->m_inputChannel2Operation = NULL;
+  this->m_inputChannel2Operation = nullptr;
-  this->m_inputChannel3Operation = NULL;
+  this->m_inputChannel3Operation = nullptr;
-  this->m_inputChannel4Operation = NULL;
+  this->m_inputChannel4Operation = nullptr;
 }
 
 void CombineChannelsOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp

@@ -42,42 +42,42 @@ void ConvolutionEdgeFilterOperation::executePixel(float output[4], int x, int y,
   CLAMP(y3, 0, getHeight() - 1);
 
   float value[4];
-  this->m_inputValueOperation->read(value, x2, y2, NULL);
+  this->m_inputValueOperation->read(value, x2, y2, nullptr);
   float mval = 1.0f - value[0];
 
-  this->m_inputOperation->read(in1, x1, y1, NULL);
+  this->m_inputOperation->read(in1, x1, y1, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[0]);
   madd_v3_v3fl(res2, in1, this->m_filter[0]);
 
-  this->m_inputOperation->read(in1, x2, y1, NULL);
+  this->m_inputOperation->read(in1, x2, y1, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[1]);
   madd_v3_v3fl(res2, in1, this->m_filter[3]);
 
-  this->m_inputOperation->read(in1, x3, y1, NULL);
+  this->m_inputOperation->read(in1, x3, y1, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[2]);
   madd_v3_v3fl(res2, in1, this->m_filter[6]);
 
-  this->m_inputOperation->read(in1, x1, y2, NULL);
+  this->m_inputOperation->read(in1, x1, y2, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[3]);
   madd_v3_v3fl(res2, in1, this->m_filter[1]);
 
-  this->m_inputOperation->read(in2, x2, y2, NULL);
+  this->m_inputOperation->read(in2, x2, y2, nullptr);
   madd_v3_v3fl(res1, in2, this->m_filter[4]);
   madd_v3_v3fl(res2, in2, this->m_filter[4]);
 
-  this->m_inputOperation->read(in1, x3, y2, NULL);
+  this->m_inputOperation->read(in1, x3, y2, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[5]);
   madd_v3_v3fl(res2, in1, this->m_filter[7]);
 
-  this->m_inputOperation->read(in1, x1, y3, NULL);
+  this->m_inputOperation->read(in1, x1, y3, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[6]);
   madd_v3_v3fl(res2, in1, this->m_filter[2]);
 
-  this->m_inputOperation->read(in1, x2, y3, NULL);
+  this->m_inputOperation->read(in1, x2, y3, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[7]);
   madd_v3_v3fl(res2, in1, this->m_filter[5]);
 
-  this->m_inputOperation->read(in1, x3, y3, NULL);
+  this->m_inputOperation->read(in1, x3, y3, nullptr);
   madd_v3_v3fl(res1, in1, this->m_filter[8]);
   madd_v3_v3fl(res2, in1, this->m_filter[8]);
 

source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp

@@ -28,7 +28,7 @@ ConvolutionFilterOperation::ConvolutionFilterOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
   this->setResolutionInputSocketIndex(0);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
   this->setComplex(true);
 }
 void ConvolutionFilterOperation::initExecution()
@@ -55,8 +55,8 @@ void ConvolutionFilterOperation::set3x3Filter(
 
 void ConvolutionFilterOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
-  this->m_inputValueOperation = NULL;
+  this->m_inputValueOperation = nullptr;
 }
 
 void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, void * /*data*/)
@@ -76,27 +76,27 @@ void ConvolutionFilterOperation::executePixel(float output[4], int x, int y, voi
   CLAMP(y2, 0, getHeight() - 1);
   CLAMP(y3, 0, getHeight() - 1);
   float value[4];
-  this->m_inputValueOperation->read(value, x2, y2, NULL);
+  this->m_inputValueOperation->read(value, x2, y2, nullptr);
   const float mval = 1.0f - value[0];
 
   zero_v4(output);
-  this->m_inputOperation->read(in1, x1, y1, NULL);
+  this->m_inputOperation->read(in1, x1, y1, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[0]);
-  this->m_inputOperation->read(in1, x2, y1, NULL);
+  this->m_inputOperation->read(in1, x2, y1, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[1]);
-  this->m_inputOperation->read(in1, x3, y1, NULL);
+  this->m_inputOperation->read(in1, x3, y1, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[2]);
-  this->m_inputOperation->read(in1, x1, y2, NULL);
+  this->m_inputOperation->read(in1, x1, y2, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[3]);
-  this->m_inputOperation->read(in2, x2, y2, NULL);
+  this->m_inputOperation->read(in2, x2, y2, nullptr);
   madd_v4_v4fl(output, in2, this->m_filter[4]);
-  this->m_inputOperation->read(in1, x3, y2, NULL);
+  this->m_inputOperation->read(in1, x3, y2, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[5]);
-  this->m_inputOperation->read(in1, x1, y3, NULL);
+  this->m_inputOperation->read(in1, x1, y3, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[6]);
-  this->m_inputOperation->read(in1, x2, y3, NULL);
+  this->m_inputOperation->read(in1, x2, y3, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[7]);
-  this->m_inputOperation->read(in1, x3, y3, NULL);
+  this->m_inputOperation->read(in1, x3, y3, nullptr);
   madd_v4_v4fl(output, in1, this->m_filter[8]);
 
   output[0] = output[0] * value[0] + in2[0] * mval;

source/blender/compositor/operations/COM_CropOperation.cpp

@@ -23,8 +23,8 @@ CropBaseOperation::CropBaseOperation()
 {
   this->addInputSocket(COM_DT_COLOR, COM_SC_NO_RESIZE);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
-  this->m_settings = NULL;
+  this->m_settings = nullptr;
 }
 
 void CropBaseOperation::updateArea()
@@ -75,7 +75,7 @@ void CropBaseOperation::initExecution()
 
 void CropBaseOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 
 CropOperation::CropOperation() : CropBaseOperation()

source/blender/compositor/operations/COM_CurveBaseOperation.cpp

@@ -22,14 +22,14 @@
 
 CurveBaseOperation::CurveBaseOperation()
 {
-  this->m_curveMapping = NULL;
+  this->m_curveMapping = nullptr;
 }
 
 CurveBaseOperation::~CurveBaseOperation()
 {
   if (this->m_curveMapping) {
     BKE_curvemapping_free(this->m_curveMapping);
-    this->m_curveMapping = NULL;
+    this->m_curveMapping = nullptr;
   }
 }
 
@@ -41,7 +41,7 @@ void CurveBaseOperation::deinitExecution()
 {
   if (this->m_curveMapping) {
     BKE_curvemapping_free(this->m_curveMapping);
-    this->m_curveMapping = NULL;
+    this->m_curveMapping = nullptr;
   }
 }
 

source/blender/compositor/operations/COM_DenoiseOperation.cpp

@@ -32,7 +32,7 @@ DenoiseOperation::DenoiseOperation()
   this->addInputSocket(COM_DT_VECTOR);
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
-  this->m_settings = NULL;
+  this->m_settings = nullptr;
 }
 void DenoiseOperation::initExecution()
 {
@@ -44,9 +44,9 @@ void DenoiseOperation::initExecution()
 
 void DenoiseOperation::deinitExecution()
 {
-  this->m_inputProgramColor = NULL;
+  this->m_inputProgramColor = nullptr;
-  this->m_inputProgramNormal = NULL;
+  this->m_inputProgramNormal = nullptr;
-  this->m_inputProgramAlbedo = NULL;
+  this->m_inputProgramAlbedo = nullptr;
   SingleThreadedOperation::deinitExecution();
 }
 

source/blender/compositor/operations/COM_DespeckleOperation.cpp

@@ -28,7 +28,7 @@ DespeckleOperation::DespeckleOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
   this->setResolutionInputSocketIndex(0);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
   this->setComplex(true);
 }
 void DespeckleOperation::initExecution()
@@ -39,8 +39,8 @@ void DespeckleOperation::initExecution()
 
 void DespeckleOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
-  this->m_inputValueOperation = NULL;
+  this->m_inputValueOperation = nullptr;
 }
 
 BLI_INLINE int color_diff(const float a[3], const float b[3], const float threshold)
@@ -69,10 +69,10 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da
   CLAMP(y2, 0, getHeight() - 1);
   CLAMP(y3, 0, getHeight() - 1);
   float value[4];
-  this->m_inputValueOperation->read(value, x2, y2, NULL);
+  this->m_inputValueOperation->read(value, x2, y2, nullptr);
   // const float mval = 1.0f - value[0];
 
-  this->m_inputOperation->read(color_org, x2, y2, NULL);
+  this->m_inputOperation->read(color_org, x2, y2, nullptr);
 
 #define TOT_DIV_ONE 1.0f
 #define TOT_DIV_CNR (float)M_SQRT1_2
@@ -91,13 +91,13 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da
   zero_v4(color_mid);
   zero_v4(color_mid_ok);
 
-  this->m_inputOperation->read(in1, x1, y1, NULL);
+  this->m_inputOperation->read(in1, x1, y1, nullptr);
   COLOR_ADD(TOT_DIV_CNR)
-  this->m_inputOperation->read(in1, x2, y1, NULL);
+  this->m_inputOperation->read(in1, x2, y1, nullptr);
   COLOR_ADD(TOT_DIV_ONE)
-  this->m_inputOperation->read(in1, x3, y1, NULL);
+  this->m_inputOperation->read(in1, x3, y1, nullptr);
   COLOR_ADD(TOT_DIV_CNR)
-  this->m_inputOperation->read(in1, x1, y2, NULL);
+  this->m_inputOperation->read(in1, x1, y2, nullptr);
   COLOR_ADD(TOT_DIV_ONE)
 
 #if 0
@@ -105,13 +105,13 @@ void DespeckleOperation::executePixel(float output[4], int x, int y, void * /*da
   madd_v4_v4fl(color_mid, in2, this->m_filter[4]);
 #endif
 
-  this->m_inputOperation->read(in1, x3, y2, NULL);
+  this->m_inputOperation->read(in1, x3, y2, nullptr);
   COLOR_ADD(TOT_DIV_ONE)
-  this->m_inputOperation->read(in1, x1, y3, NULL);
+  this->m_inputOperation->read(in1, x1, y3, nullptr);
   COLOR_ADD(TOT_DIV_CNR)
-  this->m_inputOperation->read(in1, x2, y3, NULL);
+  this->m_inputOperation->read(in1, x2, y3, nullptr);
   COLOR_ADD(TOT_DIV_ONE)
-  this->m_inputOperation->read(in1, x3, y3, NULL);
+  this->m_inputOperation->read(in1, x3, y3, nullptr);
   COLOR_ADD(TOT_DIV_CNR)
 
   mul_v4_fl(color_mid, 1.0f / (4.0f + (4.0f * (float)M_SQRT1_2)));

source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp

@@ -25,8 +25,8 @@ DifferenceMatteOperation::DifferenceMatteOperation()
   addInputSocket(COM_DT_COLOR);
   addOutputSocket(COM_DT_VALUE);
 
-  this->m_inputImage1Program = NULL;
+  this->m_inputImage1Program = nullptr;
-  this->m_inputImage2Program = NULL;
+  this->m_inputImage2Program = nullptr;
 }
 
 void DifferenceMatteOperation::initExecution()
@@ -36,8 +36,8 @@ void DifferenceMatteOperation::initExecution()
 }
 void DifferenceMatteOperation::deinitExecution()
 {
-  this->m_inputImage1Program = NULL;
+  this->m_inputImage1Program = nullptr;
-  this->m_inputImage2Program = NULL;
+  this->m_inputImage2Program = nullptr;
 }
 
 void DifferenceMatteOperation::executePixelSampled(float output[4],

source/blender/compositor/operations/COM_DilateErodeOperation.cpp

@@ -28,7 +28,7 @@ DilateErodeThresholdOperation::DilateErodeThresholdOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
   this->setComplex(true);
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
   this->m_inset = 0.0f;
   this->m__switch = 0.5f;
   this->m_distance = 0.0f;
@@ -54,7 +54,7 @@ void DilateErodeThresholdOperation::initExecution()
 
 void *DilateErodeThresholdOperation::initializeTileData(rcti * /*rect*/)
 {
-  void *buffer = this->m_inputProgram->initializeTileData(NULL);
+  void *buffer = this->m_inputProgram->initializeTileData(nullptr);
   return buffer;
 }
 
@@ -142,7 +142,7 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y,
 
 void DilateErodeThresholdOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }
 
 bool DilateErodeThresholdOperation::determineDependingAreaOfInterest(
@@ -164,7 +164,7 @@ DilateDistanceOperation::DilateDistanceOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
   this->setComplex(true);
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
   this->m_distance = 0.0f;
   this->setOpenCL(true);
 }
@@ -179,7 +179,7 @@ void DilateDistanceOperation::initExecution()
 
 void *DilateDistanceOperation::initializeTileData(rcti * /*rect*/)
 {
-  void *buffer = this->m_inputProgram->initializeTileData(NULL);
+  void *buffer = this->m_inputProgram->initializeTileData(nullptr);
   return buffer;
 }
 
@@ -217,7 +217,7 @@ void DilateDistanceOperation::executePixel(float output[4], int x, int y, void *
 
 void DilateDistanceOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }
 
 bool DilateDistanceOperation::determineDependingAreaOfInterest(rcti *input,
@@ -241,7 +241,7 @@ void DilateDistanceOperation::executeOpenCL(OpenCLDevice *device,
                                             list<cl_mem> *clMemToCleanUp,
                                             list<cl_kernel> * /*clKernelsToCleanUp*/)
 {
-  cl_kernel dilateKernel = device->COM_clCreateKernel("dilateKernel", NULL);
+  cl_kernel dilateKernel = device->COM_clCreateKernel("dilateKernel", nullptr);
 
   cl_int distanceSquared = this->m_distance * this->m_distance;
   cl_int scope = this->m_scope;
@@ -301,7 +301,7 @@ void ErodeDistanceOperation::executeOpenCL(OpenCLDevice *device,
                                            list<cl_mem> *clMemToCleanUp,
                                            list<cl_kernel> * /*clKernelsToCleanUp*/)
 {
-  cl_kernel erodeKernel = device->COM_clCreateKernel("erodeKernel", NULL);
+  cl_kernel erodeKernel = device->COM_clCreateKernel("erodeKernel", nullptr);
 
   cl_int distanceSquared = this->m_distance * this->m_distance;
   cl_int scope = this->m_scope;
@@ -322,7 +322,7 @@ DilateStepOperation::DilateStepOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
   this->setComplex(true);
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }
 void DilateStepOperation::initExecution()
 {
@@ -351,7 +351,7 @@ static tile_info *create_cache(int xmin, int xmax, int ymin, int ymax)
 
 void *DilateStepOperation::initializeTileData(rcti *rect)
 {
-  MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL);
+  MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(nullptr);
   int x, y, i;
   int width = tile->getWidth();
   int height = tile->getHeight();
@@ -448,7 +448,7 @@ void DilateStepOperation::executePixel(float output[4], int x, int y, void *data
 
 void DilateStepOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }
 
 void DilateStepOperation::deinitializeTileData(rcti * /*rect*/, void *data)
@@ -480,7 +480,7 @@ ErodeStepOperation::ErodeStepOperation() : DilateStepOperation()
 
 void *ErodeStepOperation::initializeTileData(rcti *rect)
 {
-  MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL);
+  MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(nullptr);
   int x, y, i;
   int width = tile->getWidth();
   int height = tile->getHeight();

source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp

@@ -30,7 +30,7 @@ DirectionalBlurOperation::DirectionalBlurOperation()
   this->setComplex(true);
 
   this->setOpenCL(true);
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }
 
 void DirectionalBlurOperation::initExecution()
@@ -103,7 +103,7 @@ void DirectionalBlurOperation::executeOpenCL(OpenCLDevice *device,
                                              list<cl_mem> *clMemToCleanUp,
                                              list<cl_kernel> * /*clKernelsToCleanUp*/)
 {
-  cl_kernel directionalBlurKernel = device->COM_clCreateKernel("directionalBlurKernel", NULL);
+  cl_kernel directionalBlurKernel = device->COM_clCreateKernel("directionalBlurKernel", nullptr);
 
   cl_int iterations = pow(2.0f, this->m_data->iter);
   cl_float2 ltxy = {{this->m_tx, this->m_ty}};
@@ -128,7 +128,7 @@ void DirectionalBlurOperation::executeOpenCL(OpenCLDevice *device,
 
 void DirectionalBlurOperation::deinitExecution()
 {
-  this->m_inputProgram = NULL;
+  this->m_inputProgram = nullptr;
 }
 
 bool DirectionalBlurOperation::determineDependingAreaOfInterest(rcti * /*input*/,

source/blender/compositor/operations/COM_DisplaceOperation.cpp

@@ -29,10 +29,10 @@ DisplaceOperation::DisplaceOperation()
   this->addOutputSocket(COM_DT_COLOR);
   this->setComplex(true);
 
-  this->m_inputColorProgram = NULL;
+  this->m_inputColorProgram = nullptr;
-  this->m_inputVectorProgram = NULL;
+  this->m_inputVectorProgram = nullptr;
-  this->m_inputScaleXProgram = NULL;
+  this->m_inputScaleXProgram = nullptr;
-  this->m_inputScaleYProgram = NULL;
+  this->m_inputScaleYProgram = nullptr;
 }
 
 void DisplaceOperation::initExecution()
@@ -143,10 +143,10 @@ void DisplaceOperation::pixelTransform(const float xy[2], float r_uv[2], float r
 
 void DisplaceOperation::deinitExecution()
 {
-  this->m_inputColorProgram = NULL;
+  this->m_inputColorProgram = nullptr;
-  this->m_inputVectorProgram = NULL;
+  this->m_inputVectorProgram = nullptr;
-  this->m_inputScaleXProgram = NULL;
+  this->m_inputScaleXProgram = nullptr;
-  this->m_inputScaleYProgram = NULL;
+  this->m_inputScaleYProgram = nullptr;
 }
 
 bool DisplaceOperation::determineDependingAreaOfInterest(rcti *input,
@@ -155,7 +155,7 @@ bool DisplaceOperation::determineDependingAreaOfInterest(rcti *input,
 {
   rcti colorInput;
   rcti vectorInput;
-  NodeOperation *operation = NULL;
+  NodeOperation *operation = nullptr;
 
   /* the vector buffer only needs a 2x2 buffer. The image needs whole buffer */
   /* image */

source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp

@@ -28,10 +28,10 @@ DisplaceSimpleOperation::DisplaceSimpleOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_COLOR);
 
-  this->m_inputColorProgram = NULL;
+  this->m_inputColorProgram = nullptr;
-  this->m_inputVectorProgram = NULL;
+  this->m_inputVectorProgram = nullptr;
-  this->m_inputScaleXProgram = NULL;
+  this->m_inputScaleXProgram = nullptr;
-  this->m_inputScaleYProgram = NULL;
+  this->m_inputScaleYProgram = nullptr;
 }
 
 void DisplaceSimpleOperation::initExecution()
@@ -86,10 +86,10 @@ void DisplaceSimpleOperation::executePixelSampled(float output[4],
 
 void DisplaceSimpleOperation::deinitExecution()
 {
-  this->m_inputColorProgram = NULL;
+  this->m_inputColorProgram = nullptr;
-  this->m_inputVectorProgram = NULL;
+  this->m_inputVectorProgram = nullptr;
-  this->m_inputScaleXProgram = NULL;
+  this->m_inputScaleXProgram = nullptr;
-  this->m_inputScaleYProgram = NULL;
+  this->m_inputScaleYProgram = nullptr;
 }
 
 bool DisplaceSimpleOperation::determineDependingAreaOfInterest(rcti *input,
@@ -97,7 +97,7 @@ bool DisplaceSimpleOperation::determineDependingAreaOfInterest(rcti *input,
                                                                rcti *output)
 {
   rcti colorInput;
-  NodeOperation *operation = NULL;
+  NodeOperation *operation = nullptr;
 
   /* the vector buffer only needs a 2x2 buffer. The image needs whole buffer */
   /* image */

source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cpp

@@ -25,8 +25,8 @@ DistanceRGBMatteOperation::DistanceRGBMatteOperation()
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_VALUE);
 
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputKeyProgram = NULL;
+  this->m_inputKeyProgram = nullptr;
 }
 
 void DistanceRGBMatteOperation::initExecution()
@@ -37,8 +37,8 @@ void DistanceRGBMatteOperation::initExecution()
 
 void DistanceRGBMatteOperation::deinitExecution()
 {
-  this->m_inputImageProgram = NULL;
+  this->m_inputImageProgram = nullptr;
-  this->m_inputKeyProgram = NULL;
+  this->m_inputKeyProgram = nullptr;
 }
 
 float DistanceRGBMatteOperation::calculateDistance(float key[4], float image[4])

source/blender/compositor/operations/COM_DotproductOperation.cpp

@@ -24,8 +24,8 @@ DotproductOperation::DotproductOperation()
   this->addInputSocket(COM_DT_VECTOR);
   this->addOutputSocket(COM_DT_VALUE);
   this->setResolutionInputSocketIndex(0);
-  this->m_input1Operation = NULL;
+  this->m_input1Operation = nullptr;
-  this->m_input2Operation = NULL;
+  this->m_input2Operation = nullptr;
 }
 void DotproductOperation::initExecution()
 {
@@ -35,8 +35,8 @@ void DotproductOperation::initExecution()
 
 void DotproductOperation::deinitExecution()
 {
-  this->m_input1Operation = NULL;
+  this->m_input1Operation = nullptr;
-  this->m_input2Operation = NULL;
+  this->m_input2Operation = nullptr;
 }
 
 /** \todo: current implementation is the inverse of a dotproduct. not 'logically' correct

source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp

@@ -1311,8 +1311,8 @@ DoubleEdgeMaskOperation::DoubleEdgeMaskOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_inputInnerMask = NULL;
+  this->m_inputInnerMask = nullptr;
-  this->m_inputOuterMask = NULL;
+  this->m_inputOuterMask = nullptr;
   this->m_adjecentOnly = false;
   this->m_keepInside = false;
   this->setComplex(true);
@@ -1322,7 +1322,7 @@ bool DoubleEdgeMaskOperation::determineDependingAreaOfInterest(rcti * /*input*/,
                                                                ReadBufferOperation *readOperation,
                                                                rcti *output)
 {
-  if (this->m_cachedInstance == NULL) {
+  if (this->m_cachedInstance == nullptr) {
     rcti newInput;
     newInput.xmax = this->getWidth();
     newInput.xmin = 0;
@@ -1339,7 +1339,7 @@ void DoubleEdgeMaskOperation::initExecution()
   this->m_inputInnerMask = this->getInputSocketReader(0);
   this->m_inputOuterMask = this->getInputSocketReader(1);
   initMutex();
-  this->m_cachedInstance = NULL;
+  this->m_cachedInstance = nullptr;
 }
 
 void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect)
@@ -1349,7 +1349,7 @@ void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect)
   }
 
   lockMutex();
-  if (this->m_cachedInstance == NULL) {
+  if (this->m_cachedInstance == nullptr) {
     MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect);
     MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect);
     float *data = (float *)MEM_mallocN(sizeof(float) * this->getWidth() * this->getHeight(),
@@ -1371,11 +1371,11 @@ void DoubleEdgeMaskOperation::executePixel(float output[4], int x, int y, void *
 
 void DoubleEdgeMaskOperation::deinitExecution()
 {
-  this->m_inputInnerMask = NULL;
+  this->m_inputInnerMask = nullptr;
-  this->m_inputOuterMask = NULL;
+  this->m_inputOuterMask = nullptr;
   deinitMutex();
   if (this->m_cachedInstance) {
     MEM_freeN(this->m_cachedInstance);
-    this->m_cachedInstance = NULL;
+    this->m_cachedInstance = nullptr;
   }
 }

source/blender/compositor/operations/COM_EllipseMaskOperation.cpp

@@ -25,8 +25,8 @@ EllipseMaskOperation::EllipseMaskOperation()
   this->addInputSocket(COM_DT_VALUE);
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_inputMask = NULL;
+  this->m_inputMask = nullptr;
-  this->m_inputValue = NULL;
+  this->m_inputValue = nullptr;
   this->m_cosine = 0.0f;
   this->m_sine = 0.0f;
 }
@@ -114,6 +114,6 @@ void EllipseMaskOperation::executePixelSampled(float output[4],
 
 void EllipseMaskOperation::deinitExecution()
 {
-  this->m_inputMask = NULL;
+  this->m_inputMask = nullptr;
-  this->m_inputValue = NULL;
+  this->m_inputValue = nullptr;
 }

source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp

@@ -24,7 +24,7 @@
 
 FastGaussianBlurOperation::FastGaussianBlurOperation() : BlurBaseOperation(COM_DT_COLOR)
 {
-  this->m_iirgaus = NULL;
+  this->m_iirgaus = nullptr;
 }
 
 void FastGaussianBlurOperation::executePixel(float output[4], int x, int y, void *data)
@@ -70,7 +70,7 @@ void FastGaussianBlurOperation::deinitExecution()
 {
   if (this->m_iirgaus) {
     delete this->m_iirgaus;
-    this->m_iirgaus = NULL;
+    this->m_iirgaus = nullptr;
   }
   BlurBaseOperation::deinitMutex();
 }
@@ -260,8 +260,8 @@ FastGaussianBlurValueOperation::FastGaussianBlurValueOperation()
 {
   this->addInputSocket(COM_DT_VALUE);
   this->addOutputSocket(COM_DT_VALUE);
-  this->m_iirgaus = NULL;
+  this->m_iirgaus = nullptr;
-  this->m_inputprogram = NULL;
+  this->m_inputprogram = nullptr;
   this->m_sigma = 1.0f;
   this->m_overlay = 0;
   setComplex(true);
@@ -300,7 +300,7 @@ void FastGaussianBlurValueOperation::deinitExecution()
 {
   if (this->m_iirgaus) {
     delete this->m_iirgaus;
-    this->m_iirgaus = NULL;
+    this->m_iirgaus = nullptr;
   }
   deinitMutex();
 }

source/blender/compositor/operations/COM_FlipOperation.cpp

@@ -23,7 +23,7 @@ FlipOperation::FlipOperation()
   this->addInputSocket(COM_DT_COLOR);
   this->addOutputSocket(COM_DT_COLOR);
   this->setResolutionInputSocketIndex(0);
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
   this->m_flipX = true;
   this->m_flipY = false;
 }
@@ -34,7 +34,7 @@ void FlipOperation::initExecution()
 
 void FlipOperation::deinitExecution()
 {
-  this->m_inputOperation = NULL;
+  this->m_inputOperation = nullptr;
 }
 
 void FlipOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)