Revert moving all shader nodes to c++

This reverts to following commits:
* rB5cad004d716da02f511bd34983ac7da820308676
* rB97e3a2d935ba9b21b127eda7ca104d4bcf4e48bd
* rBf60b95b5320f8d6abe6a629fe8fc4f1b94d0d91c
* rB0bd3cad04edf4bf9b9d3b1353f955534aa5e6740
* rBf72cc47d8edf849af98e196f721022bacf86a5e7
* rB3f7014ecc9d523997062eadd62888af5fc70a2b6
* rB0578921063fbb081239439062215f2538a31af4b
* rBc20098e6ec6adee874a12e510aa4a56d89f92838
* rBd5efda72f501ad95679d7ac554086a1fb18c1ac0

The original move to c++ that the other commits depended upon had some issues
that should be fixed before committing it again. The issues were reported in
T93797, T93809 and T93798.

We should also find a better rule for not using c-style casts going forward,
although that wouldn't have been reason enough to revert the commits.
Introducing something like a `MEM_new<T>` and `MEM_delete<T>`
function might help with the the most common case of casting the return
type of `MEM_malloc`.

Going forward, I recommend first committing the changes that don't
require converting files to c++. Then convert the shading node files
in smaller chunks. Especially don't mix fairly low risk changes like
moving some simple nodes, with higher risk changes.

94 files changed, 1212 insertions, 1730 deletions

