Nodes: Convert several shader nodes to c++

Also add file namespace

This is needed to use new node APIs

Differential Revision: https://developer.blender.org/D13690

25 files changed, 282 insertions, 130 deletions

diff --git a/source/blender/nodes/shader/CMakeLists.txt b/source/blender/nodes/shader/CMakeLists.txt
index 0ba8c52e453..3e514b8635c 100644
--- a/source/blender/nodes/shader/CMakeLists.txt
+++ b/source/blender/nodes/shader/CMakeLists.txt
@@ -41,12 +41,12 @@ set(INC
 
 set(SRC
   nodes/node_shader_add_shader.cc
-  nodes/node_shader_ambient_occlusion.c
-  nodes/node_shader_attribute.c
-  nodes/node_shader_background.c
-  nodes/node_shader_bevel.c
-  nodes/node_shader_blackbody.c
-  nodes/node_shader_brightness.c
+  nodes/node_shader_ambient_occlusion.cc
+  nodes/node_shader_attribute.cc
+  nodes/node_shader_background.cc
+  nodes/node_shader_bevel.cc
+  nodes/node_shader_blackbody.cc
+  nodes/node_shader_brightness.cc
   nodes/node_shader_bsdf_anisotropic.cc
   nodes/node_shader_bsdf_diffuse.cc
   nodes/node_shader_bsdf_glass.cc
@@ -60,17 +60,17 @@ set(SRC
   nodes/node_shader_bsdf_transparent.cc
   nodes/node_shader_bsdf_velvet.cc
   nodes/node_shader_bump.cc
-  nodes/node_shader_camera.c
+  nodes/node_shader_camera.cc
   nodes/node_shader_clamp.cc
   nodes/node_shader_color_ramp.cc
   nodes/node_shader_common.c
   nodes/node_shader_curves.cc
-  nodes/node_shader_displacement.c
-  nodes/node_shader_eevee_specular.c
-  nodes/node_shader_emission.c
-  nodes/node_shader_fresnel.c
-  nodes/node_shader_gamma.c
-  nodes/node_shader_geometry.c
+  nodes/node_shader_displacement.cc
+  nodes/node_shader_eevee_specular.cc
+  nodes/node_shader_emission.cc
+  nodes/node_shader_fresnel.cc
+  nodes/node_shader_gamma.cc
+  nodes/node_shader_geometry.cc
   nodes/node_shader_hair_info.c
   nodes/node_shader_holdout.c
   nodes/node_shader_hueSatVal.c
@@ -100,12 +100,12 @@ set(SRC
   nodes/node_shader_sepcomb_rgb.cc
   nodes/node_shader_sepcomb_xyz.cc
   nodes/node_shader_shader_to_rgb.cc
-  nodes/node_shader_squeeze.c
+  nodes/node_shader_squeeze.cc
   nodes/node_shader_subsurface_scattering.cc
-  nodes/node_shader_tangent.c
+  nodes/node_shader_tangent.cc
   nodes/node_shader_tex_brick.cc
   nodes/node_shader_tex_checker.cc
-  nodes/node_shader_tex_coord.c
+  nodes/node_shader_tex_coord.cc
   nodes/node_shader_tex_environment.cc
   nodes/node_shader_tex_gradient.cc
   nodes/node_shader_tex_image.cc
@@ -117,20 +117,20 @@ set(SRC
   nodes/node_shader_tex_voronoi.cc
   nodes/node_shader_tex_wave.cc
   nodes/node_shader_tex_white_noise.cc
-  nodes/node_shader_uv_along_stroke.c
-  nodes/node_shader_uvmap.c
+  nodes/node_shader_uv_along_stroke.cc
+  nodes/node_shader_uvmap.cc
   nodes/node_shader_value.cc
-  nodes/node_shader_vector_displacement.c
+  nodes/node_shader_vector_displacement.cc
   nodes/node_shader_vector_math.cc
   nodes/node_shader_vector_rotate.cc
-  nodes/node_shader_vector_transform.c
-  nodes/node_shader_vertex_color.c
+  nodes/node_shader_vector_transform.cc
+  nodes/node_shader_vertex_color.cc
   nodes/node_shader_volume_absorption.cc
-  nodes/node_shader_volume_info.c
+  nodes/node_shader_volume_info.cc
   nodes/node_shader_volume_principled.cc
   nodes/node_shader_volume_scatter.cc
-  nodes/node_shader_wavelength.c
-  nodes/node_shader_wireframe.c
+  nodes/node_shader_wavelength.cc
+  nodes/node_shader_wireframe.cc
 
   node_shader_tree.c
   node_shader_util.cc
diff --git a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc
index 2561d6cb398..b4ad3d56d25 100644
--- a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c
+++ b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_ambient_occlusion_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_ambient_occlusion_in[] = {
@@ -64,15 +66,20 @@ static void node_shader_init_ambient_occlusion(bNodeTree *UNUSED(ntree), bNode *
   node->custom2 = 0;
 }
 
+}  // namespace blender::nodes::node_shader_ambient_occlusion_cc
+
 /* node type definition */
-void register_node_type_sh_ambient_occlusion(void)
+void register_node_type_sh_ambient_occlusion()
 {
+  namespace file_ns = blender::nodes::node_shader_ambient_occlusion_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_AMBIENT_OCCLUSION, "Ambient Occlusion", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, sh_node_ambient_occlusion_in, sh_node_ambient_occlusion_out);
-  node_type_init(&ntype, node_shader_init_ambient_occlusion);
-  node_type_gpu(&ntype, node_shader_gpu_ambient_occlusion);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_ambient_occlusion_in, file_ns::sh_node_ambient_occlusion_out);
+  node_type_init(&ntype, file_ns::node_shader_init_ambient_occlusion);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_ambient_occlusion);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_attribute.c b/source/blender/nodes/shader/nodes/node_shader_attribute.cc
index 9b3122e38e0..f0965e3a476 100644
--- a/source/blender/nodes/shader/nodes/node_shader_attribute.c
+++ b/source/blender/nodes/shader/nodes/node_shader_attribute.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_attribute_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_attribute_out[] = {
@@ -31,7 +33,7 @@ static bNodeSocketTemplate sh_node_attribute_out[] = {
 
 static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderAttribute *attr = MEM_callocN(sizeof(NodeShaderAttribute), "NodeShaderAttribute");
+  NodeShaderAttribute *attr = MEM_cnew<NodeShaderAttribute>("NodeShaderAttribute");
   node->storage = attr;
 }
 
@@ -41,7 +43,7 @@ static int node_shader_gpu_attribute(GPUMaterial *mat,
                                      GPUNodeStack *in,
                                      GPUNodeStack *out)
 {
-  NodeShaderAttribute *attr = node->storage;
+  NodeShaderAttribute *attr = static_cast<NodeShaderAttribute *>(node->storage);
   bool is_varying = attr->type == SHD_ATTRIBUTE_GEOMETRY;
 
   if (GPU_material_is_volume_shader(mat) && is_varying) {
@@ -81,17 +83,21 @@ static int node_shader_gpu_attribute(GPUMaterial *mat,
   return 1;
 }
 
+}  // namespace blender::nodes::node_shader_attribute_cc
+
 /* node type definition */
-void register_node_type_sh_attribute(void)
+void register_node_type_sh_attribute()
 {
+  namespace file_ns = blender::nodes::node_shader_attribute_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_ATTRIBUTE, "Attribute", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_attribute_out);
-  node_type_init(&ntype, node_shader_init_attribute);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_attribute_out);
+  node_type_init(&ntype, file_ns::node_shader_init_attribute);
   node_type_storage(
       &ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, node_shader_gpu_attribute);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_attribute);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_background.c b/source/blender/nodes/shader/nodes/node_shader_background.cc
index 5fc9232ba85..b6ac0e06472 100644
--- a/source/blender/nodes/shader/nodes/node_shader_background.c
+++ b/source/blender/nodes/shader/nodes/node_shader_background.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_background_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_background_in[] = {
@@ -41,14 +43,19 @@ static int node_shader_gpu_background(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_background", in, out);
 }
 
+}  // namespace blender::nodes::node_shader_background_cc
+
 /* node type definition */
-void register_node_type_sh_background(void)
+void register_node_type_sh_background()
 {
+  namespace file_ns = blender::nodes::node_shader_background_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BACKGROUND, "Background", NODE_CLASS_SHADER, 0);
-  node_type_socket_templates(&ntype, sh_node_background_in, sh_node_background_out);
-  node_type_gpu(&ntype, node_shader_gpu_background);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_background_in, file_ns::sh_node_background_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_background);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bevel.c b/source/blender/nodes/shader/nodes/node_shader_bevel.cc
index 6988563a76c..5c97d66c345 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bevel.c
+++ b/source/blender/nodes/shader/nodes/node_shader_bevel.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_bevel_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_bevel_in[] = {
@@ -54,15 +56,19 @@ static int gpu_shader_bevel(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bevel", in, out);
 }
 
+}  // namespace blender::nodes::node_shader_bevel_cc
+
 /* node type definition */
-void register_node_type_sh_bevel(void)
+void register_node_type_sh_bevel()
 {
+  namespace file_ns = blender::nodes::node_shader_bevel_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BEVEL, "Bevel", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, sh_node_bevel_in, sh_node_bevel_out);
-  node_type_init(&ntype, node_shader_init_bevel);
-  node_type_gpu(&ntype, gpu_shader_bevel);
+  node_type_socket_templates(&ntype, file_ns::sh_node_bevel_in, file_ns::sh_node_bevel_out);
+  node_type_init(&ntype, file_ns::node_shader_init_bevel);
+  node_type_gpu(&ntype, file_ns::gpu_shader_bevel);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_blackbody.c b/source/blender/nodes/shader/nodes/node_shader_blackbody.cc
index 1d86531f7f0..e9d25c0c32f 100644
--- a/source/blender/nodes/shader/nodes/node_shader_blackbody.c
+++ b/source/blender/nodes/shader/nodes/node_shader_blackbody.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_blackbody_cc {
+
 /* **************** Blackbody ******************** */
 static bNodeSocketTemplate sh_node_blackbody_in[] = {
     {SOCK_FLOAT, N_("Temperature"), 1500.0f, 0.0f, 0.0f, 0.0f, 800.0f, 12000.0f},
@@ -37,7 +39,7 @@ static int node_shader_gpu_blackbody(GPUMaterial *mat,
                                      GPUNodeStack *out)
 {
   const int size = CM_TABLE + 1;
-  float *data = MEM_mallocN(sizeof(float) * size * 4, "blackbody texture");
+  float *data = static_cast<float *>(MEM_mallocN(sizeof(float) * size * 4, "blackbody texture"));
 
   blackbody_temperature_to_rgb_table(data, size, 965.0f, 12000.0f);
 
@@ -47,15 +49,20 @@ static int node_shader_gpu_blackbody(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_blackbody", in, out, ramp_texture, GPU_constant(&layer));
 }
 
+}  // namespace blender::nodes::node_shader_blackbody_cc
+
 /* node type definition */
-void register_node_type_sh_blackbody(void)
+void register_node_type_sh_blackbody()
 {
+  namespace file_ns = blender::nodes::node_shader_blackbody_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BLACKBODY, "Blackbody", NODE_CLASS_CONVERTER, 0);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_socket_templates(&ntype, sh_node_blackbody_in, sh_node_blackbody_out);
-  node_type_gpu(&ntype, node_shader_gpu_blackbody);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_blackbody_in, file_ns::sh_node_blackbody_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_blackbody);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_brightness.c b/source/blender/nodes/shader/nodes/node_shader_brightness.cc
index 15383d85d26..1028d9cafd9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_brightness.c
+++ b/source/blender/nodes/shader/nodes/node_shader_brightness.cc
@@ -19,6 +19,8 @@
 
 #include "node_shader_util.h"
 
+namespace blender::nodes::node_shader_brightness_cc {
+
 /* **************** Bright and contrast  ******************** */
 
 static bNodeSocketTemplate sh_node_brightcontrast_in[] = {
@@ -42,13 +44,18 @@ static int gpu_shader_brightcontrast(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "brightness_contrast", in, out);
 }
 
-void register_node_type_sh_brightcontrast(void)
+}  // namespace blender::nodes::node_shader_brightness_cc
+
+void register_node_type_sh_brightcontrast()
 {
+  namespace file_ns = blender::nodes::node_shader_brightness_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, 0);
-  node_type_socket_templates(&ntype, sh_node_brightcontrast_in, sh_node_brightcontrast_out);
-  node_type_gpu(&ntype, gpu_shader_brightcontrast);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_brightcontrast_in, file_ns::sh_node_brightcontrast_out);
+  node_type_gpu(&ntype, file_ns::gpu_shader_brightcontrast);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_camera.c b/source/blender/nodes/shader/nodes/node_shader_camera.cc
index 2321bdf587d..8154b773cfd 100644
--- a/source/blender/nodes/shader/nodes/node_shader_camera.c
+++ b/source/blender/nodes/shader/nodes/node_shader_camera.cc
@@ -23,6 +23,8 @@
 
 #include "node_shader_util.h"
 
+namespace blender::nodes::node_shader_camera_cc {
+
 /* **************** CAMERA INFO  ******************** */
 static bNodeSocketTemplate sh_node_camera_out[] = {
     {SOCK_VECTOR, N_("View Vector")},
@@ -44,13 +46,17 @@ static int gpu_shader_camera(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "camera", in, out, viewvec);
 }
 
-void register_node_type_sh_camera(void)
+}  // namespace blender::nodes::node_shader_camera_cc
+
+void register_node_type_sh_camera()
 {
+  namespace file_ns = blender::nodes::node_shader_camera_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_CAMERA, "Camera Data", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_camera_out);
-  node_type_gpu(&ntype, gpu_shader_camera);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_camera_out);
+  node_type_gpu(&ntype, file_ns::gpu_shader_camera);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_displacement.c b/source/blender/nodes/shader/nodes/node_shader_displacement.cc
index 569ec8da83e..7c3b5f9f7a9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_displacement.c
+++ b/source/blender/nodes/shader/nodes/node_shader_displacement.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_displacement_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_displacement_in[] = {
@@ -68,15 +70,20 @@ static int gpu_shader_displacement(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_displacement_world", in, out);
 }
 
+}  // namespace blender::nodes::node_shader_displacement_cc
+
 /* node type definition */
-void register_node_type_sh_displacement(void)
+void register_node_type_sh_displacement()
 {
+  namespace file_ns = blender::nodes::node_shader_displacement_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_DISPLACEMENT, "Displacement", NODE_CLASS_OP_VECTOR, 0);
-  node_type_socket_templates(&ntype, sh_node_displacement_in, sh_node_displacement_out);
-  node_type_init(&ntype, node_shader_init_displacement);
-  node_type_gpu(&ntype, gpu_shader_displacement);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_displacement_in, file_ns::sh_node_displacement_out);
+  node_type_init(&ntype, file_ns::node_shader_init_displacement);
+  node_type_gpu(&ntype, file_ns::gpu_shader_displacement);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_eevee_specular.c b/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc
index 94de78bbf0d..0b24caa0e83 100644
--- a/source/blender/nodes/shader/nodes/node_shader_eevee_specular.c
+++ b/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_eevee_specular_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_eevee_specular_in[] = {
@@ -81,19 +83,24 @@ static int node_shader_gpu_eevee_specular(GPUMaterial *mat,
     GPU_link(mat, "set_value", GPU_constant(&one), &in[9].link);
   }
 
-  GPU_material_flag_set(mat, GPU_MATFLAG_DIFFUSE | GPU_MATFLAG_GLOSSY);
+  GPU_material_flag_set(mat, static_cast<eGPUMatFlag>(GPU_MATFLAG_DIFFUSE | GPU_MATFLAG_GLOSSY));
 
   return GPU_stack_link(mat, node, "node_eevee_specular", in, out, GPU_constant(&node->ssr_id));
 }
 
+}  // namespace blender::nodes::node_shader_eevee_specular_cc
+
 /* node type definition */
-void register_node_type_sh_eevee_specular(void)
+void register_node_type_sh_eevee_specular()
 {
+  namespace file_ns = blender::nodes::node_shader_eevee_specular_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_EEVEE_SPECULAR, "Specular BSDF", NODE_CLASS_SHADER, 0);
-  node_type_socket_templates(&ntype, sh_node_eevee_specular_in, sh_node_eevee_specular_out);
-  node_type_gpu(&ntype, node_shader_gpu_eevee_specular);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_eevee_specular_in, file_ns::sh_node_eevee_specular_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_eevee_specular);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_emission.c b/source/blender/nodes/shader/nodes/node_shader_emission.cc
index 4f277686bbf..114f83893ce 100644
--- a/source/blender/nodes/shader/nodes/node_shader_emission.c
+++ b/source/blender/nodes/shader/nodes/node_shader_emission.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_emission_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_emission_in[] = {
@@ -41,14 +43,18 @@ static int node_shader_gpu_emission(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_emission", in, out, GPU_builtin(GPU_VIEW_NORMAL));
 }
 
+}  // namespace blender::nodes::node_shader_emission_cc
+
 /* node type definition */
-void register_node_type_sh_emission(void)
+void register_node_type_sh_emission()
 {
+  namespace file_ns = blender::nodes::node_shader_emission_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_EMISSION, "Emission", NODE_CLASS_SHADER, 0);
-  node_type_socket_templates(&ntype, sh_node_emission_in, sh_node_emission_out);
-  node_type_gpu(&ntype, node_shader_gpu_emission);
+  node_type_socket_templates(&ntype, file_ns::sh_node_emission_in, file_ns::sh_node_emission_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_emission);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_fresnel.c b/source/blender/nodes/shader/nodes/node_shader_fresnel.cc
index 3dc00b21a36..a6317c1adba 100644
--- a/source/blender/nodes/shader/nodes/node_shader_fresnel.c
+++ b/source/blender/nodes/shader/nodes/node_shader_fresnel.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_fresnel_cc {
+
 /* **************** Fresnel ******************** */
 static bNodeSocketTemplate sh_node_fresnel_in[] = {
     {SOCK_FLOAT, N_("IOR"), 1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@@ -57,15 +59,19 @@ static void node_shader_exec_fresnel(void *UNUSED(data),
 {
 }
 
+}  // namespace blender::nodes::node_shader_fresnel_cc
+
 /* node type definition */
-void register_node_type_sh_fresnel(void)
+void register_node_type_sh_fresnel()
 {
+  namespace file_ns = blender::nodes::node_shader_fresnel_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_FRESNEL, "Fresnel", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, sh_node_fresnel_in, sh_node_fresnel_out);
-  node_type_gpu(&ntype, node_shader_gpu_fresnel);
-  node_type_exec(&ntype, NULL, NULL, node_shader_exec_fresnel);
+  node_type_socket_templates(&ntype, file_ns::sh_node_fresnel_in, file_ns::sh_node_fresnel_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_fresnel);
+  node_type_exec(&ntype, NULL, NULL, file_ns::node_shader_exec_fresnel);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_gamma.c b/source/blender/nodes/shader/nodes/node_shader_gamma.cc
index 57bca29f8bf..4e20f733192 100644
--- a/source/blender/nodes/shader/nodes/node_shader_gamma.c
+++ b/source/blender/nodes/shader/nodes/node_shader_gamma.cc
@@ -19,6 +19,8 @@
 
 #include "node_shader_util.h"
 
+namespace blender::nodes::node_shader_gamma_cc {
+
 /* **************** Gamma Tools  ******************** */
 
 static bNodeSocketTemplate sh_node_gamma_in[] = {
@@ -58,14 +60,18 @@ static int node_shader_gpu_gamma(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_gamma", in, out);
 }
 
-void register_node_type_sh_gamma(void)
+}  // namespace blender::nodes::node_shader_gamma_cc
+
+void register_node_type_sh_gamma()
 {
+  namespace file_ns = blender::nodes::node_shader_gamma_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, 0);
-  node_type_socket_templates(&ntype, sh_node_gamma_in, sh_node_gamma_out);
-  node_type_exec(&ntype, NULL, NULL, node_shader_exec_gamma);
-  node_type_gpu(&ntype, node_shader_gpu_gamma);
+  node_type_socket_templates(&ntype, file_ns::sh_node_gamma_in, file_ns::sh_node_gamma_out);
+  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_gamma);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_gamma);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_geometry.c b/source/blender/nodes/shader/nodes/node_shader_geometry.cc
index 455b49f2197..15b3a64b3b2 100644
--- a/source/blender/nodes/shader/nodes/node_shader_geometry.c
+++ b/source/blender/nodes/shader/nodes/node_shader_geometry.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_geometry_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_geometry_out[] = {
@@ -79,21 +81,25 @@ static int node_shader_gpu_geometry(GPUMaterial *mat,
                out[i].link,
                out[i].link,
                &out[i].link,
-               NULL);
+               nullptr);
     }
   }
 
   return success;
 }
 