diff --git a/source/blender/nodes/shader/nodes/node_shader_add_shader.cc b/source/blender/nodes/shader/nodes/node_shader_add_shader.c
index 81c7643e18b..12c138ac9d5 100644
--- a/source/blender/nodes/shader/nodes/node_shader_add_shader.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_add_shader.c
@@ -17,18 +17,20 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_add_shader_cc {
+static bNodeSocketTemplate sh_node_add_shader_in[] = {
+    {SOCK_SHADER, N_("Shader")},
+    {SOCK_SHADER, N_("Shader")},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Shader>(N_("Shader"));
-  b.add_input<decl::Shader>(N_("Shader"), "Shader_001");
-  b.add_output<decl::Shader>(N_("Shader"));
-}
+static bNodeSocketTemplate sh_node_add_shader_out[] = {
+    {SOCK_SHADER, N_("Shader")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_add_shader(GPUMaterial *mat,
                                       bNode *node,
@@ -39,20 +41,16 @@ static int node_shader_gpu_add_shader(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_add_shader", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_add_shader_cc
-
 /* node type definition */
-void register_node_type_sh_add_shader()
+void register_node_type_sh_add_shader(void)
 {
-  namespace file_ns = blender::nodes::node_shader_add_shader_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_ADD_SHADER, "Add Shader", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_add_shader);
+  node_type_socket_templates(&ntype, sh_node_add_shader_in, sh_node_add_shader_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_add_shader);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c
index cf201aab7d8..abe80ebcefb 100644
--- a/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_ambient_occlusion.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_ambient_occlusion_cc {
-
 static bNodeSocketTemplate sh_node_ambient_occlusion_in[] = {
     {SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
     {SOCK_FLOAT, N_("Distance"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@@ -66,21 +64,16 @@ 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 register_node_type_sh_ambient_occlusion(void)
 {
-  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, 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_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_ambient_occlusion);
+  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_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_ambient_occlusion);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_attribute.cc b/source/blender/nodes/shader/nodes/node_shader_attribute.c
index 068d1266caa..9b3122e38e0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_attribute.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_attribute.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_attribute_cc {
-
 static bNodeSocketTemplate sh_node_attribute_out[] = {
     {SOCK_RGBA, N_("Color")},
     {SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -33,8 +31,7 @@ static bNodeSocketTemplate sh_node_attribute_out[] = {
 
 static void node_shader_init_attribute(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderAttribute *attr = (NodeShaderAttribute *)MEM_callocN(sizeof(NodeShaderAttribute),
-                                                                 "NodeShaderAttribute");
+  NodeShaderAttribute *attr = MEM_callocN(sizeof(NodeShaderAttribute), "NodeShaderAttribute");
   node->storage = attr;
 }
 
@@ -44,7 +41,7 @@ static int node_shader_gpu_attribute(GPUMaterial *mat,
                                      GPUNodeStack *in,
                                      GPUNodeStack *out)
 {
-  NodeShaderAttribute *attr = (NodeShaderAttribute *)node->storage;
+  NodeShaderAttribute *attr = node->storage;
   bool is_varying = attr->type == SHD_ATTRIBUTE_GEOMETRY;
 
   if (GPU_material_is_volume_shader(mat) && is_varying) {
@@ -84,21 +81,17 @@ 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 register_node_type_sh_attribute(void)
 {
-  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, nullptr, file_ns::sh_node_attribute_out);
-  node_type_init(&ntype, file_ns::node_shader_init_attribute);
+  node_type_socket_templates(&ntype, NULL, sh_node_attribute_out);
+  node_type_init(&ntype, node_shader_init_attribute);
   node_type_storage(
       &ntype, "NodeShaderAttribute", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_attribute);
+  node_type_gpu(&ntype, node_shader_gpu_attribute);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_background.cc b/source/blender/nodes/shader/nodes/node_shader_background.c
index 68ff2a3fb40..5281a9fecb1 100644
--- a/source/blender/nodes/shader/nodes/node_shader_background.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_background.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_background_cc {
-
 static bNodeSocketTemplate sh_node_background_in[] = {
     {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
     {SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
@@ -43,21 +41,16 @@ 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 register_node_type_sh_background(void)
 {
-  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, file_ns::sh_node_background_in, file_ns::sh_node_background_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_background);
+  node_type_socket_templates(&ntype, sh_node_background_in, sh_node_background_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_background);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bevel.cc b/source/blender/nodes/shader/nodes/node_shader_bevel.c
index f34e9e99f37..347d82c5506 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bevel.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bevel.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bevel_cc {
-
 static bNodeSocketTemplate sh_node_bevel_in[] = {
     {SOCK_FLOAT, N_("Radius"), 0.05f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@@ -56,20 +54,16 @@ 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 register_node_type_sh_bevel(void)
 {
-  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, file_ns::sh_node_bevel_in, file_ns::sh_node_bevel_out);
-  node_type_init(&ntype, file_ns::node_shader_init_bevel);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::gpu_shader_bevel);
+  node_type_socket_templates(&ntype, sh_node_bevel_in, sh_node_bevel_out);
+  node_type_init(&ntype, node_shader_init_bevel);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, gpu_shader_bevel);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_blackbody.cc b/source/blender/nodes/shader/nodes/node_shader_blackbody.c
index de5bf98fd79..95c35affc27 100644
--- a/source/blender/nodes/shader/nodes/node_shader_blackbody.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_blackbody.c
@@ -17,12 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** Blackbody ******************** */
-
-namespace blender::nodes::node_shader_blackbody_cc {
-
 static bNodeSocketTemplate sh_node_blackbody_in[] = {
     {SOCK_FLOAT, N_("Temperature"), 1500.0f, 0.0f, 0.0f, 0.0f, 800.0f, 12000.0f},
     {-1, ""},
@@ -40,7 +37,7 @@ static int node_shader_gpu_blackbody(GPUMaterial *mat,
                                      GPUNodeStack *out)
 {
   const int size = CM_TABLE + 1;
-  float *data = (float *)MEM_mallocN(sizeof(float) * size * 4, "blackbody texture");
+  float *data = MEM_mallocN(sizeof(float) * size * 4, "blackbody texture");
 
   blackbody_temperature_to_rgb_table(data, size, 965.0f, 12000.0f);
 
@@ -50,22 +47,17 @@ 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 register_node_type_sh_blackbody(void)
 {
-  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, file_ns::sh_node_blackbody_in, file_ns::sh_node_blackbody_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_blackbody);
+  node_type_socket_templates(&ntype, sh_node_blackbody_in, sh_node_blackbody_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_blackbody);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_brightness.cc b/source/blender/nodes/shader/nodes/node_shader_brightness.c
index 3e76a2cb0b1..4f375c666de 100644
--- a/source/blender/nodes/shader/nodes/node_shader_brightness.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_brightness.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** Bright and contrast  ******************** */
 
-namespace blender::nodes::node_shader_brightness_cc {
-
 static bNodeSocketTemplate sh_node_brightcontrast_in[] = {
     {SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f},
     {SOCK_FLOAT, N_("Bright"), 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
@@ -44,20 +42,15 @@ static int gpu_shader_brightcontrast(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "brightness_contrast", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_brightness_cc
-
-void register_node_type_sh_brightcontrast()
+void register_node_type_sh_brightcontrast(void)
 {
-  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, file_ns::sh_node_brightcontrast_in, file_ns::sh_node_brightcontrast_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::gpu_shader_brightcontrast);
+  node_type_socket_templates(&ntype, sh_node_brightcontrast_in, sh_node_brightcontrast_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, gpu_shader_brightcontrast);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c
index 9fac8d70e9d..499f62da683 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_anisotropic.c
@@ -17,26 +17,24 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_anisotropic_cc {
+static bNodeSocketTemplate sh_node_bsdf_anisotropic_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Roughness"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Anisotropy"), 0.5f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f},
+    {SOCK_FLOAT, N_("Rotation"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {SOCK_VECTOR, N_("Tangent"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Roughness"))
-      .default_value(0.5f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Anisotropy")).default_value(0.5f).min(-1.0f).max(1.0f);
-  b.add_input<decl::Float>(N_("Rotation")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_input<decl::Vector>(N_("Tangent")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_anisotropic_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static void node_shader_init_anisotropic(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -66,21 +64,17 @@ static int node_shader_gpu_bsdf_anisotropic(GPUMaterial *mat,
                         GPU_constant(&node->ssr_id));
 }
 
-}  // namespace blender::nodes::node_shader_anisotropic_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_anisotropic()
+void register_node_type_sh_bsdf_anisotropic(void)
 {
-  namespace file_ns = blender::nodes::node_shader_anisotropic_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_ANISOTROPIC, "Anisotropic BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_anisotropic_in, sh_node_bsdf_anisotropic_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_anisotropic);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_anisotropic);
+  node_type_init(&ntype, node_shader_init_anisotropic);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_anisotropic);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c
index c3ec80a4cf9..f4f1d274826 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_diffuse.c
@@ -17,19 +17,21 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_diffuse_cc {
+static bNodeSocketTemplate sh_node_bsdf_diffuse_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Roughness")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_diffuse_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat,
                                         bNode *node,
@@ -46,21 +48,17 @@ static int node_shader_gpu_bsdf_diffuse(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_diffuse", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_diffuse_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_diffuse()
+void register_node_type_sh_bsdf_diffuse(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_diffuse_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_DIFFUSE, "Diffuse BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_diffuse_in, sh_node_bsdf_diffuse_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_diffuse);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_diffuse);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c
index 840d7e68dbc..5fc946e3509 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glass.c
@@ -17,20 +17,22 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_glass_cc {
+static bNodeSocketTemplate sh_node_bsdf_glass_in[] = {
+    {SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("IOR"), 1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
-  b.add_input<decl::Float>(N_("Roughness")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("IOR")).default_value(1.45f).min(0.0f).max(1000.0f);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_glass_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static void node_shader_init_glass(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -51,7 +53,7 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat,
     GPU_link(mat, "set_value_zero", &in[1].link);
   }
 
-  GPU_material_flag_set(mat, (eGPUMatFlag)(GPU_MATFLAG_GLOSSY | GPU_MATFLAG_REFRACT));
+  GPU_material_flag_set(mat, GPU_MATFLAG_GLOSSY | GPU_MATFLAG_REFRACT);
 
   float use_multi_scatter = (node->custom1 == SHD_GLOSSY_MULTI_GGX) ? 1.0f : 0.0f;
 
@@ -64,21 +66,17 @@ static int node_shader_gpu_bsdf_glass(GPUMaterial *mat,
                         GPU_constant(&node->ssr_id));
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_glass_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_glass()
+void register_node_type_sh_bsdf_glass(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_glass_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_GLASS, "Glass BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_glass_in, sh_node_bsdf_glass_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_glass);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_glass);
+  node_type_init(&ntype, node_shader_init_glass);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_glass);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c
index 0090096fd42..13b1b21c7fc 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_glossy.c
@@ -17,23 +17,21 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_glossy_cc {
+static bNodeSocketTemplate sh_node_bsdf_glossy_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Roughness"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Roughness"))
-      .default_value(0.5)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_glossy_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static void node_shader_init_glossy(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -67,21 +65,17 @@ static int node_shader_gpu_bsdf_glossy(GPUMaterial *mat,
                         GPU_constant(&node->ssr_id));
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_glossy_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_glossy()
+void register_node_type_sh_bsdf_glossy(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_glossy_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_GLOSSY, "Glossy BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_glossy_in, sh_node_bsdf_glossy_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_glossy);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_glossy);
+  node_type_init(&ntype, node_shader_init_glossy);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_glossy);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.c
index 0bb0e886a7c..fb2decec5f4 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair.c
@@ -17,29 +17,23 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_hair_cc {
+static bNodeSocketTemplate sh_node_bsdf_hair_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Offset"), 0.0f, 0.0f, 0.0f, 0.0f, -M_PI_2, M_PI_2, PROP_ANGLE},
+    {SOCK_FLOAT, N_("RoughnessU"), 0.1f, 0.1f, 0.1f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("RoughnessV"), 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Tangent"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Offset")).min(-M_PI_2).max(M_PI_2).subtype(PROP_ANGLE);
-  b.add_input<decl::Float>(N_("RoughnessU"))
-      .default_value(0.1f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("RoughnessV"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Tangent")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_hair_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_bsdf_hair(GPUMaterial *mat,
                                      bNode *node,
@@ -50,21 +44,17 @@ static int node_shader_gpu_bsdf_hair(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_hair", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_hair_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_hair()
+void register_node_type_sh_bsdf_hair(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_hair_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_HAIR, "Hair BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_hair_in, sh_node_bsdf_hair_out);
   node_type_size(&ntype, 150, 60, 200);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_hair);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_hair);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.c
index 55ac8bc4ff9..d2b40a7ec39 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_hair_principled.c
@@ -17,54 +17,40 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_hair_principled_cc {
-
 /* Color, melanin and absorption coefficient default to approximately same brownish hair. */
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.017513f, 0.005763f, 0.002059f, 1.0f});
-  b.add_input<decl::Float>(N_("Melanin"))
-      .default_value(0.8f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Melanin Redness"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Color>(N_("Tint")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
-  b.add_input<decl::Vector>(N_("Absorption Coefficient"))
-      .default_value({0.245531f, 0.52f, 1.365f})
-      .min(0.0f)
-      .max(1000.0f);
+static bNodeSocketTemplate sh_node_bsdf_hair_principled_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.017513f, 0.005763f, 0.002059f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Melanin"), 0.8f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Melanin Redness"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_RGBA, N_("Tint"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_VECTOR, N_("Absorption Coefficient"), 0.245531f, 0.52f, 1.365f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_FLOAT, N_("Roughness"), 0.3f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Radial Roughness"), 0.3f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Coat"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("IOR"), 1.55f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_FLOAT,
+     N_("Offset"),
+     2.0f * ((float)M_PI) / 180.0f,
+     0.0f,
+     0.0f,
+     0.0f,
+     -M_PI_2,
+     M_PI_2,
+     PROP_ANGLE},
+    {SOCK_FLOAT, N_("Random Color"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Random Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Random"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-  b.add_input<decl::Float>(N_("Roughness"))
-      .default_value(0.3f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Radial Roughness"))
-      .default_value(0.3f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Coat")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("IOR")).default_value(1.55f).min(0.0f).max(1000.0f);
-  b.add_input<decl::Float>(N_("Offset"))
-      .default_value(2.0f * ((float)M_PI) / 180.0f)
-      .min(-M_PI_2)
-      .max(M_PI_2)
-      .subtype(PROP_ANGLE);
-  b.add_input<decl::Float>(N_("Random Color")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Random Roughness")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Random")).min(0.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_hair_principled_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 /* Initialize the custom Parametrization property to Color. */
 static void node_shader_init_hair_principled(bNodeTree *UNUSED(ntree), bNode *node)
@@ -75,9 +61,10 @@ static void node_shader_init_hair_principled(bNodeTree *UNUSED(ntree), bNode *no
 /* Triggers (in)visibility of some sockets when changing Parametrization. */
 static void node_shader_update_hair_principled(bNodeTree *ntree, bNode *node)
 {
+  bNodeSocket *sock;
   int parametrization = node->custom1;
 
-  LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
+  for (sock = node->inputs.first; sock; sock = sock->next) {
     if (STREQ(sock->name, "Color")) {
       nodeSetSocketAvailability(ntree, sock, parametrization == SHD_PRINCIPLED_HAIR_REFLECTANCE);
     }
@@ -104,22 +91,19 @@ static void node_shader_update_hair_principled(bNodeTree *ntree, bNode *node)
   }
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_hair_principled_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_hair_principled()
+void register_node_type_sh_bsdf_hair_principled(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_hair_principled_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(
       &ntype, SH_NODE_BSDF_HAIR_PRINCIPLED, "Principled Hair BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(
+      &ntype, sh_node_bsdf_hair_principled_in, sh_node_bsdf_hair_principled_out);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  node_type_init(&ntype, file_ns::node_shader_init_hair_principled);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_update(&ntype, file_ns::node_shader_update_hair_principled);
+  node_type_init(&ntype, node_shader_init_hair_principled);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_update(&ntype, node_shader_update_hair_principled);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c
index ff01a9d6a91..b9f4106c79a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_principled.c
@@ -17,66 +17,61 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_principled_cc {
-
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Base Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Subsurface")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Subsurface Radius"))
-      .default_value({1.0f, 0.2f, 0.1f})
-      .min(0.0f)
-      .max(100.0f)
-      .compact();
-  b.add_input<decl::Color>(N_("Subsurface Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Subsurface IOR"))
-      .default_value(1.4f)
-      .min(1.01f)
-      .max(3.8f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Subsurface Anisotropy")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Metallic")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Specular")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Specular Tint")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Roughness"))
-      .default_value(0.5f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Anisotropic")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Anisotropic Rotation")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Sheen")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Sheen Tint"))
-      .default_value(0.5f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Clearcoat")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Clearcoat Roughness"))
-      .default_value(0.03f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("IOR")).default_value(1.45f).min(0.0f).max(1000.0f).subtype(
-      PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Transmission")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Transmission Roughness")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Color>(N_("Emission")).default_value({0.0f, 0.0f, 0.0f, 1.0f});
-  b.add_input<decl::Float>(N_("Emission Strength")).default_value(1.0f).min(0.0f).max(1000000.0f);
-  b.add_input<decl::Float>(N_("Alpha"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_input<decl::Vector>(N_("Clearcoat Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_input<decl::Vector>(N_("Tangent")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_principled_in[] = {
+    {SOCK_RGBA, N_("Base Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Subsurface"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR,
+     N_("Subsurface Radius"),
+     1.0f,
+     0.2f,
+     0.1f,
+     0.0f,
+     0.0f,
+     100.0f,
+     PROP_NONE,
+     SOCK_COMPACT},
+    {SOCK_RGBA, N_("Subsurface Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Subsurface IOR"), 1.4f, 0.0f, 0.0f, 0.0f, 1.01f, 3.8f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Subsurface Anisotropy"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Metallic"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Specular"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Specular Tint"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Roughness"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Anisotropic"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Anisotropic Rotation"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Sheen"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Sheen Tint"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Clearcoat"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Clearcoat Roughness"), 0.03f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("IOR"), 1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_FLOAT, N_("Transmission"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Transmission Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_RGBA, N_("Emission"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Emission Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
+    {SOCK_FLOAT, N_("Alpha"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {SOCK_VECTOR,
+     N_("Clearcoat Normal"),
+     0.0f,
+     0.0f,
+     0.0f,
+     1.0f,
+     -1.0f,
+     1.0f,
+     PROP_NONE,
+     SOCK_HIDE_VALUE},
+    {SOCK_VECTOR, N_("Tangent"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
+
+static bNodeSocketTemplate sh_node_bsdf_principled_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static void node_shader_init_principled(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -127,8 +122,8 @@ static int node_shader_gpu_bsdf_principled(GPUMaterial *mat,
 
   /* SSS Profile */
   if (use_subsurf) {
-    bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&node->original->inputs, 2);
-    bNodeSocketValueRGBA *socket_data = (bNodeSocketValueRGBA *)socket->default_value;
+    bNodeSocket *socket = BLI_findlink(&node->original->inputs, 2);
+    bNodeSocketValueRGBA *socket_data = socket->default_value;
     /* For some reason it seems that the socket value is in ARGB format. */
     GPU_material_sss_profile_create(mat, &socket_data->value[1]);
   }
@@ -156,7 +151,7 @@ static int node_shader_gpu_bsdf_principled(GPUMaterial *mat,
   float f_use_refraction = use_refract ? 1.0f : 0.0f;
   float use_multi_scatter = (node->custom1 == SHD_GLOSSY_MULTI_GGX) ? 1.0f : 0.0f;
 
-  GPU_material_flag_set(mat, (eGPUMatFlag)flag);
+  GPU_material_flag_set(mat, flag);
 
   return GPU_stack_link(mat,
                         node,
@@ -177,7 +172,7 @@ static void node_shader_update_principled(bNodeTree *ntree, bNode *node)
   const int distribution = node->custom1;
   const int sss_method = node->custom2;
 
-  LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
+  for (bNodeSocket *sock = node->inputs.first; sock; sock = sock->next) {
     if (STREQ(sock->name, "Transmission Roughness")) {
       nodeSetSocketAvailability(ntree, sock, distribution == SHD_GLOSSY_GGX);
     }
@@ -188,22 +183,18 @@ static void node_shader_update_principled(bNodeTree *ntree, bNode *node)
   }
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_principled_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_principled()
+void register_node_type_sh_bsdf_principled(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_principled_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_PRINCIPLED, "Principled BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_principled_in, sh_node_bsdf_principled_out);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  node_type_init(&ntype, file_ns::node_shader_init_principled);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_principled);
-  node_type_update(&ntype, file_ns::node_shader_update_principled);
+  node_type_init(&ntype, node_shader_init_principled);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_principled);
+  node_type_update(&ntype, node_shader_update_principled);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c
index 432e69331e0..ff33b3456db 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_refraction.c
@@ -17,20 +17,22 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_refraction_cc {
+static bNodeSocketTemplate sh_node_bsdf_refraction_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Roughness"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("IOR"), 1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Roughness")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("IOR")).default_value(1.45f).min(0.0f).max(1000.0f);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_refraction_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static void node_shader_init_refraction(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -56,21 +58,17 @@ static int node_shader_gpu_bsdf_refraction(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_refraction", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_refraction_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_refraction()
+void register_node_type_sh_bsdf_refraction(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_refraction_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_REFRACTION, "Refraction BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_refraction_in, sh_node_bsdf_refraction_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_refraction);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_refraction);
+  node_type_init(&ntype, node_shader_init_refraction);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_refraction);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.c
index 8d8e198b7fc..2d04fcee40c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_toon.c
@@ -17,24 +17,22 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_toon_cc {
+static bNodeSocketTemplate sh_node_bsdf_toon_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Size"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Smooth"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Size"))
-      .default_value(0.5f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Smooth")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_toon_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_bsdf_toon(GPUMaterial *mat,
                                      bNode *node,
@@ -51,21 +49,17 @@ static int node_shader_gpu_bsdf_toon(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_toon", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_toon_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_toon()
+void register_node_type_sh_bsdf_toon(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_toon_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_TOON, "Toon BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_bsdf_toon_in, sh_node_bsdf_toon_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_toon);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_toon);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c
index 5633f422fb8..d2e1a276645 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_translucent.c
@@ -17,18 +17,20 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_translucent_cc {
+static bNodeSocketTemplate sh_node_bsdf_translucent_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_translucent_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat,
                                             bNode *node,
@@ -45,20 +47,16 @@ static int node_shader_gpu_bsdf_translucent(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_translucent", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_translucent_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_translucent()
+void register_node_type_sh_bsdf_translucent(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_translucent_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSLUCENT, "Translucent BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_translucent);
+  node_type_socket_templates(&ntype, sh_node_bsdf_translucent_in, sh_node_bsdf_translucent_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_translucent);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c
index 1c8e77781fe..45f8ebf1d52 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_transparent.c
@@ -17,17 +17,19 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_transparent_cc {
+static bNodeSocketTemplate sh_node_bsdf_transparent_in[] = {
+    {SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_transparent_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat,
                                             bNode *node,
@@ -38,20 +40,16 @@ static int node_shader_gpu_bsdf_transparent(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_transparent", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_transparent_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_transparent()
+void register_node_type_sh_bsdf_transparent(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_transparent_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_TRANSPARENT, "Transparent BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_transparent);
+  node_type_socket_templates(&ntype, sh_node_bsdf_transparent_in, sh_node_bsdf_transparent_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_transparent);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.cc b/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c
index 6762b52c959..59e8bbd3c63 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bsdf_velvet.c
@@ -17,23 +17,21 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_bsdf_velvet_cc {
+static bNodeSocketTemplate sh_node_bsdf_velvet_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Sigma"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Sigma"))
-      .default_value(1.0f)
-      .min(0.0f)
-      .max(1.0f)
-      .subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSDF"));
-}
+static bNodeSocketTemplate sh_node_bsdf_velvet_out[] = {
+    {SOCK_SHADER, N_("BSDF")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat,
                                        bNode *node,
@@ -50,20 +48,16 @@ static int node_shader_gpu_bsdf_velvet(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_bsdf_velvet", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_bsdf_velvet_cc
-
 /* node type definition */
-void register_node_type_sh_bsdf_velvet()
+void register_node_type_sh_bsdf_velvet(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bsdf_velvet_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BSDF_VELVET, "Velvet BSDF", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_bsdf_velvet);
+  node_type_socket_templates(&ntype, sh_node_bsdf_velvet_in, sh_node_bsdf_velvet_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_bsdf_velvet);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_bump.cc b/source/blender/nodes/shader/nodes/node_shader_bump.c
index 40871c9ab32..7444ea3952a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_bump.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_bump.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** BUMP ******************** */
-
-namespace blender::nodes::node_shader_bump_cc {
-
 /* clang-format off */
 static bNodeSocketTemplate sh_node_bump_in[] = {
     {SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@@ -57,19 +54,15 @@ static int gpu_shader_bump(GPUMaterial *mat,
       mat, node, "node_bump", in, out, GPU_builtin(GPU_VIEW_POSITION), GPU_constant(&invert));
 }
 
-}  // namespace blender::nodes::node_shader_bump_cc
-
 /* node type definition */
-void register_node_type_sh_bump()
+void register_node_type_sh_bump(void)
 {
-  namespace file_ns = blender::nodes::node_shader_bump_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_BUMP, "Bump", NODE_CLASS_OP_VECTOR, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_bump_in, file_ns::sh_node_bump_out);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::gpu_shader_bump);
+  node_type_socket_templates(&ntype, sh_node_bump_in, sh_node_bump_out);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, gpu_shader_bump);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_camera.cc b/source/blender/nodes/shader/nodes/node_shader_camera.c
index d9349ccf86c..5148104700a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_camera.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_camera.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** CAMERA INFO  ******************** */
-
-namespace blender::nodes::node_shader_camera_cc {
-
 static bNodeSocketTemplate sh_node_camera_out[] = {
     {SOCK_VECTOR, N_("View Vector")},
     {SOCK_FLOAT, N_("View Z Depth")},
@@ -47,18 +44,14 @@ static int gpu_shader_camera(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "camera", in, out, viewvec);
 }
 
-}  // namespace blender::nodes::node_shader_camera_cc
-
-void register_node_type_sh_camera()
+void register_node_type_sh_camera(void)
 {
-  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, nullptr, file_ns::sh_node_camera_out);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::gpu_shader_camera);
+  node_type_socket_templates(&ntype, NULL, sh_node_camera_out);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, gpu_shader_camera);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_clamp.cc b/source/blender/nodes/shader/nodes/node_shader_clamp.cc
index 50577749977..57a992a4275 100644
--- a/source/blender/nodes/shader/nodes/node_shader_clamp.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_clamp.cc
@@ -21,9 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_clamp_cc {
+namespace blender::nodes {
 
 static void sh_node_clamp_declare(NodeDeclarationBuilder &b)
 {
@@ -34,6 +34,8 @@ static void sh_node_clamp_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Result"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_clamp(bNodeTree *UNUSED(ntree), bNode *node)
 {
   node->custom1 = NODE_CLAMP_MINMAX; /* clamp type */
@@ -73,19 +75,15 @@ static void sh_node_clamp_build_multi_function(blender::nodes::NodeMultiFunction
   }
 }
 
-}  // namespace blender::nodes::node_shader_clamp_cc
-
-void register_node_type_sh_clamp()
+void register_node_type_sh_clamp(void)
 {
-  namespace file_ns = blender::nodes::node_shader_clamp_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_CLAMP, "Clamp", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_clamp_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_clamp);
-  node_type_gpu(&ntype, file_ns::gpu_shader_clamp);
-  ntype.build_multi_function = file_ns::sh_node_clamp_build_multi_function;
+  ntype.declare = blender::nodes::sh_node_clamp_declare;
+  node_type_init(&ntype, node_shader_init_clamp);
+  node_type_gpu(&ntype, gpu_shader_clamp);
+  ntype.build_multi_function = sh_node_clamp_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_combine_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_combine_rgb.cc
deleted file mode 100644
index f5d401a5044..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_combine_rgb.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2006 Blender Foundation.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup shdnodes
- */
-
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_combine_rgb_cc {
-
-static void sh_node_combrgb_declare(NodeDeclarationBuilder &b)
-{
-  b.is_function_node();
-  b.add_input<decl::Float>(N_("R")).min(0.0f).max(1.0f);
-  b.add_input<decl::Float>(N_("G")).min(0.0f).max(1.0f);
-  b.add_input<decl::Float>(N_("B")).min(0.0f).max(1.0f);
-  b.add_output<decl::Color>(N_("Image"));
-};
-
-static void node_shader_exec_combrgb(void *UNUSED(data),
-                                     int UNUSED(thread),
-                                     bNode *UNUSED(node),
-                                     bNodeExecData *UNUSED(execdata),
-                                     bNodeStack **in,
-                                     bNodeStack **out)
-{
-  float r, g, b;
-  nodestack_get_vec(&r, SOCK_FLOAT, in[0]);
-  nodestack_get_vec(&g, SOCK_FLOAT, in[1]);
-  nodestack_get_vec(&b, SOCK_FLOAT, in[2]);
-
-  out[0]->vec[0] = r;
-  out[0]->vec[1] = g;
-  out[0]->vec[2] = b;
-}
-
-static int gpu_shader_combrgb(GPUMaterial *mat,
-                              bNode *node,
-                              bNodeExecData *UNUSED(execdata),
-                              GPUNodeStack *in,
-                              GPUNodeStack *out)
-{
-  return GPU_stack_link(mat, node, "combine_rgb", in, out);
-}
-
-static void sh_node_combrgb_build_multi_function(blender::nodes::NodeMultiFunctionBuilder &builder)
-{
-  static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, blender::ColorGeometry4f> fn{
-      "Combine RGB",
-      [](float r, float g, float b) { return blender::ColorGeometry4f(r, g, b, 1.0f); }};
-  builder.set_matching_fn(fn);
-}
-
-}  // namespace blender::nodes::node_shader_combine_rgb_cc
-
-void register_node_type_sh_combrgb()
-{
-  namespace file_ns = blender::nodes::node_shader_combine_rgb_cc;
-
-  static bNodeType ntype;
-
-  sh_fn_node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_combrgb_declare;
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_combrgb);
-  node_type_gpu(&ntype, file_ns::gpu_shader_combrgb);
-  ntype.build_multi_function = file_ns::sh_node_combrgb_build_multi_function;
-
-  nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_combine_xyz.cc b/source/blender/nodes/shader/nodes/node_shader_combine_xyz.cc
deleted file mode 100644
index ff5b333a459..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_combine_xyz.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2014 Blender Foundation.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup shdnodes
- */
-
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_combine_xyz_cc {
-
-static void sh_node_combxyz_declare(NodeDeclarationBuilder &b)
-{
-  b.is_function_node();
-  b.add_input<decl::Float>(N_("X")).min(-10000.0f).max(10000.0f);
-  b.add_input<decl::Float>(N_("Y")).min(-10000.0f).max(10000.0f);
-  b.add_input<decl::Float>(N_("Z")).min(-10000.0f).max(10000.0f);
-  b.add_output<decl::Vector>(N_("Vector"));
-};
-
-static int gpu_shader_combxyz(GPUMaterial *mat,
-                              bNode *node,
-                              bNodeExecData *UNUSED(execdata),
-                              GPUNodeStack *in,
-                              GPUNodeStack *out)
-{
-  return GPU_stack_link(mat, node, "combine_xyz", in, out);
-}
-
-static void sh_node_combxyz_build_multi_function(blender::nodes::NodeMultiFunctionBuilder &builder)
-{
-  static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, blender::float3> fn{
-      "Combine Vector", [](float x, float y, float z) { return blender::float3(x, y, z); }};
-  builder.set_matching_fn(fn);
-}
-
-}  // namespace blender::nodes::node_shader_combine_xyz_cc
-
-void register_node_type_sh_combxyz()
-{
-  namespace file_ns = blender::nodes::node_shader_combine_xyz_cc;
-
-  static bNodeType ntype;
-
-  sh_fn_node_type_base(&ntype, SH_NODE_COMBXYZ, "Combine XYZ", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_combxyz_declare;
-  node_type_gpu(&ntype, file_ns::gpu_shader_combxyz);
-  ntype.build_multi_function = file_ns::sh_node_combxyz_build_multi_function;
-
-  nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_common.cc b/source/blender/nodes/shader/nodes/node_shader_common.c
index 156fe437e1a..07ae412d384 100644
--- a/source/blender/nodes/shader/nodes/node_shader_common.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_common.c
@@ -31,7 +31,7 @@
 #include "NOD_common.h"
 #include "node_common.h"
 #include "node_exec.h"
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 #include "RNA_access.h"
 
@@ -55,7 +55,7 @@ static void move_stack(bNodeStack *to, bNodeStack *from)
     to->datatype = from->datatype;
     to->is_copy = from->is_copy;
 
-    from->data = nullptr;
+    from->data = NULL;
     from->is_copy = 0;
   }
 }
@@ -68,7 +68,7 @@ static void *group_initexec(bNodeExecContext *context, bNode *node, bNodeInstanc
   bNodeTreeExec *exec;
 
   if (!ngroup) {
-    return nullptr;
+    return NULL;
   }
 
   /* initialize the internal node tree execution */
@@ -91,12 +91,15 @@ static void group_freeexec(void *nodedata)
 static void group_copy_inputs(bNode *gnode, bNodeStack **in, bNodeStack *gstack)
 {
   bNodeTree *ngroup = (bNodeTree *)gnode->id;
+  bNode *node;
+  bNodeSocket *sock;
+  bNodeStack *ns;
+  int a;
 
-  LISTBASE_FOREACH (bNode *, node, &ngroup->nodes) {
+  for (node = ngroup->nodes.first; node; node = node->next) {
     if (node->type == NODE_GROUP_INPUT) {
-      int a;
-      LISTBASE_FOREACH_INDEX (bNodeSocket *, sock, &node->outputs, a) {
-        bNodeStack *ns = node_get_socket_stack(gstack, sock);
+      for (sock = node->outputs.first, a = 0; sock; sock = sock->next, a++) {
+        ns = node_get_socket_stack(gstack, sock);
         if (ns) {
           copy_stack(ns, in[a]);
         }
@@ -110,12 +113,15 @@ static void group_copy_inputs(bNode *gnode, bNodeStack **in, bNodeStack *gstack)
 static void group_move_outputs(bNode *gnode, bNodeStack **out, bNodeStack *gstack)
 {
   bNodeTree *ngroup = (bNodeTree *)gnode->id;
+  bNode *node;
+  bNodeSocket *sock;
+  bNodeStack *ns;
+  int a;
 
-  LISTBASE_FOREACH (bNode *, node, &ngroup->nodes) {
+  for (node = ngroup->nodes.first; node; node = node->next) {
     if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) {
-      int a;
-      LISTBASE_FOREACH_INDEX (bNodeSocket *, sock, &node->inputs, a) {
-        bNodeStack *ns = node_get_socket_stack(gstack, sock);
+      for (sock = node->inputs.first, a = 0; sock; sock = sock->next, a++) {
+        ns = node_get_socket_stack(gstack, sock);
         if (ns) {
           move_stack(out[a], ns);
         }
@@ -132,7 +138,7 @@ static void group_execute(void *data,
                           struct bNodeStack **in,
                           struct bNodeStack **out)
 {
-  bNodeTreeExec *exec = (bNodeTreeExec *)execdata->data;
+  bNodeTreeExec *exec = execdata->data;
   bNodeThreadStack *nts;
 
   if (!exec) {
@@ -143,7 +149,8 @@ static void group_execute(void *data,
    * it's stupid, but just makes it work. compo redesign will do this better.
    */
   {
-    LISTBASE_FOREACH (bNode *, inode, &exec->nodetree->nodes) {
+    bNode *inode;
+    for (inode = exec->nodetree->nodes.first; inode; inode = inode->next) {
       inode->need_exec = 1;
     }
   }
@@ -160,12 +167,15 @@ static void group_execute(void *data,
 static void group_gpu_copy_inputs(bNode *gnode, GPUNodeStack *in, bNodeStack *gstack)
 {
   bNodeTree *ngroup = (bNodeTree *)gnode->id;
+  bNode *node;
+  bNodeSocket *sock;
+  bNodeStack *ns;
+  int a;
 
-  LISTBASE_FOREACH (bNode *, node, &ngroup->nodes) {
+  for (node = ngroup->nodes.first; node; node = node->next) {
     if (node->type == NODE_GROUP_INPUT) {
-      int a;
-      LISTBASE_FOREACH_INDEX (bNodeSocket *, sock, &node->outputs, a) {
-        bNodeStack *ns = node_get_socket_stack(gstack, sock);
+      for (sock = node->outputs.first, a = 0; sock; sock = sock->next, a++) {
+        ns = node_get_socket_stack(gstack, sock);
         if (ns) {
           /* convert the external gpu stack back to internal node stack data */
           node_data_from_gpu_stack(ns, &in[a]);
@@ -180,12 +190,15 @@ static void group_gpu_copy_inputs(bNode *gnode, GPUNodeStack *in, bNodeStack *gs
 static void group_gpu_move_outputs(bNode *gnode, GPUNodeStack *out, bNodeStack *gstack)
 {
   bNodeTree *ngroup = (bNodeTree *)gnode->id;
+  bNode *node;
+  bNodeSocket *sock;
+  bNodeStack *ns;
+  int a;
 
-  LISTBASE_FOREACH (bNode *, node, &ngroup->nodes) {
+  for (node = ngroup->nodes.first; node; node = node->next) {
     if (node->type == NODE_GROUP_OUTPUT && (node->flag & NODE_DO_OUTPUT)) {
-      int a;
-      LISTBASE_FOREACH_INDEX (bNodeSocket *, sock, &node->inputs, a) {
-        bNodeStack *ns = node_get_socket_stack(gstack, sock);
+      for (sock = node->inputs.first, a = 0; sock; sock = sock->next, a++) {
+        ns = node_get_socket_stack(gstack, sock);
         if (ns) {
           /* convert the node stack data result back to gpu stack */
           node_gpu_stack_from_data(&out[a], sock->type, ns);
@@ -199,20 +212,20 @@ static void group_gpu_move_outputs(bNode *gnode, GPUNodeStack *out, bNodeStack *
 static int gpu_group_execute(
     GPUMaterial *mat, bNode *node, bNodeExecData *execdata, GPUNodeStack *in, GPUNodeStack *out)
 {
-  bNodeTreeExec *exec = (bNodeTreeExec *)execdata->data;
+  bNodeTreeExec *exec = execdata->data;
 
   if (!node->id) {
     return 0;
   }
 
   group_gpu_copy_inputs(node, in, exec->stack);
-  ntreeExecGPUNodes(exec, mat, nullptr);
+  ntreeExecGPUNodes(exec, mat, NULL);
   group_gpu_move_outputs(node, out, exec->stack);
 
   return 1;
 }
 
-void register_node_type_sh_group()
+void register_node_type_sh_group(void)
 {
   static bNodeType ntype;
 
@@ -225,10 +238,10 @@ void register_node_type_sh_group()
   ntype.poll_instance = node_group_poll_instance;
   ntype.insert_link = node_insert_link_default;
   ntype.rna_ext.srna = RNA_struct_find("ShaderNodeGroup");
-  BLI_assert(ntype.rna_ext.srna != nullptr);
+  BLI_assert(ntype.rna_ext.srna != NULL);
   RNA_struct_blender_type_set(ntype.rna_ext.srna, &ntype);
 
-  node_type_socket_templates(&ntype, nullptr, nullptr);
+  node_type_socket_templates(&ntype, NULL, NULL);
   node_type_size(&ntype, 140, 60, 400);
   node_type_label(&ntype, node_group_label);
   node_type_group_update(&ntype, node_group_update);
@@ -241,10 +254,10 @@ void register_node_type_sh_group()
 void register_node_type_sh_custom_group(bNodeType *ntype)
 {
   /* These methods can be overridden but need a default implementation otherwise. */
-  if (ntype->poll == nullptr) {
+  if (ntype->poll == NULL) {
     ntype->poll = sh_node_poll_default;
   }
-  if (ntype->insert_link == nullptr) {
+  if (ntype->insert_link == NULL) {
     ntype->insert_link = node_insert_link_default;
   }
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.cc b/source/blender/nodes/shader/nodes/node_shader_curves.cc
index 55bf75217c4..7ce5150bf85 100644
--- a/source/blender/nodes/shader/nodes/node_shader_curves.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_curves.cc
@@ -21,9 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_curve_vec_cc {
+namespace blender::nodes {
 
 static void sh_node_curve_vec_declare(NodeDeclarationBuilder &b)
 {
@@ -33,6 +33,8 @@ static void sh_node_curve_vec_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Vector>(N_("Vector"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_exec_curve_vec(void *UNUSED(data),
                                        int UNUSED(thread),
                                        bNode *node,
@@ -150,29 +152,25 @@ static void sh_node_curve_vec_build_multi_function(
   builder.construct_and_set_matching_fn<CurveVecFunction>(*cumap);
 }
 
-}  // namespace blender::nodes::node_shader_curve_vec_cc
-
-void register_node_type_sh_curve_vec()
+void register_node_type_sh_curve_vec(void)
 {
-  namespace file_ns = blender::nodes::node_shader_curve_vec_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, 0);
-  ntype.declare = file_ns::sh_node_curve_vec_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_curve_vec);
+  ntype.declare = blender::nodes::sh_node_curve_vec_declare;
+  node_type_init(&ntype, node_shader_init_curve_vec);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
   node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
-  node_type_exec(&ntype, node_initexec_curves, nullptr, file_ns::node_shader_exec_curve_vec);
-  node_type_gpu(&ntype, file_ns::gpu_shader_curve_vec);
-  ntype.build_multi_function = file_ns::sh_node_curve_vec_build_multi_function;
+  node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_vec);
+  node_type_gpu(&ntype, gpu_shader_curve_vec);
+  ntype.build_multi_function = sh_node_curve_vec_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
 
 /* **************** CURVE RGB  ******************** */
 
-namespace blender::nodes::node_shader_curve_rgb_cc {
+namespace blender::nodes {
 
 static void sh_node_curve_rgb_declare(NodeDeclarationBuilder &b)
 {
@@ -182,6 +180,8 @@ static void sh_node_curve_rgb_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Color>(N_("Color"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_exec_curve_rgb(void *UNUSED(data),
                                        int UNUSED(thread),
                                        bNode *node,
@@ -329,29 +329,25 @@ static void sh_node_curve_rgb_build_multi_function(
   builder.construct_and_set_matching_fn<CurveRGBFunction>(*cumap);
 }
 
-}  // namespace blender::nodes::node_shader_curve_rgb_cc
-
-void register_node_type_sh_curve_rgb()
+void register_node_type_sh_curve_rgb(void)
 {
-  namespace file_ns = blender::nodes::node_shader_curve_rgb_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, 0);
-  ntype.declare = file_ns::sh_node_curve_rgb_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_curve_rgb);
+  ntype.declare = blender::nodes::sh_node_curve_rgb_declare;
+  node_type_init(&ntype, node_shader_init_curve_rgb);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
   node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
-  node_type_exec(&ntype, node_initexec_curves, nullptr, file_ns::node_shader_exec_curve_rgb);
-  node_type_gpu(&ntype, file_ns::gpu_shader_curve_rgb);
-  ntype.build_multi_function = file_ns::sh_node_curve_rgb_build_multi_function;
+  node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_rgb);
+  node_type_gpu(&ntype, gpu_shader_curve_rgb);
+  ntype.build_multi_function = sh_node_curve_rgb_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
 
 /* **************** CURVE FLOAT  ******************** */
 
-namespace blender::nodes::node_shader_curve_float_cc {
+namespace blender::nodes {
 
 static void sh_node_curve_float_declare(NodeDeclarationBuilder &b)
 {
@@ -365,6 +361,8 @@ static void sh_node_curve_float_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Value"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_exec_curve_float(void *UNUSED(data),
                                          int UNUSED(thread),
                                          bNode *node,
@@ -475,22 +473,18 @@ static void sh_node_curve_float_build_multi_function(
   builder.construct_and_set_matching_fn<CurveFloatFunction>(*cumap);
 }
 
-}  // namespace blender::nodes::node_shader_curve_float_cc
-
-void register_node_type_sh_curve_float()
+void register_node_type_sh_curve_float(void)
 {
-  namespace file_ns = blender::nodes::node_shader_curve_float_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_CURVE_FLOAT, "Float Curve", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_curve_float_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_curve_float);
+  ntype.declare = blender::nodes::sh_node_curve_float_declare;
+  node_type_init(&ntype, node_shader_init_curve_float);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
   node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
-  node_type_exec(&ntype, node_initexec_curves, nullptr, file_ns::node_shader_exec_curve_float);
-  node_type_gpu(&ntype, file_ns::gpu_shader_curve_float);
-  ntype.build_multi_function = file_ns::sh_node_curve_float_build_multi_function;
+  node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_float);
+  node_type_gpu(&ntype, gpu_shader_curve_float);
+  ntype.build_multi_function = sh_node_curve_float_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_displacement.cc b/source/blender/nodes/shader/nodes/node_shader_displacement.c
index 238f2014fa7..e7deef23428 100644
--- a/source/blender/nodes/shader/nodes/node_shader_displacement.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_displacement.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_displacement_cc {
-
 static bNodeSocketTemplate sh_node_displacement_in[] = {
     {SOCK_FLOAT, N_("Height"), 0.00f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
     {SOCK_FLOAT, N_("Midlevel"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@@ -70,21 +68,16 @@ 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 register_node_type_sh_displacement(void)
 {
-  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, file_ns::sh_node_displacement_in, file_ns::sh_node_displacement_out);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_init(&ntype, file_ns::node_shader_init_displacement);
-  node_type_gpu(&ntype, file_ns::gpu_shader_displacement);
+  node_type_socket_templates(&ntype, sh_node_displacement_in, sh_node_displacement_out);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_init(&ntype, node_shader_init_displacement);
+  node_type_gpu(&ntype, gpu_shader_displacement);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc b/source/blender/nodes/shader/nodes/node_shader_eevee_specular.c
index 190ed0c1590..015af19abb2 100644
--- a/source/blender/nodes/shader/nodes/node_shader_eevee_specular.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_eevee_specular.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_eevee_specular_cc {
-
 static bNodeSocketTemplate sh_node_eevee_specular_in[] = {
     {SOCK_RGBA, N_("Base Color"), 0.8f, 0.8f, 0.8f, 1.0f},
     {SOCK_RGBA, N_("Specular"), 0.03f, 0.03f, 0.03f, 1.0f},
@@ -83,26 +81,21 @@ 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, (eGPUMatFlag)(GPU_MATFLAG_DIFFUSE | GPU_MATFLAG_GLOSSY));
+  GPU_material_flag_set(mat, 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 register_node_type_sh_eevee_specular(void)
 {
-  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, file_ns::sh_node_eevee_specular_in, file_ns::sh_node_eevee_specular_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_eevee_specular);
+  node_type_socket_templates(&ntype, sh_node_eevee_specular_in, sh_node_eevee_specular_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_eevee_specular);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_emission.cc b/source/blender/nodes/shader/nodes/node_shader_emission.c
index afd250b1a9a..13f040fca48 100644
--- a/source/blender/nodes/shader/nodes/node_shader_emission.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_emission.c
@@ -17,18 +17,20 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_emission_cc {
+static bNodeSocketTemplate sh_node_emission_in[] = {
+    {SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
-  b.add_input<decl::Float>(N_("Strength")).default_value(1.0f).min(0.0f).max(1000000.0f);
-  b.add_output<decl::Shader>(N_("Emission"));
-}
+static bNodeSocketTemplate sh_node_emission_out[] = {
+    {SOCK_SHADER, N_("Emission")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_emission(GPUMaterial *mat,
                                     bNode *node,
@@ -39,20 +41,16 @@ 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 register_node_type_sh_emission(void)
 {
-  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);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_emission);
+  node_type_socket_templates(&ntype, sh_node_emission_in, sh_node_emission_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_emission);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_fresnel.cc b/source/blender/nodes/shader/nodes/node_shader_fresnel.c
index 92688fbabea..0af4e4ff5fb 100644
--- a/source/blender/nodes/shader/nodes/node_shader_fresnel.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_fresnel.c
@@ -17,12 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** Fresnel ******************** */
-
-namespace blender::nodes::node_shader_fresnel_cc {
-
 static bNodeSocketTemplate sh_node_fresnel_in[] = {
     {SOCK_FLOAT, N_("IOR"), 1.45f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@@ -60,21 +57,17 @@ 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 register_node_type_sh_fresnel(void)
 {
-  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, file_ns::sh_node_fresnel_in, file_ns::sh_node_fresnel_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_fresnel);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_fresnel);
+  node_type_socket_templates(&ntype, sh_node_fresnel_in, sh_node_fresnel_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_fresnel);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_fresnel);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_gamma.cc b/source/blender/nodes/shader/nodes/node_shader_gamma.c
index ecac578701a..b48838e5f56 100644
--- a/source/blender/nodes/shader/nodes/node_shader_gamma.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_gamma.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** Gamma Tools  ******************** */
 
-namespace blender::nodes::node_shader_gamma_cc {
-
 static bNodeSocketTemplate sh_node_gamma_in[] = {
     {SOCK_RGBA, N_("Color"), 1.0f, 1.0f, 1.0f, 1.0f},
     {SOCK_FLOAT, N_("Gamma"), 1.0f, 0.0f, 0.0f, 0.0f, 0.001f, 10.0f, PROP_UNSIGNED},
@@ -60,20 +58,16 @@ static int node_shader_gpu_gamma(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_gamma", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_gamma_cc
-
-void register_node_type_sh_gamma()
+void register_node_type_sh_gamma(void)
 {
-  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, file_ns::sh_node_gamma_in, file_ns::sh_node_gamma_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_gamma);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_gamma);
+  node_type_socket_templates(&ntype, sh_node_gamma_in, sh_node_gamma_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_gamma);
+  node_type_gpu(&ntype, node_shader_gpu_gamma);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_geometry.cc b/source/blender/nodes/shader/nodes/node_shader_geometry.c
index 22c865cf82c..f66633e64c8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_geometry.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_geometry.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_geometry_cc {
-
 static bNodeSocketTemplate sh_node_geometry_out[] = {
     {SOCK_VECTOR, N_("Position"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -81,27 +79,23 @@ static int node_shader_gpu_geometry(GPUMaterial *mat,
                out[i].link,
                out[i].link,
                &out[i].link,
-               nullptr);
+               NULL);
     }
   }
 
   return success;
 }
 
-}  // namespace blender::nodes::node_shader_geometry_cc
-
 /* node type definition */
-void register_node_type_sh_geometry()
+void register_node_type_sh_geometry(void)
 {
-  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, nullptr, file_ns::sh_node_geometry_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_geometry);
+  node_type_socket_templates(&ntype, NULL, sh_node_geometry_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_geometry);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_hair_info.cc b/source/blender/nodes/shader/nodes/node_shader_hair_info.c
index 76d5553c0d0..c721fb9c77a 100644
--- a/source/blender/nodes/shader/nodes/node_shader_hair_info.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_hair_info.c
@@ -17,9 +17,7 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_hair_info_cc {
+#include "../node_shader_util.h"
 
 static bNodeSocketTemplate outputs[] = {
     {SOCK_FLOAT, N_("Is Strand"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -45,20 +43,16 @@ static int node_shader_gpu_hair_info(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_hair_info", in, out, length_link);
 }
 
-}  // namespace blender::nodes::node_shader_hair_info_cc
-
 /* node type definition */
-void register_node_type_sh_hair_info()
+void register_node_type_sh_hair_info(void)
 {
-  namespace file_ns = blender::nodes::node_shader_hair_info_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, nullptr, file_ns::outputs);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_hair_info);
+  node_type_socket_templates(&ntype, NULL, outputs);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_hair_info);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_holdout.cc b/source/blender/nodes/shader/nodes/node_shader_holdout.c
index 02bfda39d78..b58f86c1fc0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_holdout.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_holdout.c
@@ -17,16 +17,18 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_holdout_cc {
+static bNodeSocketTemplate sh_node_holdout_in[] = {
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_output<decl::Shader>(N_("Holdout"));
-}
+static bNodeSocketTemplate sh_node_holdout_out[] = {
+    {SOCK_SHADER, N_("Holdout")},
+    {-1, ""},
+};
 
 static int gpu_shader_rgb(GPUMaterial *mat,
                           bNode *node,
@@ -37,20 +39,16 @@ static int gpu_shader_rgb(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_holdout", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_holdout_cc
-
 /* node type definition */
-void register_node_type_sh_holdout()
+void register_node_type_sh_holdout(void)
 {
-  namespace file_ns = blender::nodes::node_shader_holdout_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_HOLDOUT, "Holdout", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::gpu_shader_rgb);
+  node_type_socket_templates(&ntype, sh_node_holdout_in, sh_node_holdout_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, gpu_shader_rgb);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c
index 101166b1e6d..50eb5bf32c9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_hueSatVal.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_hueSatVal.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** Hue Saturation ******************** */
-
-namespace blender::nodes::node_shader_hueSatVal_cc {
-
 static bNodeSocketTemplate sh_node_hue_sat_in[] = {
     {SOCK_FLOAT, N_("Hue"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE},
     {SOCK_FLOAT, N_("Saturation"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f, PROP_NONE},
@@ -88,19 +85,15 @@ static int gpu_shader_hue_sat(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "hue_sat", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_hueSatVal_cc
-
-void register_node_type_sh_hue_sat()
+void register_node_type_sh_hue_sat(void)
 {
-  namespace file_ns = blender::nodes::node_shader_hueSatVal_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_hue_sat_in, file_ns::sh_node_hue_sat_out);
+  node_type_socket_templates(&ntype, sh_node_hue_sat_in, sh_node_hue_sat_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_hue_sat);
-  node_type_gpu(&ntype, file_ns::gpu_shader_hue_sat);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_hue_sat);
+  node_type_gpu(&ntype, gpu_shader_hue_sat);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_ies_light.cc b/source/blender/nodes/shader/nodes/node_shader_ies_light.c
index 9bf402d055c..9cc5fd46181 100644
--- a/source/blender/nodes/shader/nodes/node_shader_ies_light.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_ies_light.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** IES Light ******************** */
 
-namespace blender::nodes::node_shader_ies_light_cc {
-
 static bNodeSocketTemplate sh_node_tex_ies_in[] = {
     {SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
     {SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f, PROP_NONE},
@@ -36,23 +34,18 @@ static bNodeSocketTemplate sh_node_tex_ies_out[] = {
 
 static void node_shader_init_tex_ies(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderTexIES *tex = (NodeShaderTexIES *)MEM_callocN(sizeof(NodeShaderTexIES),
-                                                          "NodeShaderIESLight");
+  NodeShaderTexIES *tex = MEM_callocN(sizeof(NodeShaderTexIES), "NodeShaderIESLight");
   node->storage = tex;
 }
 
-}  // namespace blender::nodes::node_shader_ies_light_cc
-
 /* node type definition */
-void register_node_type_sh_tex_ies()
+void register_node_type_sh_tex_ies(void)
 {
-  namespace file_ns = blender::nodes::node_shader_ies_light_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TEX_IES, "IES Texture", NODE_CLASS_TEXTURE, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_tex_ies_in, file_ns::sh_node_tex_ies_out);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_ies);
+  node_type_socket_templates(&ntype, sh_node_tex_ies_in, sh_node_tex_ies_out);
+  node_type_init(&ntype, node_shader_init_tex_ies);
   node_type_storage(
       &ntype, "NodeShaderTexIES", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_invert.cc b/source/blender/nodes/shader/nodes/node_shader_invert.c
index e3981eab88c..0d6709a1968 100644
--- a/source/blender/nodes/shader/nodes/node_shader_invert.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_invert.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** INVERT ******************** */
-
-namespace blender::nodes::node_shader_invert_cc {
-
 static bNodeSocketTemplate sh_node_invert_in[] = {
     {SOCK_FLOAT, N_("Fac"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
     {SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 1.0f},
@@ -68,18 +65,14 @@ static int gpu_shader_invert(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "invert", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_invert_cc
-
-void register_node_type_sh_invert()
+void register_node_type_sh_invert(void)
 {
-  namespace file_ns = blender::nodes::node_shader_invert_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_invert_in, file_ns::sh_node_invert_out);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_invert);
-  node_type_gpu(&ntype, file_ns::gpu_shader_invert);
+  node_type_socket_templates(&ntype, sh_node_invert_in, sh_node_invert_out);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_invert);
+  node_type_gpu(&ntype, gpu_shader_invert);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_layer_weight.cc b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c
index b87f25eb483..c26b40b081c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_layer_weight.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_layer_weight.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** Layer Weight ******************** */
 
-namespace blender::nodes::node_shader_layer_weight_cc {
-
 static bNodeSocketTemplate sh_node_layer_weight_in[] = {
     {SOCK_FLOAT, N_("Blend"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
@@ -61,22 +59,17 @@ static void node_shader_exec_layer_weight(void *UNUSED(data),
 {
 }
 
-}  // namespace blender::nodes::node_shader_layer_weight_cc
-
 /* node type definition */
-void register_node_type_sh_layer_weight()
+void register_node_type_sh_layer_weight(void)
 {
-  namespace file_ns = blender::nodes::node_shader_layer_weight_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_LAYER_WEIGHT, "Layer Weight", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(
-      &ntype, file_ns::sh_node_layer_weight_in, file_ns::sh_node_layer_weight_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_layer_weight);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_layer_weight);
+  node_type_socket_templates(&ntype, sh_node_layer_weight_in, sh_node_layer_weight_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_layer_weight);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_layer_weight);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_light_falloff.cc b/source/blender/nodes/shader/nodes/node_shader_light_falloff.c
index 7568505b9f1..22172221f77 100644
--- a/source/blender/nodes/shader/nodes/node_shader_light_falloff.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_light_falloff.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** INPUT ********************* */
 
-namespace blender::nodes::node_shader_light_falloff_cc {
-
 static bNodeSocketTemplate sh_node_light_falloff_in[] = {
     {SOCK_FLOAT, N_("Strength"), 100.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000000.0f},
     {SOCK_FLOAT, N_("Smooth"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@@ -47,22 +45,17 @@ static int node_shader_gpu_light_falloff(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_light_falloff", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_light_falloff_cc
-
 /* node type definition */
-void register_node_type_sh_light_falloff()
+void register_node_type_sh_light_falloff(void)
 {
-  namespace file_ns = blender::nodes::node_shader_light_falloff_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_LIGHT_FALLOFF, "Light Falloff", NODE_CLASS_OP_COLOR, 0);
-  node_type_socket_templates(
-      &ntype, file_ns::sh_node_light_falloff_in, file_ns::sh_node_light_falloff_out);
+  node_type_socket_templates(&ntype, sh_node_light_falloff_in, sh_node_light_falloff_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_light_falloff);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_light_falloff);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_light_path.cc b/source/blender/nodes/shader/nodes/node_shader_light_path.c
index 5e3f316ad7a..45ad2133ee8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_light_path.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_light_path.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_light_path_cc {
-
 static bNodeSocketTemplate sh_node_light_path_out[] = {
     {SOCK_FLOAT, N_("Is Camera Ray"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_FLOAT, N_("Is Shadow Ray"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -49,20 +47,16 @@ static int node_shader_gpu_light_path(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_light_path", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_light_path_cc
-
 /* node type definition */
-void register_node_type_sh_light_path()
+void register_node_type_sh_light_path(void)
 {
-  namespace file_ns = blender::nodes::node_shader_light_path_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_LIGHT_PATH, "Light Path", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_light_path_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_light_path);
+  node_type_socket_templates(&ntype, NULL, sh_node_light_path_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_light_path);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_map_range.cc b/source/blender/nodes/shader/nodes/node_shader_map_range.cc
index f8fcd15a1c9..e55963eb500 100644
--- a/source/blender/nodes/shader/nodes/node_shader_map_range.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_map_range.cc
@@ -21,11 +21,11 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 #include "BLI_math_base_safe.h"
 
-namespace blender::nodes::node_shader_map_range_cc {
+namespace blender::nodes {
 
 static void sh_node_map_range_declare(NodeDeclarationBuilder &b)
 {
@@ -39,6 +39,8 @@ static void sh_node_map_range_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Result"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_update_map_range(bNodeTree *ntree, bNode *node)
 {
   bNodeSocket *sockSteps = nodeFindSocket(node, SOCK_IN, "Steps");
@@ -305,20 +307,16 @@ static void sh_node_map_range_build_multi_function(
   }
 }
 
-}  // namespace blender::nodes::node_shader_map_range_cc
-
-void register_node_type_sh_map_range()
+void register_node_type_sh_map_range(void)
 {
-  namespace file_ns = blender::nodes::node_shader_map_range_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_MAP_RANGE, "Map Range", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_map_range_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_map_range);
-  node_type_update(&ntype, file_ns::node_shader_update_map_range);
-  node_type_gpu(&ntype, file_ns::gpu_shader_map_range);
-  ntype.build_multi_function = file_ns::sh_node_map_range_build_multi_function;
+  ntype.declare = blender::nodes::sh_node_map_range_declare;
+  node_type_init(&ntype, node_shader_init_map_range);
+  node_type_update(&ntype, node_shader_update_map_range);
+  node_type_gpu(&ntype, gpu_shader_map_range);
+  ntype.build_multi_function = sh_node_map_range_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_mapping.cc b/source/blender/nodes/shader/nodes/node_shader_mapping.c
index ef72dc59095..cabfecdb6ee 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mapping.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mapping.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** MAPPING  ******************** */
-
-namespace blender::nodes::node_shader_mapping_cc {
-
 static bNodeSocketTemplate sh_node_mapping_in[] = {
     {SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 1.0f, -FLT_MAX, FLT_MAX, PROP_NONE},
     {SOCK_VECTOR, N_("Location"), 0.0f, 0.0f, 0.0f, 1.0f, -FLT_MAX, FLT_MAX, PROP_TRANSLATION},
@@ -47,10 +44,10 @@ static int gpu_shader_mapping(GPUMaterial *mat,
                               GPUNodeStack *out)
 {
   static const char *names[] = {
-      "mapping_point",
-      "mapping_texture",
-      "mapping_vector",
-      "mapping_normal",
+      [NODE_MAPPING_TYPE_POINT] = "mapping_point",
+      [NODE_MAPPING_TYPE_TEXTURE] = "mapping_texture",
+      [NODE_MAPPING_TYPE_VECTOR] = "mapping_vector",
+      [NODE_MAPPING_TYPE_NORMAL] = "mapping_normal",
   };
 
   if (node->custom1 < ARRAY_SIZE(names) && names[node->custom1]) {
@@ -67,18 +64,14 @@ static void node_shader_update_mapping(bNodeTree *ntree, bNode *node)
       ntree, sock, ELEM(node->custom1, NODE_MAPPING_TYPE_POINT, NODE_MAPPING_TYPE_TEXTURE));
 }
 
-}  // namespace blender::nodes::node_shader_mapping_cc
-
-void register_node_type_sh_mapping()
+void register_node_type_sh_mapping(void)
 {
-  namespace file_ns = blender::nodes::node_shader_mapping_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_MAPPING, "Mapping", NODE_CLASS_OP_VECTOR, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_mapping_in, file_ns::sh_node_mapping_out);
-  node_type_gpu(&ntype, file_ns::gpu_shader_mapping);
-  node_type_update(&ntype, file_ns::node_shader_update_mapping);
+  node_type_socket_templates(&ntype, sh_node_mapping_in, sh_node_mapping_out);
+  node_type_gpu(&ntype, gpu_shader_mapping);
+  node_type_update(&ntype, node_shader_update_mapping);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_math.cc b/source/blender/nodes/shader/nodes/node_shader_math.cc
index 5fca37aecb4..1e94148c5c7 100644
--- a/source/blender/nodes/shader/nodes/node_shader_math.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_math.cc
@@ -21,13 +21,13 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 #include "NOD_math_functions.hh"
 
 /* **************** SCALAR MATH ******************** */
 
-namespace blender::nodes::node_shader_math_cc {
+namespace blender::nodes {
 
 static void sh_node_math_declare(NodeDeclarationBuilder &b)
 {
@@ -44,6 +44,8 @@ static void sh_node_math_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Value"));
 };
 
+}  // namespace blender::nodes
+
 static const char *gpu_shader_get_name(int mode)
 {
   const blender::nodes::FloatMathOperationInfo *info =
@@ -159,20 +161,16 @@ static void sh_node_math_build_multi_function(blender::nodes::NodeMultiFunctionB
   }
 }
 
-}  // namespace blender::nodes::node_shader_math_cc
-
-void register_node_type_sh_math()
+void register_node_type_sh_math(void)
 {
-  namespace file_ns = blender::nodes::node_shader_math_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_MATH, "Math", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_math_declare;
+  ntype.declare = blender::nodes::sh_node_math_declare;
   node_type_label(&ntype, node_math_label);
-  node_type_gpu(&ntype, file_ns::gpu_shader_math);
+  node_type_gpu(&ntype, gpu_shader_math);
   node_type_update(&ntype, node_math_update);
-  ntype.build_multi_function = file_ns::sh_node_math_build_multi_function;
+  ntype.build_multi_function = sh_node_math_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
index 288161d1463..06fafff578e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mix_rgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
@@ -21,9 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_mix_rgb_cc {
+namespace blender::nodes {
 
 static void sh_node_mix_rgb_declare(NodeDeclarationBuilder &b)
 {
@@ -34,6 +34,8 @@ static void sh_node_mix_rgb_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Color>(N_("Color"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_exec_mix_rgb(void *UNUSED(data),
                                      int UNUSED(thread),
                                      bNode *node,
@@ -181,20 +183,16 @@ static void sh_node_mix_rgb_build_multi_function(blender::nodes::NodeMultiFuncti
   builder.construct_and_set_matching_fn<MixRGBFunction>(clamp, mix_type);
 }
 
-}  // namespace blender::nodes::node_shader_mix_rgb_cc
-
-void register_node_type_sh_mix_rgb()
+void register_node_type_sh_mix_rgb(void)
 {
-  namespace file_ns = blender::nodes::node_shader_mix_rgb_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, 0);
-  ntype.declare = file_ns::sh_node_mix_rgb_declare;
+  ntype.declare = blender::nodes::sh_node_mix_rgb_declare;
   node_type_label(&ntype, node_blend_label);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_mix_rgb);
-  node_type_gpu(&ntype, file_ns::gpu_shader_mix_rgb);
-  ntype.build_multi_function = file_ns::sh_node_mix_rgb_build_multi_function;
+  node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_mix_rgb);
+  node_type_gpu(&ntype, gpu_shader_mix_rgb);
+  ntype.build_multi_function = sh_node_mix_rgb_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_mix_shader.cc b/source/blender/nodes/shader/nodes/node_shader_mix_shader.c
index 7254a0b2976..33cbf34543c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mix_shader.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mix_shader.c
@@ -17,19 +17,21 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_mix_shader_cc {
+static bNodeSocketTemplate sh_node_mix_shader_in[] = {
+    {SOCK_FLOAT, N_("Fac"), 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_SHADER, N_("Shader")},
+    {SOCK_SHADER, N_("Shader")},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Float>(N_("Fac")).default_value(0.5f).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Shader>(N_("Shader"));
-  b.add_input<decl::Shader>(N_("Shader"), "Shader_001");
-  b.add_output<decl::Shader>(N_("Shader"));
-}
+static bNodeSocketTemplate sh_node_mix_shader_out[] = {
+    {SOCK_SHADER, N_("Shader")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_mix_shader(GPUMaterial *mat,
                                       bNode *node,
@@ -40,20 +42,16 @@ static int node_shader_gpu_mix_shader(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_mix_shader", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_mix_shader_cc
-
 /* node type definition */
-void register_node_type_sh_mix_shader()
+void register_node_type_sh_mix_shader(void)
 {
-  namespace file_ns = blender::nodes::node_shader_mix_shader_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_MIX_SHADER, "Mix Shader", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_mix_shader);
+  node_type_socket_templates(&ntype, sh_node_mix_shader_in, sh_node_mix_shader_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_mix_shader);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_normal.cc b/source/blender/nodes/shader/nodes/node_shader_normal.c
index 3f8e2e7fc26..83d5abcba67 100644
--- a/source/blender/nodes/shader/nodes/node_shader_normal.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_normal.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** NORMAL  ******************** */
-
-namespace blender::nodes::node_shader_normal_cc {
-
 static bNodeSocketTemplate sh_node_normal_in[] = {
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 1.0f, PROP_DIRECTION},
     {-1, ""},
@@ -67,18 +64,14 @@ static int gpu_shader_normal(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "normal_new_shading", in, out, vec);
 }
 
-}  // namespace blender::nodes::node_shader_normal_cc
-
-void register_node_type_sh_normal()
+void register_node_type_sh_normal(void)
 {
-  namespace file_ns = blender::nodes::node_shader_normal_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_normal_in, file_ns::sh_node_normal_out);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_normal);
-  node_type_gpu(&ntype, file_ns::gpu_shader_normal);
+  node_type_socket_templates(&ntype, sh_node_normal_in, sh_node_normal_out);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_normal);
+  node_type_gpu(&ntype, gpu_shader_normal);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_normal_map.cc b/source/blender/nodes/shader/nodes/node_shader_normal_map.c
index ec77fcfeefe..493acb06963 100644
--- a/source/blender/nodes/shader/nodes/node_shader_normal_map.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_normal_map.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_normal_map_cc {
-
 static bNodeSocketTemplate sh_node_normal_map_in[] = {
     {SOCK_FLOAT, N_("Strength"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 10.0f},
     {SOCK_RGBA, N_("Color"), 0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 1.0f},
@@ -36,8 +34,7 @@ static bNodeSocketTemplate sh_node_normal_map_out[] = {
 
 static void node_shader_init_normal_map(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderNormalMap *attr = (NodeShaderNormalMap *)MEM_callocN(sizeof(NodeShaderNormalMap),
-                                                                 "NodeShaderNormalMap");
+  NodeShaderNormalMap *attr = MEM_callocN(sizeof(NodeShaderNormalMap), "NodeShaderNormalMap");
   node->storage = attr;
 }
 
@@ -56,15 +53,15 @@ static int gpu_shader_normal_map(GPUMaterial *mat,
                                  GPUNodeStack *in,
                                  GPUNodeStack *out)
 {
-  NodeShaderNormalMap *nm = (NodeShaderNormalMap *)node->storage;
+  NodeShaderNormalMap *nm = node->storage;
 
   GPUNodeLink *strength;
   if (in[0].link) {
     strength = in[0].link;
   }
   else if (node->original) {
-    bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&node->original->inputs, 0);
-    bNodeSocketValueFloat *socket_data = (bNodeSocketValueFloat *)socket->default_value;
+    bNodeSocket *socket = BLI_findlink(&node->original->inputs, 0);
+    bNodeSocketValueFloat *socket_data = socket->default_value;
     strength = GPU_uniform(&socket_data->value);
   }
   else {
@@ -76,8 +73,8 @@ static int gpu_shader_normal_map(GPUMaterial *mat,
     newnormal = in[1].link;
   }
   else if (node->original) {
-    bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&node->original->inputs, 1);
-    bNodeSocketValueRGBA *socket_data = (bNodeSocketValueRGBA *)socket->default_value;
+    bNodeSocket *socket = BLI_findlink(&node->original->inputs, 1);
+    bNodeSocketValueRGBA *socket_data = socket->default_value;
     newnormal = GPU_uniform(socket_data->value);
   }
   else {
@@ -117,24 +114,19 @@ static int gpu_shader_normal_map(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_normal_map_cc
-
 /* node type definition */
-void register_node_type_sh_normal_map()
+void register_node_type_sh_normal_map(void)
 {
-  namespace file_ns = blender::nodes::node_shader_normal_map_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_NORMAL_MAP, "Normal Map", NODE_CLASS_OP_VECTOR, 0);
-  node_type_socket_templates(
-      &ntype, file_ns::sh_node_normal_map_in, file_ns::sh_node_normal_map_out);
+  node_type_socket_templates(&ntype, sh_node_normal_map_in, sh_node_normal_map_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_normal_map);
+  node_type_init(&ntype, node_shader_init_normal_map);
   node_type_storage(
       &ntype, "NodeShaderNormalMap", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::gpu_shader_normal_map);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_normal_map);
+  node_type_gpu(&ntype, gpu_shader_normal_map);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_normal_map);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_object_info.cc b/source/blender/nodes/shader/nodes/node_shader_object_info.c
index 928756284ab..47040954c9e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_object_info.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_object_info.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_object_info_cc {
-
 static bNodeSocketTemplate sh_node_object_info_out[] = {
     {SOCK_VECTOR, N_("Location"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -51,17 +49,13 @@ static int node_shader_gpu_object_info(GPUMaterial *mat,
                         GPU_constant(&index));
 }
 
-}  // namespace blender::nodes::node_shader_object_info_cc
-
-void register_node_type_sh_object_info()
+void register_node_type_sh_object_info(void)
 {
-  namespace file_ns = blender::nodes::node_shader_object_info_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_OBJECT_INFO, "Object Info", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_object_info_out);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_object_info);
+  node_type_socket_templates(&ntype, NULL, sh_node_object_info_out);
+  node_type_gpu(&ntype, node_shader_gpu_object_info);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_output_aov.cc b/source/blender/nodes/shader/nodes/node_shader_output_aov.c
index 363d8da3f92..32765b459ca 100644
--- a/source/blender/nodes/shader/nodes/node_shader_output_aov.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_output_aov.c
@@ -17,14 +17,12 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_hash.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_output_aov_cc {
-
 static bNodeSocketTemplate sh_node_output_aov_in[] = {
     {SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
     {SOCK_FLOAT, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -33,8 +31,7 @@ static bNodeSocketTemplate sh_node_output_aov_in[] = {
 
 static void node_shader_init_output_aov(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderOutputAOV *aov = (NodeShaderOutputAOV *)MEM_callocN(sizeof(NodeShaderOutputAOV),
-                                                                "NodeShaderOutputAOV");
+  NodeShaderOutputAOV *aov = MEM_callocN(sizeof(NodeShaderOutputAOV), "NodeShaderOutputAOV");
   node->storage = aov;
 }
 
@@ -55,21 +52,17 @@ static int node_shader_gpu_output_aov(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_output_aov_cc
-
 /* node type definition */
-void register_node_type_sh_output_aov()
+void register_node_type_sh_output_aov(void)
 {
-  namespace file_ns = blender::nodes::node_shader_output_aov_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_OUTPUT_AOV, "AOV Output", NODE_CLASS_OUTPUT, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_output_aov_in, nullptr);
-  node_type_init(&ntype, file_ns::node_shader_init_output_aov);
+  node_type_socket_templates(&ntype, sh_node_output_aov_in, NULL);
+  node_type_init(&ntype, node_shader_init_output_aov);
   node_type_storage(
       &ntype, "NodeShaderOutputAOV", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_output_aov);
+  node_type_gpu(&ntype, node_shader_gpu_output_aov);
 
   ntype.no_muting = true;
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_output_light.cc b/source/blender/nodes/shader/nodes/node_shader_output_light.c
index 00518271672..6c4837f3c6f 100644
--- a/source/blender/nodes/shader/nodes/node_shader_output_light.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_output_light.c
@@ -17,30 +17,24 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_output_light_cc {
-
 static bNodeSocketTemplate sh_node_output_light_in[] = {
     {SOCK_SHADER, N_("Surface"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {-1, ""},
 };
 
-}  // namespace blender::nodes::node_shader_output_light_cc
-
 /* node type definition */
-void register_node_type_sh_output_light()
+void register_node_type_sh_output_light(void)
 {
-  namespace file_ns = blender::nodes::node_shader_output_light_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_OUTPUT_LIGHT, "Light Output", NODE_CLASS_OUTPUT, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_output_light_in, nullptr);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
+  node_type_socket_templates(&ntype, sh_node_output_light_in, NULL);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
 
   ntype.no_muting = true;
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc b/source/blender/nodes/shader/nodes/node_shader_output_linestyle.c
index 3c39ff8e2c9..07e253383e2 100644
--- a/source/blender/nodes/shader/nodes/node_shader_output_linestyle.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_output_linestyle.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_output_linestyle_cc {
-
 static bNodeSocketTemplate sh_node_output_linestyle_in[] = {
     {SOCK_RGBA, N_("Color"), 1.0f, 0.0f, 1.0f, 1.0f},
     {SOCK_FLOAT, N_("Color Fac"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
@@ -31,18 +29,14 @@ static bNodeSocketTemplate sh_node_output_linestyle_in[] = {
     {-1, ""},
 };
 
-}  // namespace blender::nodes::node_shader_output_linestyle_cc
-
 /* node type definition */
-void register_node_type_sh_output_linestyle()
+void register_node_type_sh_output_linestyle(void)
 {
-  namespace file_ns = blender::nodes::node_shader_output_linestyle_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_OUTPUT_LINESTYLE, "Line Style Output", NODE_CLASS_OUTPUT, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_output_linestyle_in, nullptr);
-  node_type_init(&ntype, nullptr);
+  node_type_socket_templates(&ntype, sh_node_output_linestyle_in, NULL);
+  node_type_init(&ntype, NULL);
 
   ntype.no_muting = true;
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_output_material.cc b/source/blender/nodes/shader/nodes/node_shader_output_material.c
index c111115f108..41932cca6a3 100644
--- a/source/blender/nodes/shader/nodes/node_shader_output_material.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_output_material.c
@@ -17,14 +17,12 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BKE_scene.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_output_material_cc {
-
 static bNodeSocketTemplate sh_node_output_material_in[] = {
     {SOCK_SHADER, N_("Surface")},
     {SOCK_SHADER, N_("Volume")},
@@ -75,20 +73,16 @@ static int node_shader_gpu_output_material(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_output_material_cc
-
 /* node type definition */
-void register_node_type_sh_output_material()
+void register_node_type_sh_output_material(void)
 {
-  namespace file_ns = blender::nodes::node_shader_output_material_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_OUTPUT_MATERIAL, "Material Output", NODE_CLASS_OUTPUT, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_output_material_in, nullptr);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_output_material);
+  node_type_socket_templates(&ntype, sh_node_output_material_in, NULL);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_output_material);
 
   ntype.no_muting = true;
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_output_world.cc b/source/blender/nodes/shader/nodes/node_shader_output_world.c
index 545342ccaa5..09eca7f712e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_output_world.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_output_world.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_output_world_cc {
-
 static bNodeSocketTemplate sh_node_output_world_in[] = {
     {SOCK_SHADER, N_("Surface"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_SHADER, N_("Volume"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -43,20 +41,16 @@ static int node_shader_gpu_output_world(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_output_world_cc
-
 /* node type definition */
-void register_node_type_sh_output_world()
+void register_node_type_sh_output_world(void)
 {
-  namespace file_ns = blender::nodes::node_shader_output_world_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_OUTPUT_WORLD, "World Output", NODE_CLASS_OUTPUT, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_output_world_in, nullptr);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_output_world);
+  node_type_socket_templates(&ntype, sh_node_output_world_in, NULL);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_output_world);
 
   ntype.no_muting = true;
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_particle_info.cc b/source/blender/nodes/shader/nodes/node_shader_particle_info.c
index 0f71eebc050..c6eabc3b2cb 100644
--- a/source/blender/nodes/shader/nodes/node_shader_particle_info.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_particle_info.c
@@ -17,12 +17,9 @@
  * All rights reserved.
  */
 
+#include "../node_shader_util.h"
 #include "RE_texture.h"
 
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_particle_info_cc {
-
 static bNodeSocketTemplate outputs[] = {
     {SOCK_FLOAT, "Index"},
     {SOCK_FLOAT, "Random"},
@@ -64,19 +61,15 @@ static int gpu_shader_particle_info(GPUMaterial *mat,
                         GPU_builtin(GPU_PARTICLE_ANG_VELOCITY));
 }
 
-}  // namespace blender::nodes::node_shader_particle_info_cc
-
 /* node type definition */
-void register_node_type_sh_particle_info()
+void register_node_type_sh_particle_info(void)
 {
-  namespace file_ns = blender::nodes::node_shader_particle_info_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, nullptr, file_ns::outputs);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_particle_info);
-  node_type_gpu(&ntype, file_ns::gpu_shader_particle_info);
+  node_type_socket_templates(&ntype, NULL, outputs);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_particle_info);
+  node_type_gpu(&ntype, gpu_shader_particle_info);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_rgb.c
index 65dfba604af..0bdef9a2a17 100644
--- a/source/blender/nodes/shader/nodes/node_shader_rgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_rgb.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** RGB ******************** */
-
-namespace blender::nodes::node_shader_rgb_cc {
-
 static bNodeSocketTemplate sh_node_rgb_out[] = {
     {SOCK_RGBA, N_("Color"), 0.5f, 0.5f, 0.5f, 1.0f},
     {-1, ""},
@@ -42,17 +39,13 @@ static int gpu_shader_rgb(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "set_rgba", in, out, link);
 }
 
-}  // namespace blender::nodes::node_shader_rgb_cc
-
-void register_node_type_sh_rgb()
+void register_node_type_sh_rgb(void)
 {
-  namespace file_ns = blender::nodes::node_shader_rgb_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, nullptr, file_ns::sh_node_rgb_out);
-  node_type_gpu(&ntype, file_ns::gpu_shader_rgb);
+  node_type_socket_templates(&ntype, NULL, sh_node_rgb_out);
+  node_type_gpu(&ntype, gpu_shader_rgb);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc b/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc
deleted file mode 100644
index 7d6fec4b7c5..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_rgb_to_bw.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2005 Blender Foundation.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup shdnodes
- */
-
-#include "IMB_colormanagement.h"
-
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_rgb_to_bw_cc {
-
-static void sh_node_rgbtobw_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.5f, 0.5f, 0.5f, 1.0f});
-  b.add_output<decl::Float>(N_("Val"));
-};
-
-static void node_shader_exec_rgbtobw(void *UNUSED(data),
-                                     int UNUSED(thread),
-                                     bNode *UNUSED(node),
-                                     bNodeExecData *UNUSED(execdata),
-                                     bNodeStack **in,
-                                     bNodeStack **out)
-{
-  /* Stack order out: BW. */
-  /* Stack order in: COL. */
-  float col[3];
-  nodestack_get_vec(col, SOCK_VECTOR, in[0]);
-
-  out[0]->vec[0] = IMB_colormanagement_get_luminance(col);
-}
-
-static int gpu_shader_rgbtobw(GPUMaterial *mat,
-                              bNode *node,
-                              bNodeExecData *UNUSED(execdata),
-                              GPUNodeStack *in,
-                              GPUNodeStack *out)
-{
-  return GPU_stack_link(mat, node, "rgbtobw", in, out);
-}
-
-}  // namespace blender::nodes::node_shader_rgb_to_bw_cc
-
-void register_node_type_sh_rgbtobw()
-{
-  namespace file_ns = blender::nodes::node_shader_rgb_to_bw_cc;
-
-  static bNodeType ntype;
-
-  sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_rgbtobw_declare;
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_rgbtobw);
-  node_type_gpu(&ntype, file_ns::gpu_shader_rgbtobw);
-
-  nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_script.cc b/source/blender/nodes/shader/nodes/node_shader_script.c
index 7dbf2449832..42ab272de0e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_script.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_script.c
@@ -21,22 +21,19 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** Script ******************** */
 
-namespace blender::nodes::node_shader_script_cc {
-
 static void init(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderScript *nss = (NodeShaderScript *)MEM_callocN(sizeof(NodeShaderScript),
-                                                          "shader script node");
+  NodeShaderScript *nss = MEM_callocN(sizeof(NodeShaderScript), "shader script node");
   node->storage = nss;
 }
 
 static void node_free_script(bNode *node)
 {
-  NodeShaderScript *nss = (NodeShaderScript *)node->storage;
+  NodeShaderScript *nss = node->storage;
 
   if (nss) {
     if (nss->bytecode) {
@@ -51,28 +48,23 @@ static void node_copy_script(bNodeTree *UNUSED(dest_ntree),
                              bNode *dest_node,
                              const bNode *src_node)
 {
-  NodeShaderScript *src_nss = (NodeShaderScript *)src_node->storage;
-  NodeShaderScript *dest_nss = (NodeShaderScript *)MEM_dupallocN(src_nss);
+  NodeShaderScript *src_nss = src_node->storage;
+  NodeShaderScript *dest_nss = MEM_dupallocN(src_nss);
 
   if (src_nss->bytecode) {
-    dest_nss->bytecode = (char *)MEM_dupallocN(src_nss->bytecode);
+    dest_nss->bytecode = MEM_dupallocN(src_nss->bytecode);
   }
 
   dest_node->storage = dest_nss;
 }
 
-}  // namespace blender::nodes::node_shader_script_cc
-
-void register_node_type_sh_script()
+void register_node_type_sh_script(void)
 {
-  namespace file_ns = blender::nodes::node_shader_script_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, 0);
-  node_type_init(&ntype, file_ns::init);
-  node_type_storage(
-      &ntype, "NodeShaderScript", file_ns::node_free_script, file_ns::node_copy_script);
+  node_type_init(&ntype, init);
+  node_type_storage(&ntype, "NodeShaderScript", node_free_script, node_copy_script);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_separate_hsv.cc b/source/blender/nodes/shader/nodes/node_shader_separate_hsv.cc
deleted file mode 100644
index 242bc5f9781..00000000000
--- a/source/blender/nodes/shader/nodes/node_shader_separate_hsv.cc
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2021 Blender Foundation.
- * All rights reserved.
- */
-
-/** \file
- * \ingroup shdnodes
- */
-
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_separate_hsv_cc {
-
-static bNodeSocketTemplate sh_node_sephsv_in[] = {
-    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f},
-    {-1, ""},
-};
-static bNodeSocketTemplate sh_node_sephsv_out[] = {
-    {SOCK_FLOAT, N_("H")},
-    {SOCK_FLOAT, N_("S")},
-    {SOCK_FLOAT, N_("V")},
-    {-1, ""},
-};
-
-static void node_shader_exec_sephsv(void *UNUSED(data),
-                                    int UNUSED(thread),
-                                    bNode *UNUSED(node),
-                                    bNodeExecData *UNUSED(execdata),
-                                    bNodeStack **in,
-                                    bNodeStack **out)
-{
-  float col[3];
-  nodestack_get_vec(col, SOCK_VECTOR, in[0]);
-
-  rgb_to_hsv(col[0], col[1], col[2], &out[0]->vec[0], &out[1]->vec[0], &out[2]->vec[0]);
-}
-
-static int gpu_shader_sephsv(GPUMaterial *mat,
-                             bNode *node,
-                             bNodeExecData *UNUSED(execdata),
-                             GPUNodeStack *in,
-                             GPUNodeStack *out)
-{
-  return GPU_stack_link(mat, node, "separate_hsv", in, out);
-}
-
-}  // namespace blender::nodes::node_shader_separate_hsv_cc
-
-void register_node_type_sh_sephsv()
-{
-  namespace file_ns = blender::nodes::node_shader_separate_hsv_cc;
-
-  static bNodeType ntype;
-
-  sh_node_type_base(&ntype, SH_NODE_SEPHSV, "Separate HSV", NODE_CLASS_CONVERTER, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_sephsv_in, file_ns::sh_node_sephsv_out);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_sephsv);
-  node_type_gpu(&ntype, file_ns::gpu_shader_sephsv);
-
-  nodeRegisterType(&ntype);
-}
diff --git a/source/blender/nodes/shader/nodes/node_shader_combine_hsv.cc b/source/blender/nodes/shader/nodes/node_shader_sepcombHSV.c
index 4d4879fd060..dfecb830b35 100644
--- a/source/blender/nodes/shader/nodes/node_shader_combine_hsv.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_sepcombHSV.c
@@ -21,10 +21,55 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_combine_hsv_cc {
+/* **************** SEPARATE HSV ******************** */
+static bNodeSocketTemplate sh_node_sephsv_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f},
+    {-1, ""},
+};
+static bNodeSocketTemplate sh_node_sephsv_out[] = {
+    {SOCK_FLOAT, N_("H")},
+    {SOCK_FLOAT, N_("S")},
+    {SOCK_FLOAT, N_("V")},
+    {-1, ""},
+};
+
+static void node_shader_exec_sephsv(void *UNUSED(data),
+                                    int UNUSED(thread),
+                                    bNode *UNUSED(node),
+                                    bNodeExecData *UNUSED(execdata),
+                                    bNodeStack **in,
+                                    bNodeStack **out)
+{
+  float col[3];
+  nodestack_get_vec(col, SOCK_VECTOR, in[0]);
+
+  rgb_to_hsv(col[0], col[1], col[2], &out[0]->vec[0], &out[1]->vec[0], &out[2]->vec[0]);
+}
+
+static int gpu_shader_sephsv(GPUMaterial *mat,
+                             bNode *node,
+                             bNodeExecData *UNUSED(execdata),
+                             GPUNodeStack *in,
+                             GPUNodeStack *out)
+{
+  return GPU_stack_link(mat, node, "separate_hsv", in, out);
+}
+
+void register_node_type_sh_sephsv(void)
+{
+  static bNodeType ntype;
+
+  sh_node_type_base(&ntype, SH_NODE_SEPHSV, "Separate HSV", NODE_CLASS_CONVERTER, 0);
+  node_type_socket_templates(&ntype, sh_node_sephsv_in, sh_node_sephsv_out);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_sephsv);
+  node_type_gpu(&ntype, gpu_shader_sephsv);
 
+  nodeRegisterType(&ntype);
+}
+
+/* **************** COMBINE HSV ******************** */
 static bNodeSocketTemplate sh_node_combhsv_in[] = {
     {SOCK_FLOAT, N_("H"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_UNSIGNED},
     {SOCK_FLOAT, N_("S"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_UNSIGNED},
@@ -60,18 +105,14 @@ static int gpu_shader_combhsv(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "combine_hsv", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_combine_hsv_cc
-
-void register_node_type_sh_combhsv()
+void register_node_type_sh_combhsv(void)
 {
-  namespace file_ns = blender::nodes::node_shader_combine_hsv_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_COMBHSV, "Combine HSV", NODE_CLASS_CONVERTER, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_combhsv_in, file_ns::sh_node_combhsv_out);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_combhsv);
-  node_type_gpu(&ntype, file_ns::gpu_shader_combhsv);
+  node_type_socket_templates(&ntype, sh_node_combhsv_in, sh_node_combhsv_out);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_combhsv);
+  node_type_gpu(&ntype, gpu_shader_combhsv);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_separate_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc
index 2f57fe31f47..08a9e01786e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_separate_rgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_sepcombRGB.cc
@@ -13,7 +13,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * The Original Code is Copyright (C) 2006 Blender Foundation.
  * All rights reserved.
  */
 
@@ -21,9 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_separate_rgb_cc {
+namespace blender::nodes {
 
 static void sh_node_seprgb_declare(NodeDeclarationBuilder &b)
 {
@@ -34,6 +34,8 @@ static void sh_node_seprgb_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("B"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_exec_seprgb(void *UNUSED(data),
                                     int UNUSED(thread),
                                     bNode *UNUSED(node),
@@ -101,19 +103,75 @@ static void sh_node_seprgb_build_multi_function(blender::nodes::NodeMultiFunctio
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes::node_shader_separate_rgb_cc
+void register_node_type_sh_seprgb(void)
+{
+  static bNodeType ntype;
+
+  sh_fn_node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTER, 0);
+  ntype.declare = blender::nodes::sh_node_seprgb_declare;
+  node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_seprgb);
+  node_type_gpu(&ntype, gpu_shader_seprgb);
+  ntype.build_multi_function = sh_node_seprgb_build_multi_function;
+
+  nodeRegisterType(&ntype);
+}
+
+namespace blender::nodes {
+
+static void sh_node_combrgb_declare(NodeDeclarationBuilder &b)
+{
+  b.is_function_node();
+  b.add_input<decl::Float>(N_("R")).min(0.0f).max(1.0f);
+  b.add_input<decl::Float>(N_("G")).min(0.0f).max(1.0f);
+  b.add_input<decl::Float>(N_("B")).min(0.0f).max(1.0f);
+  b.add_output<decl::Color>(N_("Image"));
+};
+
+}  // namespace blender::nodes
+
+static void node_shader_exec_combrgb(void *UNUSED(data),
+                                     int UNUSED(thread),
+                                     bNode *UNUSED(node),
+                                     bNodeExecData *UNUSED(execdata),
+                                     bNodeStack **in,
+                                     bNodeStack **out)
+{
+  float r, g, b;
+  nodestack_get_vec(&r, SOCK_FLOAT, in[0]);
+  nodestack_get_vec(&g, SOCK_FLOAT, in[1]);
+  nodestack_get_vec(&b, SOCK_FLOAT, in[2]);
+
+  out[0]->vec[0] = r;
+  out[0]->vec[1] = g;
+  out[0]->vec[2] = b;
+}
+
+static int gpu_shader_combrgb(GPUMaterial *mat,
+                              bNode *node,
+                              bNodeExecData *UNUSED(execdata),
+                              GPUNodeStack *in,
+                              GPUNodeStack *out)
+{
+  return GPU_stack_link(mat, node, "combine_rgb", in, out);
+}
 
-void register_node_type_sh_seprgb()
+static void sh_node_combrgb_build_multi_function(blender::nodes::NodeMultiFunctionBuilder &builder)
 {
-  namespace file_ns = blender::nodes::node_shader_separate_rgb_cc;
+  static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, blender::ColorGeometry4f> fn{
+      "Combine RGB",
+      [](float r, float g, float b) { return blender::ColorGeometry4f(r, g, b, 1.0f); }};
+  builder.set_matching_fn(fn);
+}
 
+void register_node_type_sh_combrgb(void)
+{
   static bNodeType ntype;
 
-  sh_fn_node_type_base(&ntype, SH_NODE_SEPRGB, "Separate RGB", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_seprgb_declare;
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_seprgb);
-  node_type_gpu(&ntype, file_ns::gpu_shader_seprgb);
-  ntype.build_multi_function = file_ns::sh_node_seprgb_build_multi_function;
+  sh_fn_node_type_base(&ntype, SH_NODE_COMBRGB, "Combine RGB", NODE_CLASS_CONVERTER, 0);
+  ntype.declare = blender::nodes::sh_node_combrgb_declare;
+  node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_combrgb);
+  node_type_gpu(&ntype, gpu_shader_combrgb);
+  ntype.build_multi_function = sh_node_combrgb_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_separate_xyz.cc b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc
index ee2335978a3..1bbfa629462 100644
--- a/source/blender/nodes/shader/nodes/node_shader_separate_xyz.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_sepcombXYZ.cc
@@ -13,7 +13,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * The Original Code is Copyright (C) 2014 Blender Foundation.
  * All rights reserved.
  */
 
@@ -21,9 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_separate_xyz_cc {
+namespace blender::nodes {
 
 static void sh_node_sepxyz_declare(NodeDeclarationBuilder &b)
 {
@@ -34,6 +34,8 @@ static void sh_node_sepxyz_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Z"));
 };
 
+}  // namespace blender::nodes
+
 static int gpu_shader_sepxyz(GPUMaterial *mat,
                              bNode *node,
                              bNodeExecData *UNUSED(execdata),
@@ -86,18 +88,55 @@ static void sh_node_sepxyz_build_multi_function(blender::nodes::NodeMultiFunctio
   builder.set_matching_fn(separate_fn);
 }
 
-}  // namespace blender::nodes::node_shader_separate_xyz_cc
+void register_node_type_sh_sepxyz(void)
+{
+  static bNodeType ntype;
+
+  sh_fn_node_type_base(&ntype, SH_NODE_SEPXYZ, "Separate XYZ", NODE_CLASS_CONVERTER, 0);
+  ntype.declare = blender::nodes::sh_node_sepxyz_declare;
+  node_type_gpu(&ntype, gpu_shader_sepxyz);
+  ntype.build_multi_function = sh_node_sepxyz_build_multi_function;
+
+  nodeRegisterType(&ntype);
+}
+
+namespace blender::nodes {
+
+static void sh_node_combxyz_declare(NodeDeclarationBuilder &b)
+{
+  b.is_function_node();
+  b.add_input<decl::Float>(N_("X")).min(-10000.0f).max(10000.0f);
+  b.add_input<decl::Float>(N_("Y")).min(-10000.0f).max(10000.0f);
+  b.add_input<decl::Float>(N_("Z")).min(-10000.0f).max(10000.0f);
+  b.add_output<decl::Vector>(N_("Vector"));
+};
+
+}  // namespace blender::nodes
+
+static int gpu_shader_combxyz(GPUMaterial *mat,
+                              bNode *node,
+                              bNodeExecData *UNUSED(execdata),
+                              GPUNodeStack *in,
+                              GPUNodeStack *out)
+{
+  return GPU_stack_link(mat, node, "combine_xyz", in, out);
+}
 
-void register_node_type_sh_sepxyz()
+static void sh_node_combxyz_build_multi_function(blender::nodes::NodeMultiFunctionBuilder &builder)
 {
-  namespace file_ns = blender::nodes::node_shader_separate_xyz_cc;
+  static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, blender::float3> fn{
+      "Combine Vector", [](float x, float y, float z) { return blender::float3(x, y, z); }};
+  builder.set_matching_fn(fn);
+}
 
+void register_node_type_sh_combxyz(void)
+{
   static bNodeType ntype;
 
-  sh_fn_node_type_base(&ntype, SH_NODE_SEPXYZ, "Separate XYZ", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_sepxyz_declare;
-  node_type_gpu(&ntype, file_ns::gpu_shader_sepxyz);
-  ntype.build_multi_function = file_ns::sh_node_sepxyz_build_multi_function;
+  sh_fn_node_type_base(&ntype, SH_NODE_COMBXYZ, "Combine XYZ", NODE_CLASS_CONVERTER, 0);
+  ntype.declare = blender::nodes::sh_node_combxyz_declare;
+  node_type_gpu(&ntype, gpu_shader_combxyz);
+  ntype.build_multi_function = sh_node_combxyz_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_shader_to_rgb.cc b/source/blender/nodes/shader/nodes/node_shader_shaderToRgb.c
index 3791eb9449f..25c30aa4081 100644
--- a/source/blender/nodes/shader/nodes/node_shader_shader_to_rgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_shaderToRgb.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_shader_to_rgb_cc {
-
 static bNodeSocketTemplate sh_node_shadertorgb_in[] = {
     {SOCK_SHADER, N_("Shader")},
     {-1, ""},
@@ -47,21 +45,16 @@ static int node_shader_gpu_shadertorgb(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_shader_to_rgba", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_shader_to_rgb_cc
-
 /* node type definition */
-void register_node_type_sh_shadertorgb()
+void register_node_type_sh_shadertorgb(void)
 {
-  namespace file_ns = blender::nodes::node_shader_shader_to_rgb_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_SHADERTORGB, "Shader to RGB", NODE_CLASS_CONVERTER, 0);
-  node_type_socket_templates(
-      &ntype, file_ns::sh_node_shadertorgb_in, file_ns::sh_node_shadertorgb_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_shadertorgb);
+  node_type_socket_templates(&ntype, sh_node_shadertorgb_in, sh_node_shadertorgb_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_shadertorgb);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_squeeze.cc b/source/blender/nodes/shader/nodes/node_shader_squeeze.c
index 55c25ffbdb7..ca7bdf41df9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_squeeze.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_squeeze.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 /* **************** VALUE SQUEEZE ******************** */
-
-namespace blender::nodes::node_shader_squeeze_cc {
-
 static bNodeSocketTemplate sh_node_squeeze_in[] = {
     {SOCK_FLOAT, N_("Value"), 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
     {SOCK_FLOAT, N_("Width"), 1.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
@@ -60,19 +57,15 @@ static int gpu_shader_squeeze(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "squeeze", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_squeeze_cc
-
-void register_node_type_sh_squeeze()
+void register_node_type_sh_squeeze(void)
 {
-  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, file_ns::sh_node_squeeze_in, file_ns::sh_node_squeeze_out);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_squeeze);
-  node_type_gpu(&ntype, file_ns::gpu_shader_squeeze);
+  node_type_socket_templates(&ntype, sh_node_squeeze_in, sh_node_squeeze_out);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_squeeze);
+  node_type_gpu(&ntype, gpu_shader_squeeze);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc b/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.c
index 943ef45cc44..85a4a6aa425 100644
--- a/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_subsurface_scattering.c
@@ -17,26 +17,24 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_subsurface_scattering_cc {
-
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Scale")).default_value(1.0f).min(0.0f).max(1000.0f);
-  b.add_input<decl::Vector>(N_("Radius"))
-      .default_value({1.0f, 0.2f, 0.1f})
-      .min(0.0f)
-      .max(100.0f)
-      .compact();
-  b.add_input<decl::Float>(N_("IOR")).default_value(1.4f).min(0.0f).max(3.8f).subtype(PROP_FACTOR);
-  b.add_input<decl::Float>(N_("Anisotropy")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Vector>(N_("Normal")).min(-1.0f).max(1.0f).hide_value();
-  b.add_output<decl::Shader>(N_("BSSRDF"));
-}
+static bNodeSocketTemplate sh_node_subsurface_scattering_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Scale"), 1.0, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_VECTOR, N_("Radius"), 1.0f, 0.2f, 0.1f, 0.0f, 0.0f, 100.0f, PROP_NONE, SOCK_COMPACT},
+    {SOCK_FLOAT, N_("IOR"), 1.4f, 0.0f, 0.0f, 0.0f, 1.01f, 3.8f, PROP_FACTOR},
+    {SOCK_FLOAT, N_("Anisotropy"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
+    {-1, ""},
+};
+
+static bNodeSocketTemplate sh_node_subsurface_scattering_out[] = {
+    {SOCK_SHADER, N_("BSSRDF")},
+    {-1, ""},
+};
 
 static void node_shader_init_subsurface_scattering(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -55,14 +53,14 @@ static int node_shader_gpu_subsurface_scattering(GPUMaterial *mat,
   }
 
   if (node->sss_id > 0) {
-    bNodeSocket *socket = (bNodeSocket *)BLI_findlink(&node->original->inputs, 2);
-    bNodeSocketValueRGBA *socket_data = (bNodeSocketValueRGBA *)socket->default_value;
+    bNodeSocket *socket = BLI_findlink(&node->original->inputs, 2);
+    bNodeSocketValueRGBA *socket_data = socket->default_value;
     /* For some reason it seems that the socket value is in ARGB format. */
     GPU_material_sss_profile_create(mat, &socket_data->value[1]);
 
     /* sss_id is 0 only the node is not connected to any output.
      * In this case flagging the material would trigger a bug (see T68736). */
-    GPU_material_flag_set(mat, (eGPUMatFlag)(GPU_MATFLAG_DIFFUSE | GPU_MATFLAG_SSS));
+    GPU_material_flag_set(mat, GPU_MATFLAG_DIFFUSE | GPU_MATFLAG_SSS);
   }
 
   return GPU_stack_link(
@@ -73,30 +71,27 @@ static void node_shader_update_subsurface_scattering(bNodeTree *ntree, bNode *no
 {
   const int sss_method = node->custom1;
 
-  LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
+  for (bNodeSocket *sock = node->inputs.first; sock; sock = sock->next) {
     if (STR_ELEM(sock->name, "IOR", "Anisotropy")) {
       nodeSetSocketAvailability(ntree, sock, sss_method != SHD_SUBSURFACE_BURLEY);
     }
   }
 }
 
-}  // namespace blender::nodes::node_shader_subsurface_scattering_cc
-
 /* node type definition */
-void register_node_type_sh_subsurface_scattering()
+void register_node_type_sh_subsurface_scattering(void)
 {
-  namespace file_ns = blender::nodes::node_shader_subsurface_scattering_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(
       &ntype, SH_NODE_SUBSURFACE_SCATTERING, "Subsurface Scattering", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(
+      &ntype, sh_node_subsurface_scattering_in, sh_node_subsurface_scattering_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_subsurface_scattering);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_subsurface_scattering);
-  node_type_update(&ntype, file_ns::node_shader_update_subsurface_scattering);
+  node_type_init(&ntype, node_shader_init_subsurface_scattering);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_subsurface_scattering);
+  node_type_update(&ntype, node_shader_update_subsurface_scattering);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tangent.cc b/source/blender/nodes/shader/nodes/node_shader_tangent.c
index 90148c5bf4c..2c12bf9bc01 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tangent.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tangent.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_tangent_cc {
-
 static bNodeSocketTemplate sh_node_tangent_out[] = {
     {SOCK_VECTOR, N_("Tangent"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {-1, ""},
@@ -30,8 +28,7 @@ static bNodeSocketTemplate sh_node_tangent_out[] = {
 
 static void node_shader_init_tangent(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderTangent *attr = (NodeShaderTangent *)MEM_callocN(sizeof(NodeShaderTangent),
-                                                             "NodeShaderTangent");
+  NodeShaderTangent *attr = MEM_callocN(sizeof(NodeShaderTangent), "NodeShaderTangent");
   attr->axis = SHD_TANGENT_AXIS_Z;
   node->storage = attr;
 }
@@ -42,7 +39,7 @@ static int node_shader_gpu_tangent(GPUMaterial *mat,
                                    GPUNodeStack *in,
                                    GPUNodeStack *out)
 {
-  NodeShaderTangent *attr = (NodeShaderTangent *)node->storage;
+  NodeShaderTangent *attr = node->storage;
 
   if (attr->direction_type == SHD_TANGENT_UVMAP) {
     return GPU_stack_link(
@@ -71,20 +68,16 @@ 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 register_node_type_sh_tangent(void)
 {
-  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, nullptr, file_ns::sh_node_tangent_out);
+  node_type_socket_templates(&ntype, NULL, sh_node_tangent_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_tangent);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tangent);
+  node_type_init(&ntype, node_shader_init_tangent);
+  node_type_gpu(&ntype, 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_brick.cc b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
index 14f0b71b957..b840bd75e42 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_brick.cc
@@ -17,12 +17,12 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_float2.hh"
 #include "BLI_float4.hh"
 
-namespace blender::nodes::node_shader_tex_brick_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_brick_declare(NodeDeclarationBuilder &b)
 {
@@ -57,6 +57,8 @@ static void sh_node_tex_brick_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Fac"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_brick(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexBrick *tex = (NodeTexBrick *)MEM_callocN(sizeof(NodeTexBrick), "NodeTexBrick");
@@ -99,6 +101,8 @@ static int node_shader_gpu_tex_brick(GPUMaterial *mat,
                         GPU_constant(&squash_freq));
 }
 
+namespace blender::nodes {
+
 class BrickFunction : public fn::MultiFunction {
  private:
   const float offset_;
@@ -262,22 +266,20 @@ static void sh_node_brick_build_multi_function(blender::nodes::NodeMultiFunction
       tex->offset, tex->offset_freq, tex->squash, tex->squash_freq);
 }
 
-}  // namespace blender::nodes::node_shader_tex_brick_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_brick()
+void register_node_type_sh_tex_brick(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_brick_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_BRICK, "Brick Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_brick_declare;
+  ntype.declare = blender::nodes::sh_node_tex_brick_declare;
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_brick);
+  node_type_init(&ntype, node_shader_init_tex_brick);
   node_type_storage(
       &ntype, "NodeTexBrick", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_brick);
-  ntype.build_multi_function = file_ns::sh_node_brick_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_brick);
+  ntype.build_multi_function = blender::nodes::sh_node_brick_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc b/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
index 714fdc129e5..7c1223a6a32 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_checker.cc
@@ -17,9 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
-namespace blender::nodes::node_shader_tex_checker_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_checker_declare(NodeDeclarationBuilder &b)
 {
@@ -36,6 +36,8 @@ static void sh_node_tex_checker_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Fac"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_checker(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexChecker *tex = (NodeTexChecker *)MEM_callocN(sizeof(NodeTexChecker), "NodeTexChecker");
@@ -57,6 +59,8 @@ static int node_shader_gpu_tex_checker(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_tex_checker", in, out);
 }
 
+namespace blender::nodes {
+
 class NodeTexChecker : public fn::MultiFunction {
  public:
   NodeTexChecker()
@@ -117,21 +121,19 @@ static void sh_node_tex_checker_build_multi_function(
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes::node_shader_tex_checker_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_checker()
+void register_node_type_sh_tex_checker(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_checker_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_CHECKER, "Checker Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_checker_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_checker);
+  ntype.declare = blender::nodes::sh_node_tex_checker_declare;
+  node_type_init(&ntype, node_shader_init_tex_checker);
   node_type_storage(
       &ntype, "NodeTexChecker", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_checker);
-  ntype.build_multi_function = file_ns::sh_node_tex_checker_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_checker);
+  ntype.build_multi_function = blender::nodes::sh_node_tex_checker_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc b/source/blender/nodes/shader/nodes/node_shader_tex_coord.c
index 50411f10aed..4ce19bdc45e 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_coord.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_coord.c
@@ -17,14 +17,12 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "DNA_customdata_types.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_tex_coord_cc {
-
 static bNodeSocketTemplate sh_node_tex_coord_out[] = {
     {SOCK_VECTOR, N_("Generated"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -44,12 +42,11 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat,
 {
   Object *ob = (Object *)node->id;
 
-  GPUNodeLink *inv_obmat = (ob != nullptr) ? GPU_uniform(&ob->imat[0][0]) :
-                                             GPU_builtin(GPU_INVERSE_OBJECT_MATRIX);
+  GPUNodeLink *inv_obmat = (ob != NULL) ? GPU_uniform(&ob->imat[0][0]) :
+                                          GPU_builtin(GPU_INVERSE_OBJECT_MATRIX);
 
   /* Opti: don't request orco if not needed. */
-  const float default_coords[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-  GPUNodeLink *orco = (!out[0].hasoutput) ? GPU_constant(default_coords) :
+  GPUNodeLink *orco = (!out[0].hasoutput) ? GPU_constant((float[4]){0.0f, 0.0f, 0.0f, 0.0f}) :
                                             GPU_attribute(mat, CD_ORCO, "");
   GPUNodeLink *mtface = GPU_attribute(mat, CD_MTFACE, "");
   GPUNodeLink *viewpos = GPU_builtin(GPU_VIEW_POSITION);
@@ -78,27 +75,23 @@ static int node_shader_gpu_tex_coord(GPUMaterial *mat,
                out[i].link,
                out[i].link,
                &out[i].link,
-               nullptr);
+               NULL);
     }
   }
 
   return 1;
 }
 
-}  // namespace blender::nodes::node_shader_tex_coord_cc
-
 /* node type definition */
-void register_node_type_sh_tex_coord()
+void register_node_type_sh_tex_coord(void)
 {
-  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, nullptr, file_ns::sh_node_tex_coord_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_coord);
+  node_type_socket_templates(&ntype, NULL, sh_node_tex_coord_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_tex_coord);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_environment.cc b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c
index 936d3a3011a..26a1db1f3a6 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_environment.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_environment.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_tex_environment_cc {
-
 static bNodeSocketTemplate sh_node_tex_environment_in[] = {
     {SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
     {-1, ""},
@@ -35,8 +33,7 @@ static bNodeSocketTemplate sh_node_tex_environment_out[] = {
 
 static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeTexEnvironment *tex = (NodeTexEnvironment *)MEM_callocN(sizeof(NodeTexEnvironment),
-                                                              "NodeTexEnvironment");
+  NodeTexEnvironment *tex = MEM_callocN(sizeof(NodeTexEnvironment), "NodeTexEnvironment");
   BKE_texture_mapping_default(&tex->base.tex_mapping, TEXMAP_TYPE_POINT);
   BKE_texture_colormapping_default(&tex->base.color_mapping);
   tex->projection = SHD_PROJ_EQUIRECTANGULAR;
@@ -52,12 +49,12 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat,
                                            GPUNodeStack *out)
 {
   Image *ima = (Image *)node->id;
-  NodeTexEnvironment *tex = (NodeTexEnvironment *)node->storage;
+  NodeTexEnvironment *tex = node->storage;
 
   /* We get the image user from the original node, since GPU image keeps
    * a pointer to it and the dependency refreshes the original. */
   bNode *node_original = node->original ? node->original : node;
-  NodeTexImage *tex_original = (NodeTexImage *)node_original->storage;
+  NodeTexImage *tex_original = node_original->storage;
   ImageUser *iuser = &tex_original->iuser;
   eGPUSamplerState sampler = GPU_SAMPLER_REPEAT | GPU_SAMPLER_ANISO | GPU_SAMPLER_FILTER;
   /* TODO(fclem): For now assume mipmap is always enabled. */
@@ -135,22 +132,17 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_tex_environment_cc
-
 /* node type definition */
-void register_node_type_sh_tex_environment()
+void register_node_type_sh_tex_environment(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_environment_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TEX_ENVIRONMENT, "Environment Texture", NODE_CLASS_TEXTURE, 0);
-  node_type_socket_templates(
-      &ntype, file_ns::sh_node_tex_environment_in, file_ns::sh_node_tex_environment_out);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_environment);
+  node_type_socket_templates(&ntype, sh_node_tex_environment_in, sh_node_tex_environment_out);
+  node_type_init(&ntype, node_shader_init_tex_environment);
   node_type_storage(
       &ntype, "NodeTexEnvironment", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_environment);
+  node_type_gpu(&ntype, node_shader_gpu_tex_environment);
   node_type_label(&ntype, node_image_label);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
index c6094409206..33832c42b3c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_gradient.cc
@@ -17,9 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
-namespace blender::nodes::node_shader_tex_gradient_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_gradient_declare(NodeDeclarationBuilder &b)
 {
@@ -29,6 +29,8 @@ static void sh_node_tex_gradient_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Fac")).no_muted_links();
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_gradient(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexGradient *tex = (NodeTexGradient *)MEM_callocN(sizeof(NodeTexGradient),
@@ -54,6 +56,8 @@ static int node_shader_gpu_tex_gradient(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_tex_gradient", in, out, GPU_constant(&gradient_type));
 }
 
+namespace blender::nodes {
+
 class GradientFunction : public fn::MultiFunction {
  private:
   int gradient_type_;
@@ -154,21 +158,19 @@ static void sh_node_gradient_tex_build_multi_function(
   builder.construct_and_set_matching_fn<GradientFunction>(tex->gradient_type);
 }
 
-}  // namespace blender::nodes::node_shader_tex_gradient_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_gradient()
+void register_node_type_sh_tex_gradient(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_gradient_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_GRADIENT, "Gradient Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_gradient_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_gradient);
+  ntype.declare = blender::nodes::sh_node_tex_gradient_declare;
+  node_type_init(&ntype, node_shader_init_tex_gradient);
   node_type_storage(
       &ntype, "NodeTexGradient", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_gradient);
-  ntype.build_multi_function = file_ns::sh_node_gradient_tex_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_gradient);
+  ntype.build_multi_function = blender::nodes::sh_node_gradient_tex_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_image.cc b/source/blender/nodes/shader/nodes/node_shader_tex_image.cc
index fd20c556d00..f20fc85cbe0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_image.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_image.cc
@@ -17,9 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
-namespace blender::nodes::node_shader_tex_image_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_image_declare(NodeDeclarationBuilder &b)
 {
@@ -29,6 +29,8 @@ static void sh_node_tex_image_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Alpha")).no_muted_links();
 };
 
+};  // namespace blender::nodes
+
 static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexImage *tex = (NodeTexImage *)MEM_callocN(sizeof(NodeTexImage), "NodeTexImage");
@@ -171,21 +173,17 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_tex_image_cc
-
 /* node type definition */
-void register_node_type_sh_tex_image()
+void register_node_type_sh_tex_image(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_image_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TEX_IMAGE, "Image Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_image_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_image);
+  ntype.declare = blender::nodes::sh_node_tex_image_declare;
+  node_type_init(&ntype, node_shader_init_tex_image);
   node_type_storage(
       &ntype, "NodeTexImage", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_image);
+  node_type_gpu(&ntype, node_shader_gpu_tex_image);
   node_type_label(&ntype, node_image_label);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc b/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
index 9b19dc2907b..62e68d53d03 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_magic.cc
@@ -17,9 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
-namespace blender::nodes::node_shader_tex_magic_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_magic_declare(NodeDeclarationBuilder &b)
 {
@@ -31,6 +31,8 @@ static void sh_node_tex_magic_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Fac")).no_muted_links();
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexMagic *tex = (NodeTexMagic *)MEM_callocN(sizeof(NodeTexMagic), "NodeTexMagic");
@@ -56,6 +58,8 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_tex_magic", in, out, GPU_constant(&depth));
 }
 
+namespace blender::nodes {
+
 class MagicFunction : public fn::MultiFunction {
  private:
   int depth_;
@@ -175,21 +179,19 @@ static void sh_node_magic_tex_build_multi_function(
   builder.construct_and_set_matching_fn<MagicFunction>(tex->depth);
 }
 
-}  // namespace blender::nodes::node_shader_tex_magic_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_magic()
+void register_node_type_sh_tex_magic(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_magic_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_MAGIC, "Magic Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_magic_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_magic);
+  ntype.declare = blender::nodes::sh_node_tex_magic_declare;
+  node_type_init(&ntype, node_shader_init_tex_magic);
   node_type_storage(
       &ntype, "NodeTexMagic", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_magic);
-  ntype.build_multi_function = file_ns::sh_node_magic_tex_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_magic);
+  ntype.build_multi_function = blender::nodes::sh_node_magic_tex_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
index 70c78f75736..e426d9cc49c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_musgrave.cc
@@ -17,11 +17,11 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_noise.hh"
 
-namespace blender::nodes::node_shader_tex_musgrave_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_musgrave_declare(NodeDeclarationBuilder &b)
 {
@@ -37,6 +37,8 @@ static void sh_node_tex_musgrave_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Fac")).no_muted_links();
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexMusgrave *tex = (NodeTexMusgrave *)MEM_callocN(sizeof(NodeTexMusgrave),
@@ -126,6 +128,8 @@ static void node_shader_update_tex_musgrave(bNodeTree *ntree, bNode *node)
   node_sock_label(outFacSock, "Height");
 }
 
+namespace blender::nodes {
+
 class MusgraveFunction : public fn::MultiFunction {
  private:
   const int dimensions_;
@@ -525,23 +529,21 @@ static void sh_node_musgrave_build_multi_function(
   builder.construct_and_set_matching_fn<MusgraveFunction>(tex->dimensions, tex->musgrave_type);
 }
 
-}  // namespace blender::nodes::node_shader_tex_musgrave_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_musgrave()
+void register_node_type_sh_tex_musgrave(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_musgrave_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_MUSGRAVE, "Musgrave Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_musgrave_declare;
+  ntype.declare = blender::nodes::sh_node_tex_musgrave_declare;
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_musgrave);
+  node_type_init(&ntype, node_shader_init_tex_musgrave);
   node_type_storage(
       &ntype, "NodeTexMusgrave", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_musgrave);
-  node_type_update(&ntype, file_ns::node_shader_update_tex_musgrave);
-  ntype.build_multi_function = file_ns::sh_node_musgrave_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_musgrave);
+  node_type_update(&ntype, node_shader_update_tex_musgrave);
+  ntype.build_multi_function = blender::nodes::sh_node_musgrave_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
index 13537be2249..5f846207673 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
@@ -17,11 +17,11 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_noise.hh"
 
-namespace blender::nodes::node_shader_tex_noise_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_noise_declare(NodeDeclarationBuilder &b)
 {
@@ -40,6 +40,8 @@ static void sh_node_tex_noise_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Color>(N_("Color")).no_muted_links();
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexNoise *tex = (NodeTexNoise *)MEM_callocN(sizeof(NodeTexNoise), "NodeTexNoise");
@@ -84,6 +86,8 @@ static void node_shader_update_tex_noise(bNodeTree *ntree, bNode *node)
   nodeSetSocketAvailability(ntree, sockW, tex->dimensions == 1 || tex->dimensions == 4);
 }
 
+namespace blender::nodes {
+
 class NoiseFunction : public fn::MultiFunction {
  private:
   int dimensions_;
@@ -242,23 +246,21 @@ static void sh_node_noise_build_multi_function(blender::nodes::NodeMultiFunction
   builder.construct_and_set_matching_fn<NoiseFunction>(tex->dimensions);
 }
 
-}  // namespace blender::nodes::node_shader_tex_noise_cc
+}  // namespace blender::nodes
 
 /* node type definition */
-void register_node_type_sh_tex_noise()
+void register_node_type_sh_tex_noise(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_noise_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_NOISE, "Noise Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_noise_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_noise);
+  ntype.declare = blender::nodes::sh_node_tex_noise_declare;
+  node_type_init(&ntype, node_shader_init_tex_noise);
   node_type_storage(
       &ntype, "NodeTexNoise", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_noise);
-  node_type_update(&ntype, file_ns::node_shader_update_tex_noise);
-  ntype.build_multi_function = file_ns::sh_node_noise_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_noise);
+  node_type_update(&ntype, node_shader_update_tex_noise);
+  ntype.build_multi_function = blender::nodes::sh_node_noise_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc b/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.c
index 73812da029c..14cd1fd4c0c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_pointdensity.c
@@ -17,14 +17,12 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "RE_texture.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_tex_pointdensity_cc {
-
 static bNodeSocketTemplate sh_node_tex_pointdensity_in[] = {
     {SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
     {-1, ""},
@@ -38,8 +36,8 @@ static bNodeSocketTemplate sh_node_tex_pointdensity_out[] = {
 
 static void node_shader_init_tex_pointdensity(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderTexPointDensity *point_density = (NodeShaderTexPointDensity *)MEM_callocN(
-      sizeof(NodeShaderTexPointDensity), "new pd node");
+  NodeShaderTexPointDensity *point_density = MEM_callocN(sizeof(NodeShaderTexPointDensity),
+                                                         "new pd node");
   point_density->resolution = 100;
   point_density->radius = 0.3f;
   point_density->space = SHD_POINTDENSITY_SPACE_OBJECT;
@@ -49,7 +47,7 @@ static void node_shader_init_tex_pointdensity(bNodeTree *UNUSED(ntree), bNode *n
 
 static void node_shader_free_tex_pointdensity(bNode *node)
 {
-  NodeShaderTexPointDensity *point_density = (NodeShaderTexPointDensity *)node->storage;
+  NodeShaderTexPointDensity *point_density = node->storage;
   PointDensity *pd = &point_density->pd;
   RE_point_density_free(pd);
   BKE_texture_pointdensity_free_data(pd);
@@ -62,28 +60,23 @@ static void node_shader_copy_tex_pointdensity(bNodeTree *UNUSED(dest_ntree),
                                               const bNode *src_node)
 {
   dest_node->storage = MEM_dupallocN(src_node->storage);
-  NodeShaderTexPointDensity *point_density = (NodeShaderTexPointDensity *)dest_node->storage;
+  NodeShaderTexPointDensity *point_density = dest_node->storage;
   PointDensity *pd = &point_density->pd;
   memset(pd, 0, sizeof(*pd));
 }
 
-}  // namespace blender::nodes::node_shader_tex_pointdensity_cc
-
 /* node type definition */
-void register_node_type_sh_tex_pointdensity()
+void register_node_type_sh_tex_pointdensity(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_pointdensity_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TEX_POINTDENSITY, "Point Density", NODE_CLASS_TEXTURE, 0);
-  node_type_socket_templates(
-      &ntype, file_ns::sh_node_tex_pointdensity_in, file_ns::sh_node_tex_pointdensity_out);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_pointdensity);
+  node_type_socket_templates(&ntype, sh_node_tex_pointdensity_in, sh_node_tex_pointdensity_out);
+  node_type_init(&ntype, node_shader_init_tex_pointdensity);
   node_type_storage(&ntype,
                     "NodeShaderTexPointDensity",
-                    file_ns::node_shader_free_tex_pointdensity,
-                    file_ns::node_shader_copy_tex_pointdensity);
+                    node_shader_free_tex_pointdensity,
+                    node_shader_copy_tex_pointdensity);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_sky.cc b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c
index 2ee271b5d24..5c581528c14 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_sky.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_sky.c
@@ -17,13 +17,11 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 #include "sky_model.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_tex_sky_cc {
-
 static bNodeSocketTemplate sh_node_tex_sky_in[] = {
     {SOCK_VECTOR, N_("Vector"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE, SOCK_HIDE_VALUE},
     {-1, ""},
@@ -36,7 +34,7 @@ static bNodeSocketTemplate sh_node_tex_sky_out[] = {
 
 static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeTexSky *tex = (NodeTexSky *)MEM_callocN(sizeof(NodeTexSky), "NodeTexSky");
+  NodeTexSky *tex = MEM_callocN(sizeof(NodeTexSky), "NodeTexSky");
   BKE_texture_mapping_default(&tex->base.tex_mapping, TEXMAP_TYPE_POINT);
   BKE_texture_colormapping_default(&tex->base.color_mapping);
   tex->sun_direction[0] = 0.0f;
@@ -57,10 +55,10 @@ static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode *node)
   node->storage = tex;
 }
 
-struct SkyModelPreetham {
+typedef struct SkyModelPreetham {
   float config_Y[5], config_x[5], config_y[5]; /* named after xyY color space */
   float radiance[3];
-};
+} SkyModelPreetham;
 
 static float sky_perez_function(const float *lam, float theta, float gamma)
 {
@@ -205,23 +203,19 @@ static void node_shader_update_sky(bNodeTree *ntree, bNode *node)
   nodeSetSocketAvailability(ntree, sockVector, !(tex->sky_model == 2 && tex->sun_disc == 1));
 }
 
-}  // namespace blender::nodes::node_shader_tex_sky_cc
-
 /* node type definition */
-void register_node_type_sh_tex_sky()
+void register_node_type_sh_tex_sky(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_sky_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_TEX_SKY, "Sky Texture", NODE_CLASS_TEXTURE, 0);
-  node_type_socket_templates(&ntype, file_ns::sh_node_tex_sky_in, file_ns::sh_node_tex_sky_out);
+  node_type_socket_templates(&ntype, sh_node_tex_sky_in, sh_node_tex_sky_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_sky);
+  node_type_init(&ntype, node_shader_init_tex_sky);
   node_type_storage(&ntype, "NodeTexSky", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_sky);
+  node_type_gpu(&ntype, node_shader_gpu_tex_sky);
   /* remove Vector input for Nishita */
-  node_type_update(&ntype, file_ns::node_shader_update_sky);
+  node_type_update(&ntype, node_shader_update_sky);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
index a1e54749b71..5d2654f61c8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
@@ -17,11 +17,11 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_noise.hh"
 
-namespace blender::nodes::node_shader_tex_voronoi_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_voronoi_declare(NodeDeclarationBuilder &b)
 {
@@ -47,6 +47,8 @@ static void sh_node_tex_voronoi_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Radius")).no_muted_links();
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexVoronoi *tex = (NodeTexVoronoi *)MEM_callocN(sizeof(NodeTexVoronoi), "NodeTexVoronoi");
@@ -163,6 +165,8 @@ static void node_shader_update_tex_voronoi(bNodeTree *ntree, bNode *node)
   nodeSetSocketAvailability(ntree, outRadiusSock, tex->feature == SHD_VORONOI_N_SPHERE_RADIUS);
 }
 
+namespace blender::nodes {
+
 static MultiFunction::ExecutionHints voronoi_execution_hints{50, false};
 
 class VoronoiMinowskiFunction : public fn::MultiFunction {
@@ -1317,22 +1321,20 @@ static void sh_node_voronoi_build_multi_function(blender::nodes::NodeMultiFuncti
   }
 }
 
-}  // namespace blender::nodes::node_shader_tex_voronoi_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_voronoi()
+void register_node_type_sh_tex_voronoi(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_voronoi_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_VORONOI, "Voronoi Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_voronoi_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_voronoi);
+  ntype.declare = blender::nodes::sh_node_tex_voronoi_declare;
+  node_type_init(&ntype, node_shader_init_tex_voronoi);
   node_type_storage(
       &ntype, "NodeTexVoronoi", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_voronoi);
-  node_type_update(&ntype, file_ns::node_shader_update_tex_voronoi);
-  ntype.build_multi_function = file_ns::sh_node_voronoi_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_voronoi);
+  node_type_update(&ntype, node_shader_update_tex_voronoi);
+  ntype.build_multi_function = blender::nodes::sh_node_voronoi_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc b/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
index bcb3091c1ce..fe534c605e9 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_wave.cc
@@ -17,11 +17,11 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_noise.hh"
 
-namespace blender::nodes::node_shader_tex_wave_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_wave_declare(NodeDeclarationBuilder &b)
 {
@@ -41,6 +41,8 @@ static void sh_node_tex_wave_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Fac")).no_muted_links();
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_wave(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTexWave *tex = (NodeTexWave *)MEM_callocN(sizeof(NodeTexWave), "NodeTexWave");
@@ -79,6 +81,8 @@ static int node_shader_gpu_tex_wave(GPUMaterial *mat,
                         GPU_constant(&wave_profile));
 }
 
+namespace blender::nodes {
+
 class WaveFunction : public fn::MultiFunction {
  private:
   int wave_type_;
@@ -212,21 +216,19 @@ static void sh_node_wave_tex_build_multi_function(
       tex->wave_type, tex->bands_direction, tex->rings_direction, tex->wave_profile);
 }
 
-}  // namespace blender::nodes::node_shader_tex_wave_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_wave()
+void register_node_type_sh_tex_wave(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_wave_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_TEX_WAVE, "Wave Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_wave_declare;
+  ntype.declare = blender::nodes::sh_node_tex_wave_declare;
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_tex_wave);
+  node_type_init(&ntype, node_shader_init_tex_wave);
   node_type_storage(&ntype, "NodeTexWave", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_tex_wave);
-  ntype.build_multi_function = file_ns::sh_node_wave_tex_build_multi_function;
+  node_type_gpu(&ntype, node_shader_gpu_tex_wave);
+  ntype.build_multi_function = blender::nodes::sh_node_wave_tex_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc b/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
index 5ea82991c25..7b4ff7fec5c 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_white_noise.cc
@@ -17,11 +17,11 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "BLI_noise.hh"
 
-namespace blender::nodes::node_shader_tex_white_noise_cc {
+namespace blender::nodes {
 
 static void sh_node_tex_white_noise_declare(NodeDeclarationBuilder &b)
 {
@@ -32,6 +32,8 @@ static void sh_node_tex_white_noise_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Color>(N_("Color"));
 };
 
+}  // namespace blender::nodes
+
 static void node_shader_init_tex_white_noise(bNodeTree *UNUSED(ntree), bNode *node)
 {
   node->custom1 = 3;
@@ -65,6 +67,8 @@ static void node_shader_update_tex_white_noise(bNodeTree *ntree, bNode *node)
   nodeSetSocketAvailability(ntree, sockW, node->custom1 == 1 || node->custom1 == 4);
 }
 
+namespace blender::nodes {
+
 class WhiteNoiseFunction : public fn::MultiFunction {
  private:
   int dimensions_;
@@ -185,21 +189,19 @@ static void sh_node_noise_build_multi_function(blender::nodes::NodeMultiFunction
   builder.construct_and_set_matching_fn<WhiteNoiseFunction>((int)node.custom1);
 }
 
-}  // namespace blender::nodes::node_shader_tex_white_noise_cc
+}  // namespace blender::nodes
 
-void register_node_type_sh_tex_white_noise()
+void register_node_type_sh_tex_white_noise(void)
 {
-  namespace file_ns = blender::nodes::node_shader_tex_white_noise_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(
       &ntype, SH_NODE_TEX_WHITE_NOISE, "White Noise Texture", NODE_CLASS_TEXTURE, 0);
-  ntype.declare = file_ns::sh_node_tex_white_noise_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_tex_white_noise);
-  node_type_gpu(&ntype, file_ns::gpu_shader_tex_white_noise);
-  node_type_update(&ntype, file_ns::node_shader_update_tex_white_noise);
-  ntype.build_multi_function = file_ns::sh_node_noise_build_multi_function;
+  ntype.declare = blender::nodes::sh_node_tex_white_noise_declare;
+  node_type_init(&ntype, node_shader_init_tex_white_noise);
+  node_type_gpu(&ntype, gpu_shader_tex_white_noise);
+  node_type_update(&ntype, node_shader_update_tex_white_noise);
+  ntype.build_multi_function = blender::nodes::sh_node_noise_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc b/source/blender/nodes/shader/nodes/node_shader_uvAlongStroke.c
index 8cb60199581..05c3248af65 100644
--- a/source/blender/nodes/shader/nodes/node_shader_uv_along_stroke.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_uvAlongStroke.c
@@ -17,29 +17,23 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_uv_along_stroke_cc {
-
 static bNodeSocketTemplate sh_node_uvalongstroke_out[] = {
     {SOCK_VECTOR, N_("UV"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {-1, ""},
 };
 
-}  // namespace blender::nodes::node_shader_uv_along_stroke_cc
-
 /* node type definition */
-void register_node_type_sh_uvalongstroke()
+void register_node_type_sh_uvalongstroke(void)
 {
-  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, nullptr, file_ns::sh_node_uvalongstroke_out);
-  node_type_init(&ntype, nullptr);
+  node_type_socket_templates(&ntype, NULL, sh_node_uvalongstroke_out);
+  node_type_init(&ntype, NULL);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_uvmap.cc b/source/blender/nodes/shader/nodes/node_shader_uvmap.c
index 12feb9c7d09..775b8ffbc06 100644
--- a/source/blender/nodes/shader/nodes/node_shader_uvmap.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_uvmap.c
@@ -17,14 +17,12 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 #include "DNA_customdata_types.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_uvmap_cc {
-
 static bNodeSocketTemplate sh_node_uvmap_out[] = {
     {SOCK_VECTOR, N_("UV"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {-1, ""},
@@ -32,8 +30,7 @@ static bNodeSocketTemplate sh_node_uvmap_out[] = {
 
 static void node_shader_init_uvmap(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderUVMap *attr = (NodeShaderUVMap *)MEM_callocN(sizeof(NodeShaderUVMap),
-                                                         "NodeShaderUVMap");
+  NodeShaderUVMap *attr = MEM_callocN(sizeof(NodeShaderUVMap), "NodeShaderUVMap");
   node->storage = attr;
 }
 
@@ -43,7 +40,7 @@ static int node_shader_gpu_uvmap(GPUMaterial *mat,
                                  GPUNodeStack *in,
                                  GPUNodeStack *out)
 {
-  NodeShaderUVMap *attr = (NodeShaderUVMap *)node->storage;
+  NodeShaderUVMap *attr = node->storage;
   GPUNodeLink *mtface = GPU_attribute(mat, CD_MTFACE, attr->uv_map);
 
   GPU_stack_link(mat, node, "node_uvmap", in, out, mtface);
@@ -53,22 +50,18 @@ 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 register_node_type_sh_uvmap(void)
 {
-  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, nullptr, file_ns::sh_node_uvmap_out);
+  node_type_socket_templates(&ntype, NULL, sh_node_uvmap_out);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, file_ns::node_shader_init_uvmap);
+  node_type_init(&ntype, node_shader_init_uvmap);
   node_type_storage(
       &ntype, "NodeShaderUVMap", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_uvmap);
+  node_type_gpu(&ntype, node_shader_gpu_uvmap);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc b/source/blender/nodes/shader/nodes/node_shader_valToRgb.cc
index 2bb3f2e08cf..e4f1b2c76f0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_color_ramp.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_valToRgb.cc
@@ -13,7 +13,7 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
- * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * The Original Code is Copyright (C) 2005 Blender Foundation.
  * All rights reserved.
  */
 
@@ -21,15 +21,17 @@
  * \ingroup shdnodes
  */
 
+#include "IMB_colormanagement.h"
+
 #include "DNA_texture_types.h"
 
 #include "BLI_color.hh"
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_color_ramp_cc {
+namespace blender::nodes {
 
-static void sh_node_color_ramp_declare(NodeDeclarationBuilder &b)
+static void sh_node_valtorgb_declare(NodeDeclarationBuilder &b)
 {
   b.is_function_node();
   b.add_input<decl::Float>(N_("Fac")).default_value(0.5f).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
@@ -37,12 +39,14 @@ static void sh_node_color_ramp_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Alpha"));
 };
 
-static void node_shader_exec_color_ramp(void *UNUSED(data),
-                                        int UNUSED(thread),
-                                        bNode *node,
-                                        bNodeExecData *UNUSED(execdata),
-                                        bNodeStack **in,
-                                        bNodeStack **out)
+}  // namespace blender::nodes
+
+static void node_shader_exec_valtorgb(void *UNUSED(data),
+                                      int UNUSED(thread),
+                                      bNode *node,
+                                      bNodeExecData *UNUSED(execdata),
+                                      bNodeStack **in,
+                                      bNodeStack **out)
 {
   /* stack order in: fac */
   /* stack order out: col, alpha */
@@ -56,16 +60,16 @@ static void node_shader_exec_color_ramp(void *UNUSED(data),
   }
 }
 
-static void node_shader_init_color_ramp(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_shader_init_valtorgb(bNodeTree *UNUSED(ntree), bNode *node)
 {
   node->storage = BKE_colorband_add(true);
 }
 
-static int gpu_shader_color_ramp(GPUMaterial *mat,
-                                 bNode *node,
-                                 bNodeExecData *UNUSED(execdata),
-                                 GPUNodeStack *in,
-                                 GPUNodeStack *out)
+static int gpu_shader_valtorgb(GPUMaterial *mat,
+                               bNode *node,
+                               bNodeExecData *UNUSED(execdata),
+                               GPUNodeStack *in,
+                               GPUNodeStack *out)
 {
   struct ColorBand *coba = (ColorBand *)node->storage;
   float *array, layer;
@@ -160,7 +164,7 @@ class ColorBandFunction : public blender::fn::MultiFunction {
   }
 };
 
-static void sh_node_color_ramp_build_multi_function(
+static void sh_node_valtorgb_build_multi_function(
     blender::nodes::NodeMultiFunctionBuilder &builder)
 {
   bNode &bnode = builder.node();
@@ -168,22 +172,64 @@ static void sh_node_color_ramp_build_multi_function(
   builder.construct_and_set_matching_fn<ColorBandFunction>(*color_band);
 }
 
-}  // namespace blender::nodes::node_shader_color_ramp_cc
-
-void register_node_type_sh_color_ramp()
+void register_node_type_sh_valtorgb(void)
 {
-  namespace file_ns = blender::nodes::node_shader_color_ramp_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_VALTORGB, "ColorRamp", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = file_ns::sh_node_color_ramp_declare;
-  node_type_init(&ntype, file_ns::node_shader_init_color_ramp);
+  ntype.declare = blender::nodes::sh_node_valtorgb_declare;
+  node_type_init(&ntype, node_shader_init_valtorgb);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
   node_type_storage(&ntype, "ColorBand", node_free_standard_storage, node_copy_standard_storage);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_color_ramp);
-  node_type_gpu(&ntype, file_ns::gpu_shader_color_ramp);
-  ntype.build_multi_function = file_ns::sh_node_color_ramp_build_multi_function;
+  node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_valtorgb);
+  node_type_gpu(&ntype, gpu_shader_valtorgb);
+  ntype.build_multi_function = sh_node_valtorgb_build_multi_function;
+
+  nodeRegisterType(&ntype);
+}
+
+namespace blender::nodes {
+
+static void sh_node_rgbtobw_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Color>(N_("Color")).default_value({0.5f, 0.5f, 0.5f, 1.0f});
+  b.add_output<decl::Float>(N_("Val"));
+};
+
+}  // namespace blender::nodes
+
+static void node_shader_exec_rgbtobw(void *UNUSED(data),
+                                     int UNUSED(thread),
+                                     bNode *UNUSED(node),
+                                     bNodeExecData *UNUSED(execdata),
+                                     bNodeStack **in,
+                                     bNodeStack **out)
+{
+  /* Stack order out: BW. */
+  /* Stack order in: COL. */
+  float col[3];
+  nodestack_get_vec(col, SOCK_VECTOR, in[0]);
+
+  out[0]->vec[0] = IMB_colormanagement_get_luminance(col);
+}
+
+static int gpu_shader_rgbtobw(GPUMaterial *mat,
+                              bNode *node,
+                              bNodeExecData *UNUSED(execdata),
+                              GPUNodeStack *in,
+                              GPUNodeStack *out)
+{
+  return GPU_stack_link(mat, node, "rgbtobw", in, out);
+}
+
+void register_node_type_sh_rgbtobw(void)
+{
+  static bNodeType ntype;
+
+  sh_node_type_base(&ntype, SH_NODE_RGBTOBW, "RGB to BW", NODE_CLASS_CONVERTER, 0);
+  ntype.declare = blender::nodes::sh_node_rgbtobw_declare;
+  node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_rgbtobw);
+  node_type_gpu(&ntype, gpu_shader_rgbtobw);
 
   nodeRegisterType(&ntype);
-}
\ No newline at end of file
+}
diff --git a/source/blender/nodes/shader/nodes/node_shader_value.cc b/source/blender/nodes/shader/nodes/node_shader_value.cc
index 9ff523f42f7..b0f152d8526 100644
--- a/source/blender/nodes/shader/nodes/node_shader_value.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_value.cc
@@ -21,15 +21,17 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
-namespace blender::nodes::node_shader_value_cc {
+namespace blender::nodes {
 
 static void sh_node_value_declare(NodeDeclarationBuilder &b)
 {
   b.add_output<decl::Float>(N_("Value"));
 };
 
+}  // namespace blender::nodes
+
 static int gpu_shader_value(GPUMaterial *mat,
                             bNode *node,
                             bNodeExecData *UNUSED(execdata),
@@ -47,18 +49,14 @@ static void sh_node_value_build_multi_function(blender::nodes::NodeMultiFunction
   builder.construct_and_set_matching_fn<blender::fn::CustomMF_Constant<float>>(value->value);
 }
 
-}  // namespace blender::nodes::node_shader_value_cc
-
-void register_node_type_sh_value()
+void register_node_type_sh_value(void)
 {
-  namespace file_ns = blender::nodes::node_shader_value_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_VALUE, "Value", NODE_CLASS_INPUT, 0);
-  ntype.declare = file_ns::sh_node_value_declare;
-  node_type_gpu(&ntype, file_ns::gpu_shader_value);
-  ntype.build_multi_function = file_ns::sh_node_value_build_multi_function;
+  ntype.declare = blender::nodes::sh_node_value_declare;
+  node_type_gpu(&ntype, gpu_shader_value);
+  ntype.build_multi_function = sh_node_value_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc b/source/blender/nodes/shader/nodes/node_shader_vectTransform.c
index d354b579c36..7b08178f874 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_transform.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vectTransform.c
@@ -21,12 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** Vector Transform ******************** */
-
-namespace blender::nodes::node_shader_vector_transform_cc {
-
 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, ""}};
 
@@ -37,8 +34,8 @@ static bNodeSocketTemplate sh_node_vect_transform_out[] = {
 
 static void node_shader_init_vect_transform(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderVectTransform *vect = (NodeShaderVectTransform *)MEM_callocN(
-      sizeof(NodeShaderVectTransform), "NodeShaderVectTransform");
+  NodeShaderVectTransform *vect = MEM_callocN(sizeof(NodeShaderVectTransform),
+                                              "NodeShaderVectTransform");
 
   /* Convert World into Object Space per default */
   vect->convert_to = 1;
@@ -61,7 +58,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 nullptr;
+          return NULL;
         case SHD_VECT_TRANSFORM_SPACE_WORLD:
           return GPU_builtin(GPU_OBJECT_MATRIX);
         case SHD_VECT_TRANSFORM_SPACE_CAMERA:
@@ -71,7 +68,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 nullptr;
+          return NULL;
         case SHD_VECT_TRANSFORM_SPACE_CAMERA:
           return GPU_builtin(GPU_VIEW_MATRIX);
         case SHD_VECT_TRANSFORM_SPACE_OBJECT:
@@ -81,7 +78,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 nullptr;
+          return NULL;
         case SHD_VECT_TRANSFORM_SPACE_WORLD:
           return GPU_builtin(GPU_INVERSE_VIEW_MATRIX);
         case SHD_VECT_TRANSFORM_SPACE_OBJECT:
@@ -89,7 +86,7 @@ static GPUNodeLink *get_gpulink_matrix_from_to(short from, short to)
       }
       break;
   }
-  return nullptr;
+  return NULL;
 }
 static int gpu_shader_vect_transform(GPUMaterial *mat,
                                      bNode *node,
@@ -102,7 +99,7 @@ static int gpu_shader_vect_transform(GPUMaterial *mat,
 
   const char *vtransform = "direction_transform_m4v3";
   const char *ptransform = "point_transform_m4v3";
-  const char *func_name = nullptr;
+  const char *func_name = 0;
 
   NodeShaderVectTransform *nodeprop = (NodeShaderVectTransform *)node->storage;
 
@@ -140,22 +137,17 @@ static int gpu_shader_vect_transform(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_vector_transform_cc
-
-void register_node_type_sh_vect_transform()
+void register_node_type_sh_vect_transform(void)
 {
-  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, 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_init(&ntype, node_shader_init_vect_transform);
+  node_type_socket_templates(&ntype, sh_node_vect_transform_in, sh_node_vect_transform_out);
   node_type_storage(
       &ntype, "NodeShaderVectTransform", node_free_standard_storage, node_copy_standard_storage);
-  node_type_exec(&ntype, nullptr, nullptr, file_ns::node_shader_exec_vect_transform);
-  node_type_gpu(&ntype, file_ns::gpu_shader_vect_transform);
+  node_type_exec(&ntype, NULL, NULL, node_shader_exec_vect_transform);
+  node_type_gpu(&ntype, gpu_shader_vect_transform);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc b/source/blender/nodes/shader/nodes/node_shader_vector_displacement.c
index 9683f889134..0e82f346529 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_displacement.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_displacement.c
@@ -17,12 +17,10 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_vector_displacement_cc {
-
 static bNodeSocketTemplate sh_node_vector_displacement_in[] = {
     {SOCK_RGBA, N_("Vector"), 0.00f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f, PROP_NONE, SOCK_HIDE_VALUE},
     {SOCK_FLOAT, N_("Midlevel"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
@@ -65,22 +63,18 @@ 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 register_node_type_sh_vector_displacement(void)
 {
-  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, file_ns::sh_node_vector_displacement_in, file_ns::sh_node_vector_displacement_out);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_init(&ntype, file_ns::node_shader_init_vector_displacement);
-  node_type_gpu(&ntype, file_ns::gpu_shader_vector_displacement);
+      &ntype, sh_node_vector_displacement_in, sh_node_vector_displacement_out);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_init(&ntype, node_shader_init_vector_displacement);
+  node_type_gpu(&ntype, gpu_shader_vector_displacement);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_math.cc b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
index 3a5cbad70dc..9b1b2467230 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
@@ -21,11 +21,11 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "node_shader_util.h"
 
 #include "NOD_math_functions.hh"
 
-namespace blender::nodes::node_vector_math_shader_cc {
+namespace blender::nodes {
 
 static void sh_node_vector_math_declare(NodeDeclarationBuilder &b)
 {
@@ -38,6 +38,8 @@ static void sh_node_vector_math_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Float>(N_("Value"));
 };
 
+}  // namespace blender::nodes
+
 static const char *gpu_shader_get_name(int mode)
 {
   switch (mode) {
@@ -277,20 +279,16 @@ static void sh_node_vector_math_build_multi_function(
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes::node_vector_math_shader_cc
-
-void register_node_type_sh_vect_math()
+void register_node_type_sh_vect_math(void)
 {
-  namespace file_ns = blender::nodes::node_vector_math_shader_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_VECTOR_MATH, "Vector Math", NODE_CLASS_OP_VECTOR, 0);
-  ntype.declare = file_ns::sh_node_vector_math_declare;
+  ntype.declare = blender::nodes::sh_node_vector_math_declare;
   node_type_label(&ntype, node_vector_math_label);
-  node_type_gpu(&ntype, file_ns::gpu_shader_vector_math);
-  node_type_update(&ntype, file_ns::node_shader_update_vector_math);
-  ntype.build_multi_function = file_ns::sh_node_vector_math_build_multi_function;
+  node_type_gpu(&ntype, gpu_shader_vector_math);
+  node_type_update(&ntype, node_shader_update_vector_math);
+  ntype.build_multi_function = sh_node_vector_math_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc b/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc
index 108d6d6bc4f..3c1f1ed8d39 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc
@@ -21,9 +21,9 @@
  * \ingroup shdnodes
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
-namespace blender::nodes::node_shader_vector_rotate_cc {
+namespace blender::nodes {
 
 static void sh_node_vector_rotate_declare(NodeDeclarationBuilder &b)
 {
@@ -36,6 +36,8 @@ static void sh_node_vector_rotate_declare(NodeDeclarationBuilder &b)
   b.add_output<decl::Vector>(N_("Vector"));
 };
 
+}  // namespace blender::nodes
+
 static const char *gpu_shader_get_name(int mode)
 {
   switch (mode) {
@@ -203,19 +205,15 @@ static void node_shader_update_vector_rotate(bNodeTree *ntree, bNode *node)
       ntree, sock_angle, !ELEM(node->custom1, NODE_VECTOR_ROTATE_TYPE_EULER_XYZ));
 }
 
-}  // namespace blender::nodes::node_shader_vector_rotate_cc
-
-void register_node_type_sh_vector_rotate()
+void register_node_type_sh_vector_rotate(void)
 {
-  namespace file_ns = blender::nodes::node_shader_vector_rotate_cc;
-
   static bNodeType ntype;
 
   sh_fn_node_type_base(&ntype, SH_NODE_VECTOR_ROTATE, "Vector Rotate", NODE_CLASS_OP_VECTOR, 0);
-  ntype.declare = file_ns::sh_node_vector_rotate_declare;
-  node_type_gpu(&ntype, file_ns::gpu_shader_vector_rotate);
-  node_type_update(&ntype, file_ns::node_shader_update_vector_rotate);
-  ntype.build_multi_function = file_ns::sh_node_vector_rotate_build_multi_function;
+  ntype.declare = blender::nodes::sh_node_vector_rotate_declare;
+  node_type_gpu(&ntype, gpu_shader_vector_rotate);
+  node_type_update(&ntype, node_shader_update_vector_rotate);
+  ntype.build_multi_function = sh_node_vector_rotate_build_multi_function;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc b/source/blender/nodes/shader/nodes/node_shader_vertex_color.c
index 739030d89c7..40576b68dd5 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vertex_color.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vertex_color.c
@@ -17,9 +17,7 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_vertex_color_cc {
+#include "../node_shader_util.h"
 
 static bNodeSocketTemplate sh_node_vertex_color_out[] = {
     {SOCK_RGBA, N_("Color")},
@@ -29,8 +27,8 @@ static bNodeSocketTemplate sh_node_vertex_color_out[] = {
 
 static void node_shader_init_vertex_color(bNodeTree *UNUSED(ntree), bNode *node)
 {
-  NodeShaderVertexColor *vertexColor = (NodeShaderVertexColor *)MEM_callocN(
-      sizeof(NodeShaderVertexColor), "NodeShaderVertexColor");
+  NodeShaderVertexColor *vertexColor = MEM_callocN(sizeof(NodeShaderVertexColor),
+                                                   "NodeShaderVertexColor");
   node->storage = vertexColor;
 }
 
@@ -49,20 +47,16 @@ static int node_shader_gpu_vertex_color(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_vertex_color", in, out, vertexColorLink);
 }
 
-}  // namespace blender::nodes::node_shader_vertex_color_cc
-
-void register_node_type_sh_vertex_color()
+void register_node_type_sh_vertex_color(void)
 {
-  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, nullptr, file_ns::sh_node_vertex_color_out);
-  node_type_init(&ntype, file_ns::node_shader_init_vertex_color);
+  node_type_socket_templates(&ntype, NULL, sh_node_vertex_color_out);
+  node_type_init(&ntype, node_shader_init_vertex_color);
   node_type_storage(
       &ntype, "NodeShaderVertexColor", node_free_standard_storage, node_copy_standard_storage);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_vertex_color);
+  node_type_gpu(&ntype, node_shader_gpu_vertex_color);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc b/source/blender/nodes/shader/nodes/node_shader_volume_absorption.c
index 550530b4bc0..abf2e63e6d5 100644
--- a/source/blender/nodes/shader/nodes/node_shader_volume_absorption.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_volume_absorption.c
@@ -17,18 +17,20 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_volume_absorption_cc {
+static bNodeSocketTemplate sh_node_volume_absorption_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Density"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Density")).default_value(1.0f).min(0.0f).max(1000.0f);
-  b.add_output<decl::Shader>(N_("Volume"));
-}
+static bNodeSocketTemplate sh_node_volume_absorption_out[] = {
+    {SOCK_SHADER, N_("Volume")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_volume_absorption(GPUMaterial *mat,
                                              bNode *node,
@@ -39,20 +41,16 @@ static int node_shader_gpu_volume_absorption(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_volume_absorption", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_volume_absorption_cc
-
 /* node type definition */
-void register_node_type_sh_volume_absorption()
+void register_node_type_sh_volume_absorption(void)
 {
-  namespace file_ns = blender::nodes::node_shader_volume_absorption_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_VOLUME_ABSORPTION, "Volume Absorption", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_absorption);
+  node_type_socket_templates(&ntype, sh_node_volume_absorption_in, sh_node_volume_absorption_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_volume_absorption);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_info.cc b/source/blender/nodes/shader/nodes/node_shader_volume_info.c
index dc556809fe6..6cafc991e13 100644
--- a/source/blender/nodes/shader/nodes/node_shader_volume_info.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_volume_info.c
@@ -17,9 +17,7 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
-
-namespace blender::nodes::node_shader_volume_info_cc {
+#include "../node_shader_util.h"
 
 static bNodeSocketTemplate sh_node_volume_info_out[] = {
     {SOCK_RGBA, N_("Color")},
@@ -51,17 +49,13 @@ static int node_shader_gpu_volume_info(GPUMaterial *mat,
   return true;
 }
 
-}  // namespace blender::nodes::node_shader_volume_info_cc
-
-void register_node_type_sh_volume_info()
+void register_node_type_sh_volume_info(void)
 {
-  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, nullptr, file_ns::sh_node_volume_info_out);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_info);
+  node_type_socket_templates(&ntype, NULL, sh_node_volume_info_out);
+  node_type_gpu(&ntype, node_shader_gpu_volume_info);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_principled.cc b/source/blender/nodes/shader/nodes/node_shader_volume_principled.c
index bdba452ccb2..1a25aec5cb8 100644
--- a/source/blender/nodes/shader/nodes/node_shader_volume_principled.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_volume_principled.c
@@ -17,28 +17,30 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_volume_principled_cc {
-
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.5f, 0.5f, 0.5f, 1.0f});
-  b.add_input<decl::String>(N_("Color Attribute"));
-  b.add_input<decl::Float>(N_("Density")).default_value(1.0f).min(0.0f).max(1000.0f);
-  b.add_input<decl::String>(N_("Density Attribute"));
-  b.add_input<decl::Float>(N_("Anisotropy")).min(-1.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Color>(N_("Absorption Color"));
-  b.add_input<decl::Float>(N_("Emission Strength")).min(0.0f).max(1000.0f);
-  b.add_input<decl::Color>(N_("Emission Color")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
-  b.add_input<decl::Float>(N_("Blackbody Intensity")).min(0.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_input<decl::Color>(N_("Blackbody Tint")).default_value({1.0f, 1.0f, 1.0f, 1.0f});
-  b.add_input<decl::Float>(N_("Temperature")).default_value(1000.0f).min(0.0f).max(6500.0f);
-  b.add_input<decl::String>(N_("Temperature Attribute"));
-  b.add_output<decl::Shader>(N_("Volume"));
-}
+static bNodeSocketTemplate sh_node_volume_principled_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 1.0f},
+    {SOCK_STRING, N_("Color Attribute"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Density"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_STRING, N_("Density Attribute"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Anisotropy"), 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, PROP_FACTOR},
+    {SOCK_RGBA, N_("Absorption Color"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Emission Strength"), 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1000.0f},
+    {SOCK_RGBA, N_("Emission Color"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Blackbody Intensity"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
+    {SOCK_RGBA, N_("Blackbody Tint"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Temperature"), 1000.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6500.0f},
+    {SOCK_STRING, N_("Temperature Attribute"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+    {-1, ""},
+};
+
+static bNodeSocketTemplate sh_node_volume_principled_out[] = {
+    {SOCK_SHADER, N_("Volume")},
+    {-1, ""},
+};
 
 static void node_shader_init_volume_principled(bNodeTree *UNUSED(ntree), bNode *node)
 {
@@ -62,14 +64,14 @@ static int node_shader_gpu_volume_principled(GPUMaterial *mat,
   bool use_blackbody = (in[8].link || in[8].vec[0] != 0.0f);
 
   /* Get volume attributes. */
-  GPUNodeLink *density = nullptr, *color = nullptr, *temperature = nullptr;
+  GPUNodeLink *density = NULL, *color = NULL, *temperature = NULL;
 
   LISTBASE_FOREACH (bNodeSocket *, sock, &node->inputs) {
     if (sock->typeinfo->type != SOCK_STRING) {
       continue;
     }
 
-    bNodeSocketValueString *value = (bNodeSocketValueString *)sock->default_value;
+    bNodeSocketValueString *value = sock->default_value;
     const char *attribute_name = value->value;
     if (attribute_name[0] == '\0') {
       continue;
@@ -104,11 +106,11 @@ static int node_shader_gpu_volume_principled(GPUMaterial *mat,
   const int size = CM_TABLE + 1;
   float *data, layer;
   if (use_blackbody) {
-    data = (float *)MEM_mallocN(sizeof(float) * size * 4, "blackbody texture");
+    data = MEM_mallocN(sizeof(float) * size * 4, "blackbody texture");
     blackbody_temperature_to_rgb_table(data, size, 965.0f, 12000.0f);
   }
   else {
-    data = (float *)MEM_callocN(sizeof(float) * size * 4, "blackbody black");
+    data = MEM_callocN(sizeof(float) * size * 4, "blackbody black");
   }
   GPUNodeLink *spectrummap = GPU_color_band(mat, size, data, &layer);
 
@@ -124,21 +126,17 @@ static int node_shader_gpu_volume_principled(GPUMaterial *mat,
                         GPU_constant(&layer));
 }
 
-}  // namespace blender::nodes::node_shader_volume_principled_cc
-
 /* node type definition */
-void register_node_type_sh_volume_principled()
+void register_node_type_sh_volume_principled(void)
 {
-  namespace file_ns = blender::nodes::node_shader_volume_principled_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_VOLUME_PRINCIPLED, "Principled Volume", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
+  node_type_socket_templates(&ntype, sh_node_volume_principled_in, sh_node_volume_principled_out);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  node_type_init(&ntype, file_ns::node_shader_init_volume_principled);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_principled);
+  node_type_init(&ntype, node_shader_init_volume_principled);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_volume_principled);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc b/source/blender/nodes/shader/nodes/node_shader_volume_scatter.c
index 736707ab55d..f4cfe7729ca 100644
--- a/source/blender/nodes/shader/nodes/node_shader_volume_scatter.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_volume_scatter.c
@@ -17,19 +17,21 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** OUTPUT ******************** */
 
-namespace blender::nodes::node_shader_volume_scatter_cc {
+static bNodeSocketTemplate sh_node_volume_scatter_in[] = {
+    {SOCK_RGBA, N_("Color"), 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
+    {SOCK_FLOAT, N_("Density"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1000.0f},
+    {SOCK_FLOAT, N_("Anisotropy"), 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, PROP_FACTOR},
+    {-1, ""},
+};
 
-static void node_declare(NodeDeclarationBuilder &b)
-{
-  b.add_input<decl::Color>(N_("Color")).default_value({0.8f, 0.8f, 0.8f, 1.0f});
-  b.add_input<decl::Float>(N_("Density")).default_value(1.0f).min(0.0f).max(1000.0f);
-  b.add_input<decl::Float>(N_("Anisotropy")).min(-1.0f).max(1.0f).subtype(PROP_FACTOR);
-  b.add_output<decl::Shader>(N_("Volume"));
-}
+static bNodeSocketTemplate sh_node_volume_scatter_out[] = {
+    {SOCK_SHADER, N_("Volume")},
+    {-1, ""},
+};
 
 static int node_shader_gpu_volume_scatter(GPUMaterial *mat,
                                           bNode *node,
@@ -40,20 +42,16 @@ static int node_shader_gpu_volume_scatter(GPUMaterial *mat,
   return GPU_stack_link(mat, node, "node_volume_scatter", in, out);
 }
 
-}  // namespace blender::nodes::node_shader_volume_scatter_cc
-
 /* node type definition */
-void register_node_type_sh_volume_scatter()
+void register_node_type_sh_volume_scatter(void)
 {
-  namespace file_ns = blender::nodes::node_shader_volume_scatter_cc;
-
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_VOLUME_SCATTER, "Volume Scatter", NODE_CLASS_SHADER, 0);
-  ntype.declare = file_ns::node_declare;
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_volume_scatter);
+  node_type_socket_templates(&ntype, sh_node_volume_scatter_in, sh_node_volume_scatter_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_volume_scatter);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_wavelength.cc b/source/blender/nodes/shader/nodes/node_shader_wavelength.c
index 8798b1c8e06..f978537ee85 100644
--- a/source/blender/nodes/shader/nodes/node_shader_wavelength.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_wavelength.c
@@ -17,12 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** Wavelength ******************** */
-
-namespace blender::nodes::node_shader_wavelength_cc {
-
 static bNodeSocketTemplate sh_node_wavelength_in[] = {
     {SOCK_FLOAT, N_("Wavelength"), 500.0f, 0.0f, 0.0f, 0.0f, 380.0f, 780.0f},
     {-1, ""},
@@ -40,7 +37,7 @@ static int node_shader_gpu_wavelength(GPUMaterial *mat,
                                       GPUNodeStack *out)
 {
   const int size = CM_TABLE + 1;
-  float *data = (float *)MEM_mallocN(sizeof(float) * size * 4, "cie_xyz texture");
+  float *data = MEM_mallocN(sizeof(float) * size * 4, "cie_xyz texture");
 
   wavelength_to_xyz_table(data, size);
 
@@ -60,22 +57,17 @@ 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 register_node_type_sh_wavelength(void)
 {
-  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, file_ns::sh_node_wavelength_in, file_ns::sh_node_wavelength_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_wavelength);
+  node_type_socket_templates(&ntype, sh_node_wavelength_in, sh_node_wavelength_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_wavelength);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_wireframe.cc b/source/blender/nodes/shader/nodes/node_shader_wireframe.c
index bd4d3adfde9..37e60ddb205 100644
--- a/source/blender/nodes/shader/nodes/node_shader_wireframe.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_wireframe.c
@@ -17,12 +17,9 @@
  * All rights reserved.
  */
 
-#include "node_shader_util.hh"
+#include "../node_shader_util.h"
 
 /* **************** Wireframe ******************** */
-
-namespace blender::nodes::node_shader_wireframe_cc {
-
 static bNodeSocketTemplate sh_node_wireframe_in[] = {
     {SOCK_FLOAT, N_("Size"), 0.01f, 0.0f, 0.0f, 0.0f, 0.0f, 100.0f},
     {-1, ""},
@@ -55,21 +52,16 @@ 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 register_node_type_sh_wireframe(void)
 {
-  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, file_ns::sh_node_wireframe_in, file_ns::sh_node_wireframe_out);
-  node_type_init(&ntype, nullptr);
-  node_type_storage(&ntype, "", nullptr, nullptr);
-  node_type_gpu(&ntype, file_ns::node_shader_gpu_wireframe);
+  node_type_socket_templates(&ntype, sh_node_wireframe_in, sh_node_wireframe_out);
+  node_type_init(&ntype, NULL);
+  node_type_storage(&ntype, "", NULL, NULL);
+  node_type_gpu(&ntype, node_shader_gpu_wireframe);
 
   nodeRegisterType(&ntype);
 }