+}  // namespace blender::nodes::node_shader_geometry_cc
+
 /* node type definition */
-void register_node_type_sh_geometry(void)
+void register_node_type_sh_geometry()
 {
+  namespace file_ns = blender::nodes::node_shader_geometry_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_NEW_GEOMETRY, "Geometry", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_geometry_out);
-  node_type_gpu(&ntype, node_shader_gpu_geometry);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_geometry_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_geometry);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_squeeze.c b/source/blender/nodes/shader/nodes/node_shader_squeeze.cc
index 09852b16e76..9b32a675404 100644
--- a/source/blender/nodes/shader/nodes/node_shader_squeeze.c
+++ b/source/blender/nodes/shader/nodes/node_shader_squeeze.cc
@@ -23,6 +23,8 @@
 
 #include "node_shader_util.h"
 
+namespace blender::nodes::node_shader_squeeze_cc {
+
 /* **************** VALUE SQUEEZE ******************** */
 static bNodeSocketTemplate sh_node_squeeze_in[] = {
     {SOCK_FLOAT, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
@@ -57,14 +59,18 @@ static int gpu_shader_squeeze(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "squeeze", in, out);
 }
 
-void register_node_type_sh_squeeze(void)
+}  // namespace blender::nodes::node_shader_squeeze_cc
+
+void register_node_type_sh_squeeze()
 {
+  namespace file_ns = blender::nodes::node_shader_squeeze_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_SQUEEZE, "Squeeze Value", NODE_CLASS_CONVERTER, 0);
-  node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out);
-  node_type_exec(&ntype, NULL, NULL, node_shader_exec_squeeze);
-  node_type_gpu(&ntype, gpu_shader_squeeze);
+  node_type_socket_templates(&ntype, file_ns::sh_node_squeeze_in, file_ns::sh_node_squeeze_out);
+  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_squeeze);
+  node_type_gpu(&ntype, file_ns::gpu_shader_squeeze);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tangent.c b/source/blender/nodes/shader/nodes/node_shader_tangent.cc
index 2c12bf9bc01..edd361969fd 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tangent.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tangent.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_tangent_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_tangent_out[] = {
@@ -28,7 +30,7 @@ static bNodeSocketTemplate sh_node_tangent_out[] = {
 
 static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderTangent *attr = MEM_callocN(sizeof(NodeShaderTangent), "NodeShaderTangent");
+  NodeShaderTangent *attr = MEM_cnew<NodeShaderTangent>("NodeShaderTangent");
   attr->axis = SHD_TANGENT_AXIS_Z;
   node->storage = attr;
 }
@@ -39,7 +41,7 @@ static int node_shader_gpu_tangent(GPUMaterial *mat,
                                    GPUNodeStack *in,
                                    GPUNodeStack *out)
 {
-  NodeShaderTangent *attr = node->storage;
+  NodeShaderTangent *attr = static_cast<NodeShaderTangent *>(node->storage);
 
   if (attr->direction_type == SHD_TANGENT_UVMAP) {
     return GPU_stack_link(
@@ -68,16 +70,20 @@ static int node_shader_gpu_tangent(GPUMaterial *mat,
                         GPU_builtin(GPU_OBJECT_MATRIX));
 }
 
+}  // namespace blender::nodes::node_shader_tangent_cc
+
 /* node type definition */
-void register_node_type_sh_tangent(void)
+void register_node_type_sh_tangent()
 {
+  namespace file_ns = blender::nodes::node_shader_tangent_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TANGENT, "Tangent", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_tangent_out);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_tangent_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, node_shader_init_tangent);
-  node_type_gpu(&ntype, node_shader_gpu_tangent);
+  node_type_init(&ntype, file_ns::node_shader_init_tangent);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_tangent);
   node_type_storage(
       &ntype, "NodeShaderTangent", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_coord.c b/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc
index b3f6a5fb569..a7768871cf8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_coord.c
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc
@@ -21,6 +21,8 @@
 
 #include "DNA_customdata_types.h"
 
+namespace blender::nodes::node_shader_tex_coord_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_tex_coord_out[] = {
@@ -42,11 +44,12 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat,
 {
   Object *ob = (Object *)node->id;
 
-  GPUNodeLink *inv_obmat = (ob != NULL) ? GPU_uniform(&ob->imat[0][0]) :
-                                          GPU_builtin(GPU_INVERSE_OBJECT_MATRIX);
+  GPUNodeLink *inv_obmat = (ob != nullptr) ? GPU_uniform(&ob->imat[0][0]) :
+                                             GPU_builtin(GPU_INVERSE_OBJECT_MATRIX);
 
   /* Opti: don't request orco if not needed. */
-  GPUNodeLink *orco = (!out[0].hasoutput) ? GPU_constant((float[4]){0.0f, 0.0f, 0.0f, 0.0f}) :
+  const float default_coords[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+  GPUNodeLink *orco = (!out[0].hasoutput) ? GPU_constant(default_coords) :
                                             GPU_attribute(mat, CD_ORCO, "");
   GPUNodeLink *mtface = GPU_attribute(mat, CD_MTFACE, "");
   GPUNodeLink *viewpos = GPU_builtin(GPU_VIEW_POSITION);
@@ -75,21 +78,25 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat,
                out[i].link,
                out[i].link,
                &out[i].link,
-               NULL);
+               nullptr);
     }
   }
 
   return 1;
 }
 
+}  // namespace blender::nodes::node_shader_tex_coord_cc
+
 /* node type definition */
-void register_node_type_sh_tex_coord(void)
+void register_node_type_sh_tex_coord()
 {
+  namespace file_ns = blender::nodes::node_shader_tex_coord_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TEX_COORD, "Texture Coordinate", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_tex_coord_out);
-  node_type_gpu(&ntype, node_shader_gpu_tex_coord);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_tex_coord_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_coord);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.c b/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc
index f96c255f781..aee5b06f8b9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.c
+++ b/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_uv_along_stroke_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_uvalongstroke_out[] = {
@@ -26,13 +28,17 @@ static bNodeSocketTemplate sh_node_uvalongstroke_out[] = {
     {-1, ""},
 };
 
+}  // namespace blender::nodes::node_shader_uv_along_stroke_cc
+
 /* node type definition */
-void register_node_type_sh_uvalongstroke(void)
+void register_node_type_sh_uvalongstroke()
 {
+  namespace file_ns = blender::nodes::node_shader_uv_along_stroke_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_UVALONGSTROKE, "UV Along Stroke", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_uvalongstroke_out);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_uvalongstroke_out);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_uvmap.c b/source/blender/nodes/shader/nodes/node_shader_uvmap.cc
index 775b8ffbc06..18975601a05 100644
--- a/source/blender/nodes/shader/nodes/node_shader_uvmap.c
+++ b/source/blender/nodes/shader/nodes/node_shader_uvmap.cc
@@ -21,6 +21,8 @@
 
 #include "DNA_customdata_types.h"
 
+namespace blender::nodes::node_shader_uvmap_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_uvmap_out[] = {
@@ -30,7 +32,7 @@ static bNodeSocketTemplate sh_node_uvmap_out[] = {
 
 static void node_shader_init_uvmap(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderUVMap *attr = MEM_callocN(sizeof(NodeShaderUVMap), "NodeShaderUVMap");
+  NodeShaderUVMap *attr = MEM_cnew<NodeShaderUVMap>("NodeShaderUVMap");
   node->storage = attr;
 }
 
@@ -40,7 +42,7 @@ static int node_shader_gpu_uvmap(GPUMaterial *mat,
                                  GPUNodeStack *in,
                                  GPUNodeStack *out)
 {
-  NodeShaderUVMap *attr = node->storage;
+  NodeShaderUVMap *attr = static_cast<NodeShaderUVMap *>(node->storage);
   GPUNodeLink *mtface = GPU_attribute(mat, CD_MTFACE, attr->uv_map);
 
   GPU_stack_link(mat, node, "node_uvmap", in, out, mtface);
@@ -50,18 +52,22 @@ static int node_shader_gpu_uvmap(GPUMaterial *mat,
   return 1;
 }
 
+}  // namespace blender::nodes::node_shader_uvmap_cc
+
 /* node type definition */
-void register_node_type_sh_uvmap(void)
+void register_node_type_sh_uvmap()
 {
+  namespace file_ns = blender::nodes::node_shader_uvmap_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_UVMAP, "UV Map", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_uvmap_out);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_uvmap_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, node_shader_init_uvmap);
+  node_type_init(&ntype, file_ns::node_shader_init_uvmap);
   node_type_storage(
       &ntype, "NodeShaderUVMap", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, node_shader_gpu_uvmap);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_uvmap);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_displacement.c b/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc
index acbb11bdaea..765de0ebb89 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_displacement.c
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_vector_displacement_cc {
+
 /* **************** OUTPUT ******************** */
 
 static bNodeSocketTemplate sh_node_vector_displacement_in[] = {
@@ -63,17 +65,21 @@ static int gpu_shader_vector_displacement(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_vector_displacement_world", in, out);
 }
 
+}  // namespace blender::nodes::node_shader_vector_displacement_cc
+
 /* node type definition */
-void register_node_type_sh_vector_displacement(void)
+void register_node_type_sh_vector_displacement()
 {
+  namespace file_ns = blender::nodes::node_shader_vector_displacement_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(
       &ntype, SH_NODE_VECTOR_DISPLACEMENT, "Vector Displacement", NODE_CLASS_OP_VECTOR, 0);
   node_type_socket_templates(
-      &ntype, sh_node_vector_displacement_in, sh_node_vector_displacement_out);
-  node_type_init(&ntype, node_shader_init_vector_displacement);
-  node_type_gpu(&ntype, gpu_shader_vector_displacement);
+      &ntype, file_ns::sh_node_vector_displacement_in, file_ns::sh_node_vector_displacement_out);
+  node_type_init(&ntype, file_ns::node_shader_init_vector_displacement);
+  node_type_gpu(&ntype, file_ns::gpu_shader_vector_displacement);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_transform.c b/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc
index 7b08178f874..fc6a05d93b6 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_transform.c
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc
@@ -23,6 +23,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_vector_transform_cc {
+
 /* **************** Vector Transform ******************** */
 static bNodeSocketTemplate sh_node_vect_transform_in[] = {
     {SOCK_VECTOR, N_("Vector"), 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE}, {-1, ""}};
@@ -34,8 +36,7 @@ static bNodeSocketTemplate sh_node_vect_transform_out[] = {
 
 static void node_shader_init_vect_transform(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderVectTransform *vect = MEM_callocN(sizeof(NodeShaderVectTransform),
-                                              "NodeShaderVectTransform");
+  NodeShaderVectTransform *vect = MEM_cnew<NodeShaderVectTransform>("NodeShaderVectTransform");
 
   /* Convert World into Object Space per default */
   vect->convert_to = 1;
@@ -58,7 +59,7 @@ static GPUNodeLink *get_gpulink_matrix_from_to(short from, short to)
     case SHD_VECT_TRANSFORM_SPACE_OBJECT:
       switch (to) {
         case SHD_VECT_TRANSFORM_SPACE_OBJECT:
-          return NULL;
+          return nullptr;
         case SHD_VECT_TRANSFORM_SPACE_WORLD:
           return GPU_builtin(GPU_OBJECT_MATRIX);
         case SHD_VECT_TRANSFORM_SPACE_CAMERA:
@@ -68,7 +69,7 @@ static GPUNodeLink *get_gpulink_matrix_from_to(short from, short to)
     case SHD_VECT_TRANSFORM_SPACE_WORLD:
       switch (to) {
         case SHD_VECT_TRANSFORM_SPACE_WORLD:
-          return NULL;
+          return nullptr;
         case SHD_VECT_TRANSFORM_SPACE_CAMERA:
           return GPU_builtin(GPU_VIEW_MATRIX);
         case SHD_VECT_TRANSFORM_SPACE_OBJECT:
@@ -78,7 +79,7 @@ static GPUNodeLink *get_gpulink_matrix_from_to(short from, short to)
     case SHD_VECT_TRANSFORM_SPACE_CAMERA:
       switch (to) {
         case SHD_VECT_TRANSFORM_SPACE_CAMERA:
-          return NULL;
+          return nullptr;
         case SHD_VECT_TRANSFORM_SPACE_WORLD:
           return GPU_builtin(GPU_INVERSE_VIEW_MATRIX);
         case SHD_VECT_TRANSFORM_SPACE_OBJECT:
@@ -86,7 +87,7 @@ static GPUNodeLink *get_gpulink_matrix_from_to(short from, short to)
       }
       break;
   }
-  return NULL;
+  return nullptr;
 }
 static int gpu_shader_vect_transform(GPUMaterial *mat,
                                      bNode *node,
@@ -137,17 +138,22 @@ static int gpu_shader_vect_transform(GPUMaterial *mat,
   return true;
 }
 
-void register_node_type_sh_vect_transform(void)
+}  // namespace blender::nodes::node_shader_vector_transform_cc
+
+void register_node_type_sh_vect_transform()
 {
+  namespace file_ns = blender::nodes::node_shader_vector_transform_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_VECT_TRANSFORM, "Vector Transform", NODE_CLASS_OP_VECTOR, 0);
-  node_type_init(&ntype, node_shader_init_vect_transform);
-  node_type_socket_templates(&ntype, sh_node_vect_transform_in, sh_node_vect_transform_out);
+  node_type_init(&ntype, file_ns::node_shader_init_vect_transform);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_vect_transform_in, file_ns::sh_node_vect_transform_out);
   node_type_storage(
       &ntype, "NodeShaderVectTransform", node_free_standard_storage, node_copy_standard_storage);
-  node_type_exec(&ntype, NULL, NULL, node_shader_exec_vect_transform);
-  node_type_gpu(&ntype, gpu_shader_vect_transform);
+  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_vect_transform);
+  node_type_gpu(&ntype, file_ns::gpu_shader_vect_transform);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vertex_color.c b/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc
index 40576b68dd5..c6b67fe7c94 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vertex_color.c
+++ b/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_vertex_color_cc {
+
 static bNodeSocketTemplate sh_node_vertex_color_out[] = {
     {SOCK_RGBA, N_("Color")},
     {SOCK_FLOAT, N_("Alpha")},
@@ -27,8 +29,7 @@ static bNodeSocketTemplate sh_node_vertex_color_out[] = {
 
 static void node_shader_init_vertex_color(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderVertexColor *vertexColor = MEM_callocN(sizeof(NodeShaderVertexColor),
-                                                   "NodeShaderVertexColor");
+  NodeShaderVertexColor *vertexColor = MEM_cnew<NodeShaderVertexColor>("NodeShaderVertexColor");
   node->storage = vertexColor;
 }
 
@@ -47,16 +48,20 @@ static int node_shader_gpu_vertex_color(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink);
 }
 
-void register_node_type_sh_vertex_color(void)
+}  // namespace blender::nodes::node_shader_vertex_color_cc
+
+void register_node_type_sh_vertex_color()
 {
+  namespace file_ns = blender::nodes::node_shader_vertex_color_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_VERTEX_COLOR, "Vertex Color", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_vertex_color_out);
-  node_type_init(&ntype, node_shader_init_vertex_color);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_vertex_color_out);
+  node_type_init(&ntype, file_ns::node_shader_init_vertex_color);
   node_type_storage(
       &ntype, "NodeShaderVertexColor", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, node_shader_gpu_vertex_color);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_vertex_color);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_info.c b/source/blender/nodes/shader/nodes/node_shader_volume_info.cc
index 6cafc991e13..8e5f62e07e0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_volume_info.c
+++ b/source/blender/nodes/shader/nodes/node_shader_volume_info.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_volume_info_cc {
+
 static bNodeSocketTemplate sh_node_volume_info_out[] = {
     {SOCK_RGBA, N_("Color")},
     {SOCK_FLOAT, N_("Density")},
@@ -49,13 +51,17 @@ static int node_shader_gpu_volume_info(GPUMaterial *mat,
   return true;
 }
 
-void register_node_type_sh_volume_info(void)
+}  // namespace blender::nodes::node_shader_volume_info_cc
+
+void register_node_type_sh_volume_info()
 {
+  namespace file_ns = blender::nodes::node_shader_volume_info_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_VOLUME_INFO, "Volume Info", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, sh_node_volume_info_out);
-  node_type_gpu(&ntype, node_shader_gpu_volume_info);
+  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_volume_info_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_info);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_wavelength.c b/source/blender/nodes/shader/nodes/node_shader_wavelength.cc
index 13989d1760e..5acb553ea00 100644
--- a/source/blender/nodes/shader/nodes/node_shader_wavelength.c
+++ b/source/blender/nodes/shader/nodes/node_shader_wavelength.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_wavelength_cc {
+
 /* **************** Wavelength ******************** */
 static bNodeSocketTemplate sh_node_wavelength_in[] = {
     {SOCK_FLOAT, N_("Wavelength"), 500.0f, 0.0f, 0.0f, 0.0f, 380.0f, 780.0f},
@@ -37,7 +39,7 @@ static int node_shader_gpu_wavelength(GPUMaterial *mat,
                                       GPUNodeStack *out)
 {
   const int size = CM_TABLE + 1;
-  float *data = MEM_mallocN(sizeof(float) * size * 4, "cie_xyz texture");
+  float *data = static_cast<float *>(MEM_mallocN(sizeof(float) * size * 4, "cie_xyz texture"));
 
   wavelength_to_xyz_table(data, size);
 
@@ -57,15 +59,20 @@ static int node_shader_gpu_wavelength(GPUMaterial *mat,
                         GPU_uniform(xyz_to_rgb.b));
 }
 
+}  // namespace blender::nodes::node_shader_wavelength_cc
+
 /* node type definition */
-void register_node_type_sh_wavelength(void)
+void register_node_type_sh_wavelength()
 {
+  namespace file_ns = blender::nodes::node_shader_wavelength_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_WAVELENGTH, "Wavelength", NODE_CLASS_CONVERTER, 0);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_socket_templates(&ntype, sh_node_wavelength_in, sh_node_wavelength_out);
-  node_type_gpu(&ntype, node_shader_gpu_wavelength);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_wavelength_in, file_ns::sh_node_wavelength_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_wavelength);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_wireframe.c b/source/blender/nodes/shader/nodes/node_shader_wireframe.cc
index 512f14a0838..558393e4406 100644
--- a/source/blender/nodes/shader/nodes/node_shader_wireframe.c
+++ b/source/blender/nodes/shader/nodes/node_shader_wireframe.cc
@@ -19,6 +19,8 @@
 
 #include "../node_shader_util.h"
 
+namespace blender::nodes::node_shader_wireframe_cc {
+
 /* **************** Wireframe ******************** */
 static bNodeSocketTemplate sh_node_wireframe_in[] = {
     {SOCK_FLOAT, N_("Size"), 0.01f, 0.0f, 0.0f, 0.0f, 0.0f, 100.0f},
@@ -52,14 +54,19 @@ static int node_shader_gpu_wireframe(GPUMaterial *mat,
                         GPU_builtin(GPU_BARYCENTRIC_DIST));
 }
 
+}  // namespace blender::nodes::node_shader_wireframe_cc
+
 /* node type definition */
-void register_node_type_sh_wireframe(void)
+void register_node_type_sh_wireframe()
 {
+  namespace file_ns = blender::nodes::node_shader_wireframe_cc;
+
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_WIREFRAME, "Wireframe", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, sh_node_wireframe_in, sh_node_wireframe_out);
-  node_type_gpu(&ntype, node_shader_gpu_wireframe);
+  node_type_socket_templates(
+      &ntype, file_ns::sh_node_wireframe_in, file_ns::sh_node_wireframe_out);
+  node_type_gpu(&ntype, file_ns::node_shader_gpu_wireframe);
 
   nodeRegisterType(&ntype);
 }