prepare for unity builds

69 files changed, 768 insertions, 934 deletions

diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc
index 0827a15dea0..912543e5a88 100644
--- a/source/blender/blenkernel/intern/node.cc
+++ b/source/blender/blenkernel/intern/node.cc
@@ -5703,52 +5703,52 @@ static void registerShaderNodes()
 
 static void registerTextureNodes()
 {
-  register_node_type_tex_group();
-
-  register_node_type_tex_math();
-  register_node_type_tex_mix_rgb();
-  register_node_type_tex_valtorgb();
-  register_node_type_tex_rgbtobw();
-  register_node_type_tex_valtonor();
-  register_node_type_tex_curve_rgb();
-  register_node_type_tex_curve_time();
-  register_node_type_tex_invert();
-  register_node_type_tex_hue_sat();
-  register_node_type_tex_coord();
-  register_node_type_tex_distance();
-  register_node_type_tex_compose();
-  register_node_type_tex_decompose();
-
-  register_node_type_tex_output();
-  register_node_type_tex_viewer();
-  register_node_type_sh_script();
-  register_node_type_sh_tangent();
-  register_node_type_sh_normal_map();
-  register_node_type_sh_hair_info();
-  register_node_type_sh_volume_info();
-
-  register_node_type_tex_checker();
-  register_node_type_tex_texture();
-  register_node_type_tex_bricks();
-  register_node_type_tex_image();
-  register_node_type_sh_bsdf_refraction();
-  register_node_type_sh_ambient_occlusion();
-
-  register_node_type_tex_rotate();
-  register_node_type_tex_translate();
-  register_node_type_tex_scale();
-  register_node_type_tex_at();
-
-  register_node_type_tex_proc_voronoi();
-  register_node_type_tex_proc_blend();
-  register_node_type_tex_proc_magic();
-  register_node_type_tex_proc_marble();
-  register_node_type_tex_proc_clouds();
-  register_node_type_tex_proc_wood();
-  register_node_type_tex_proc_musgrave();
-  register_node_type_tex_proc_noise();
-  register_node_type_tex_proc_stucci();
-  register_node_type_tex_proc_distnoise();
+  // register_node_type_tex_group();
+
+  // register_node_type_tex_math();
+  // register_node_type_tex_mix_rgb();
+  // register_node_type_tex_valtorgb();
+  // register_node_type_tex_rgbtobw();
+  // register_node_type_tex_valtonor();
+  // register_node_type_tex_curve_rgb();
+  // register_node_type_tex_curve_time();
+  // register_node_type_tex_invert();
+  // register_node_type_tex_hue_sat();
+  // register_node_type_tex_coord();
+  // register_node_type_tex_distance();
+  // register_node_type_tex_compose();
+  // register_node_type_tex_decompose();
+
+  // register_node_type_tex_output();
+  // register_node_type_tex_viewer();
+  // register_node_type_sh_script();
+  // register_node_type_sh_tangent();
+  // register_node_type_sh_normal_map();
+  // register_node_type_sh_hair_info();
+  // register_node_type_sh_volume_info();
+
+  // register_node_type_tex_checker();
+  // register_node_type_tex_texture();
+  // register_node_type_tex_bricks();
+  // register_node_type_tex_image();
+  // register_node_type_sh_bsdf_refraction();
+  // register_node_type_sh_ambient_occlusion();
+
+  // register_node_type_tex_rotate();
+  // register_node_type_tex_translate();
+  // register_node_type_tex_scale();
+  // register_node_type_tex_at();
+
+  // register_node_type_tex_proc_voronoi();
+  // register_node_type_tex_proc_blend();
+  // register_node_type_tex_proc_magic();
+  // register_node_type_tex_proc_marble();
+  // register_node_type_tex_proc_clouds();
+  // register_node_type_tex_proc_wood();
+  // register_node_type_tex_proc_musgrave();
+  // register_node_type_tex_proc_noise();
+  // register_node_type_tex_proc_stucci();
+  // register_node_type_tex_proc_distnoise();
 }
 
 static void registerGeometryNodes()
diff --git a/source/blender/nodes/CMakeLists.txt b/source/blender/nodes/CMakeLists.txt
index f4ca9f51b1b..19935bebaea 100644
--- a/source/blender/nodes/CMakeLists.txt
+++ b/source/blender/nodes/CMakeLists.txt
@@ -389,29 +389,29 @@ set(SRC
   shader/node_shader_tree.c
   shader/node_shader_util.c
 
-  texture/nodes/node_texture_at.c
-  texture/nodes/node_texture_bricks.c
-  texture/nodes/node_texture_checker.c
-  texture/nodes/node_texture_common.c
-  texture/nodes/node_texture_compose.c
-  texture/nodes/node_texture_coord.c
-  texture/nodes/node_texture_curves.c
-  texture/nodes/node_texture_decompose.c
-  texture/nodes/node_texture_distance.c
-  texture/nodes/node_texture_hueSatVal.c
-  texture/nodes/node_texture_image.c
-  texture/nodes/node_texture_invert.c
-  texture/nodes/node_texture_math.c
-  texture/nodes/node_texture_mixRgb.c
-  texture/nodes/node_texture_output.c
-  texture/nodes/node_texture_proc.c
-  texture/nodes/node_texture_rotate.c
-  texture/nodes/node_texture_scale.c
-  texture/nodes/node_texture_texture.c
-  texture/nodes/node_texture_translate.c
-  texture/nodes/node_texture_valToNor.c
-  texture/nodes/node_texture_valToRgb.c
-  texture/nodes/node_texture_viewer.c
+  # texture/nodes/node_texture_at.c
+  # texture/nodes/node_texture_bricks.c
+  # texture/nodes/node_texture_checker.c
+  # texture/nodes/node_texture_common.c
+  # texture/nodes/node_texture_compose.c
+  # texture/nodes/node_texture_coord.c
+  # texture/nodes/node_texture_curves.c
+  # texture/nodes/node_texture_decompose.c
+  # texture/nodes/node_texture_distance.c
+  # texture/nodes/node_texture_hueSatVal.c
+  # texture/nodes/node_texture_image.c
+  # texture/nodes/node_texture_invert.c
+  # texture/nodes/node_texture_math.c
+  # texture/nodes/node_texture_mixRgb.c
+  # texture/nodes/node_texture_output.c
+  # texture/nodes/node_texture_proc.c
+  # texture/nodes/node_texture_rotate.c
+  # texture/nodes/node_texture_scale.c
+  # texture/nodes/node_texture_texture.c
+  # texture/nodes/node_texture_translate.c
+  # texture/nodes/node_texture_valToNor.c
+  # texture/nodes/node_texture_valToRgb.c
+  # texture/nodes/node_texture_viewer.c
   texture/node_texture_tree.c
   texture/node_texture_util.c
 
diff --git a/source/blender/nodes/composite/nodes/node_composite_movieclip.cc b/source/blender/nodes/composite/nodes/node_composite_movieclip.cc
index 5d63a1b8002..bf7e9d6d3ec 100644
--- a/source/blender/nodes/composite/nodes/node_composite_movieclip.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_movieclip.cc
@@ -40,7 +40,7 @@ static void cmp_node_movieclip_declare(NodeDeclarationBuilder &b)
 
 }  // namespace blender::nodes
 
-static void init(const bContext *C, PointerRNA *ptr)
+static void cmp_node_movieclip_init(const bContext *C, PointerRNA *ptr)
 {
   bNode *node = (bNode *)ptr->data;
   Scene *scene = CTX_data_scene(C);
@@ -59,7 +59,7 @@ void register_node_type_cmp_movieclip(void)
 
   cmp_node_type_base(&ntype, CMP_NODE_MOVIECLIP, "Movie Clip", NODE_CLASS_INPUT, NODE_PREVIEW);
   ntype.declare = blender::nodes::cmp_node_movieclip_declare;
-  ntype.initfunc_api = init;
+  ntype.initfunc_api = cmp_node_movieclip_init;
   node_type_storage(
       &ntype, "MovieClipUser", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc
index 2bac30cc152..e4bb19df3d6 100644
--- a/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_moviedistortion.cc
@@ -38,7 +38,10 @@ static bNodeSocketTemplate cmp_node_moviedistortion_out[] = {
     {-1, ""},
 };
 
-static void label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
+static void cmp_node_moviedistortion_label(bNodeTree *UNUSED(ntree),
+                                           bNode *node,
+                                           char *label,
+                                           int maxlen)
 {
   if (node->custom1 == 0) {
     BLI_strncpy(label, IFACE_("Undistortion"), maxlen);
@@ -48,7 +51,7 @@ static void label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen
   }
 }
 
-static void init(const bContext *C, PointerRNA *ptr)
+static void cmp_node_moviedistortion_init(const bContext *C, PointerRNA *ptr)
 {
   bNode *node = (bNode *)ptr->data;
   Scene *scene = CTX_data_scene(C);
@@ -57,7 +60,7 @@ static void init(const bContext *C, PointerRNA *ptr)
   id_us_plus(node->id);
 }
 
-static void storage_free(bNode *node)
+static void cmp_node_moviedistortion_storage_free(bNode *node)
 {
   if (node->storage) {
     BKE_tracking_distortion_free((MovieDistortion *)node->storage);
@@ -66,7 +69,9 @@ static void storage_free(bNode *node)
   node->storage = nullptr;
 }
 
-static void storage_copy(bNodeTree *UNUSED(dest_ntree), bNode *dest_node, const bNode *src_node)
+static void cmp_node_moviedistortion_storage_copy(bNodeTree *UNUSED(dest_ntree),
+                                                  bNode *dest_node,
+                                                  const bNode *src_node)
 {
   if (src_node->storage) {
     dest_node->storage = BKE_tracking_distortion_copy((MovieDistortion *)src_node->storage);
@@ -79,10 +84,13 @@ void register_node_type_cmp_moviedistortion(void)
 
   cmp_node_type_base(&ntype, CMP_NODE_MOVIEDISTORTION, "Movie Distortion", NODE_CLASS_DISTORT, 0);
   node_type_socket_templates(&ntype, cmp_node_moviedistortion_in, cmp_node_moviedistortion_out);
-  node_type_label(&ntype, label);
+  node_type_label(&ntype, cmp_node_moviedistortion_label);
 
-  ntype.initfunc_api = init;
-  node_type_storage(&ntype, nullptr, storage_free, storage_copy);
+  ntype.initfunc_api = cmp_node_moviedistortion_init;
+  node_type_storage(&ntype,
+                    nullptr,
+                    cmp_node_moviedistortion_storage_free,
+                    cmp_node_moviedistortion_storage_copy);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc
index e122b710b7b..09fd3b8e204 100644
--- a/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc
@@ -32,7 +32,7 @@ static bNodeSocketTemplate cmp_node_planetrackdeform_out[] = {
     {-1, ""},
 };
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_cmp_planetrackdeform_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodePlaneTrackDeformData *data = (NodePlaneTrackDeformData *)MEM_callocN(
       sizeof(NodePlaneTrackDeformData), "node plane track deform data");
@@ -48,7 +48,7 @@ void register_node_type_cmp_planetrackdeform(void)
   cmp_node_type_base(
       &ntype, CMP_NODE_PLANETRACKDEFORM, "Plane Track Deform", NODE_CLASS_DISTORT, 0);
   node_type_socket_templates(&ntype, cmp_node_planetrackdeform_in, cmp_node_planetrackdeform_out);
-  node_type_init(&ntype, init);
+  node_type_init(&ntype, node_cmp_planetrackdeform_init);
   node_type_storage(
       &ntype, "NodePlaneTrackDeformData", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc
index e5ce2e8ceb9..453c61de5a2 100644
--- a/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_stabilize2d.cc
@@ -38,7 +38,7 @@ static bNodeSocketTemplate cmp_node_stabilize2d_out[] = {
     {-1, ""},
 };
 
-static void init(const bContext *C, PointerRNA *ptr)
+static void node_cmp_stabilize2d_init(const bContext *C, PointerRNA *ptr)
 {
   bNode *node = (bNode *)ptr->data;
   Scene *scene = CTX_data_scene(C);
@@ -56,7 +56,7 @@ void register_node_type_cmp_stabilize2d(void)
 
   cmp_node_type_base(&ntype, CMP_NODE_STABILIZE2D, "Stabilize 2D", NODE_CLASS_DISTORT, 0);
   node_type_socket_templates(&ntype, cmp_node_stabilize2d_in, cmp_node_stabilize2d_out);
-  ntype.initfunc_api = init;
+  ntype.initfunc_api = node_cmp_stabilize2d_init;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc b/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc
index 73907d2e27f..ca5189334db 100644
--- a/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_sunbeams.cc
@@ -23,16 +23,16 @@
 
 #include "node_composite_util.hh"
 
-static bNodeSocketTemplate inputs[] = {
+static bNodeSocketTemplate node_cmp_sunbeams_inputs[] = {
     {SOCK_RGBA, N_("Image"), 1.0f, 1.0f, 1.0f, 1.0f},
     {-1, ""},
 };
-static bNodeSocketTemplate outputs[] = {
+static bNodeSocketTemplate node_cmp_sunbeams_outputs[] = {
     {SOCK_RGBA, N_("Image")},
     {-1, ""},
 };
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_cmp_sunbeams_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeSunBeams *data = (NodeSunBeams *)MEM_callocN(sizeof(NodeSunBeams), "sun beams node");
 
@@ -46,8 +46,8 @@ void register_node_type_cmp_sunbeams(void)
   static bNodeType ntype;
 
   cmp_node_type_base(&ntype, CMP_NODE_SUNBEAMS, "Sun Beams", NODE_CLASS_OP_FILTER, 0);
-  node_type_socket_templates(&ntype, inputs, outputs);
-  node_type_init(&ntype, init);
+  node_type_socket_templates(&ntype, node_cmp_sunbeams_inputs, node_cmp_sunbeams_outputs);
+  node_type_init(&ntype, node_cmp_sunbeams_init);
   node_type_storage(
       &ntype, "NodeSunBeams", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/composite/nodes/node_composite_trackpos.cc b/source/blender/nodes/composite/nodes/node_composite_trackpos.cc
index 537f7e661db..7861c8a46c7 100644
--- a/source/blender/nodes/composite/nodes/node_composite_trackpos.cc
+++ b/source/blender/nodes/composite/nodes/node_composite_trackpos.cc
@@ -34,7 +34,7 @@ static void cmp_node_trackpos_declare(NodeDeclarationBuilder &b)
 
 }  // namespace blender::nodes
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void cmp_node_trackpos_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeTrackPosData *data = (NodeTrackPosData *)MEM_callocN(sizeof(NodeTrackPosData),
                                                            "node track position data");
@@ -48,7 +48,7 @@ void register_node_type_cmp_trackpos(void)
 
   cmp_node_type_base(&ntype, CMP_NODE_TRACKPOS, "Track Position", NODE_CLASS_INPUT, 0);
   ntype.declare = blender::nodes::cmp_node_trackpos_declare;
-  node_type_init(&ntype, init);
+  node_type_init(&ntype, cmp_node_trackpos_init);
   node_type_storage(
       &ntype, "NodeTrackPosData", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc
index b44e8d54ff1..d35f108ebb7 100644
--- a/source/blender/nodes/function/nodes/node_fn_boolean_math.cc
+++ b/source/blender/nodes/function/nodes/node_fn_boolean_math.cc
@@ -24,7 +24,7 @@
 
 #include "node_function_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::boolean_math_node {
 
 static void fn_node_boolean_math_declare(NodeDeclarationBuilder &b)
 {
@@ -84,17 +84,18 @@ static void fn_node_boolean_math_build_multi_function(NodeMultiFunctionBuilder &
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::boolean_math_node
 
 void register_node_type_fn_boolean_math()
 {
   static bNodeType ntype;
 
   fn_node_type_base(&ntype, FN_NODE_BOOLEAN_MATH, "Boolean Math", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = blender::nodes::fn_node_boolean_math_declare;
-  node_type_label(&ntype, blender::nodes::node_boolean_math_label);
-  node_type_update(&ntype, blender::nodes::node_boolean_math_update);
-  ntype.build_multi_function = blender::nodes::fn_node_boolean_math_build_multi_function;
-  ntype.draw_buttons = blender::nodes::fn_node_boolean_math_layout;
+  ntype.declare = blender::nodes::boolean_math_node::fn_node_boolean_math_declare;
+  node_type_label(&ntype, blender::nodes::boolean_math_node::node_boolean_math_label);
+  node_type_update(&ntype, blender::nodes::boolean_math_node::node_boolean_math_update);
+  ntype.build_multi_function =
+      blender::nodes::boolean_math_node::fn_node_boolean_math_build_multi_function;
+  ntype.draw_buttons = blender::nodes::boolean_math_node::fn_node_boolean_math_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_float_compare.cc b/source/blender/nodes/function/nodes/node_fn_float_compare.cc
index 2e1f2aaeeef..ae3234047c8 100644
--- a/source/blender/nodes/function/nodes/node_fn_float_compare.cc
+++ b/source/blender/nodes/function/nodes/node_fn_float_compare.cc
@@ -26,7 +26,7 @@
 
 #include "node_function_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::float_compare_node {
 
 static void fn_node_float_compare_declare(NodeDeclarationBuilder &b)
 {
@@ -103,17 +103,18 @@ static void fn_node_float_compare_build_multi_function(NodeMultiFunctionBuilder
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::float_compare_node
 
 void register_node_type_fn_float_compare()
 {
   static bNodeType ntype;
 
   fn_node_type_base(&ntype, FN_NODE_COMPARE_FLOATS, "Compare Floats", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = blender::nodes::fn_node_float_compare_declare;
-  node_type_label(&ntype, blender::nodes::node_float_compare_label);
-  node_type_update(&ntype, blender::nodes::node_float_compare_update);
-  ntype.build_multi_function = blender::nodes::fn_node_float_compare_build_multi_function;
-  ntype.draw_buttons = blender::nodes::geo_node_float_compare_layout;
+  ntype.declare = blender::nodes::float_compare_node::fn_node_float_compare_declare;
+  node_type_label(&ntype, blender::nodes::float_compare_node::node_float_compare_label);
+  node_type_update(&ntype, blender::nodes::float_compare_node::node_float_compare_update);
+  ntype.build_multi_function =
+      blender::nodes::float_compare_node::fn_node_float_compare_build_multi_function;
+  ntype.draw_buttons = blender::nodes::float_compare_node::geo_node_float_compare_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_float_to_int.cc b/source/blender/nodes/function/nodes/node_fn_float_to_int.cc
index e6ec925f945..ee37ed3b20c 100644
--- a/source/blender/nodes/function/nodes/node_fn_float_to_int.cc
+++ b/source/blender/nodes/function/nodes/node_fn_float_to_int.cc
@@ -25,7 +25,7 @@
 
 #include "node_function_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::float_to_int_node {
 
 static void fn_node_float_to_int_declare(NodeDeclarationBuilder &b)
 {
@@ -78,16 +78,17 @@ static void fn_node_float_to_int_build_multi_function(NodeMultiFunctionBuilder &
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::float_to_int_node
 
 void register_node_type_fn_float_to_int()
 {
   static bNodeType ntype;
 
   fn_node_type_base(&ntype, FN_NODE_FLOAT_TO_INT, "Float to Integer", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = blender::nodes::fn_node_float_to_int_declare;
-  node_type_label(&ntype, blender::nodes::node_float_to_int_label);
-  ntype.build_multi_function = blender::nodes::fn_node_float_to_int_build_multi_function;
-  ntype.draw_buttons = blender::nodes::fn_node_float_to_int_layout;
+  ntype.declare = blender::nodes::float_to_int_node::fn_node_float_to_int_declare;
+  node_type_label(&ntype, blender::nodes::float_to_int_node::node_float_to_int_label);
+  ntype.build_multi_function =
+      blender::nodes::float_to_int_node::fn_node_float_to_int_build_multi_function;
+  ntype.draw_buttons = blender::nodes::float_to_int_node::fn_node_float_to_int_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc b/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc
index fc4c3d8221f..4eba4bba095 100644
--- a/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc
+++ b/source/blender/nodes/function/nodes/node_fn_rotate_euler.cc
@@ -24,7 +24,7 @@
 
 #include "node_function_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::rotate_euler_node {
 
 static void fn_node_rotate_euler_declare(NodeDeclarationBuilder &b)
 {
@@ -125,15 +125,16 @@ static void fn_node_rotate_euler_build_multi_function(NodeMultiFunctionBuilder &
   builder.set_matching_fn(fn);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::rotate_euler_node
 
 void register_node_type_fn_rotate_euler()
 {
   static bNodeType ntype;
   fn_node_type_base(&ntype, FN_NODE_ROTATE_EULER, "Rotate Euler", NODE_CLASS_CONVERTER, 0);
-  ntype.declare = blender::nodes::fn_node_rotate_euler_declare;
-  ntype.draw_buttons = blender::nodes::fn_node_rotate_euler_layout;
-  node_type_update(&ntype, blender::nodes::fn_node_rotate_euler_update);
-  ntype.build_multi_function = blender::nodes::fn_node_rotate_euler_build_multi_function;
+  ntype.declare = blender::nodes::rotate_euler_node::fn_node_rotate_euler_declare;
+  ntype.draw_buttons = blender::nodes::rotate_euler_node::fn_node_rotate_euler_layout;
+  node_type_update(&ntype, blender::nodes::rotate_euler_node::fn_node_rotate_euler_update);
+  ntype.build_multi_function =
+      blender::nodes::rotate_euler_node::fn_node_rotate_euler_build_multi_function;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_clamp.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_clamp.cc
index 91ff114a480..46105b1b25a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_clamp.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_clamp.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_clamp_node {
 
 static void geo_node_attribute_clamp_declare(NodeDeclarationBuilder &b)
 {
@@ -262,7 +262,7 @@ static void geo_node_attribute_clamp_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_clamp_node
 
 void register_node_type_geo_attribute_clamp()
 {
@@ -270,11 +270,12 @@ void register_node_type_geo_attribute_clamp()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_CLAMP, "Attribute Clamp", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_clamp_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_clamp_update);
-  ntype.declare = blender::nodes::geo_node_attribute_clamp_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_clamp_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_clamp_layout;
+  node_type_init(&ntype, blender::nodes::attribute_clamp_node::geo_node_attribute_clamp_init);
+  node_type_update(&ntype, blender::nodes::attribute_clamp_node::geo_node_attribute_clamp_update);
+  ntype.declare = blender::nodes::attribute_clamp_node::geo_node_attribute_clamp_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_clamp_node::geo_node_attribute_clamp_exec;
+  ntype.draw_buttons = blender::nodes::attribute_clamp_node::geo_node_attribute_clamp_layout;
   node_type_storage(
       &ntype, "NodeAttributeClamp", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_color_ramp.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_color_ramp.cc
index ab4b6aad545..4817b1d9985 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_color_ramp.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_color_ramp.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_color_ramp_node {
 
 static void geo_node_attribute_color_ramp_declare(NodeDeclarationBuilder &b)
 {
@@ -119,7 +119,7 @@ static void geo_node_attribute_color_ramp_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_color_ramp_node
 
 void register_node_type_geo_attribute_color_ramp()
 {
@@ -132,10 +132,13 @@ void register_node_type_geo_attribute_color_ramp()
                      0);
   node_type_storage(
       &ntype, "NodeAttributeColorRamp", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_color_ramp_init);
+  node_type_init(&ntype,
+                 blender::nodes::attribute_color_ramp_node::geo_node_attribute_color_ramp_init);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  ntype.declare = blender::nodes::geo_node_attribute_color_ramp_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_color_ramp_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_color_ramp_layout;
+  ntype.declare = blender::nodes::attribute_color_ramp_node::geo_node_attribute_color_ramp_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_color_ramp_node::geo_node_attribute_color_ramp_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_color_ramp_node::geo_node_attribute_color_ramp_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_combine_xyz.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_combine_xyz.cc
index d4c23380b4e..9d8d5dab127 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_combine_xyz.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_combine_xyz.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_combine_xyz_node {
 
 static void geo_node_attribute_combine_xyz_declare(NodeDeclarationBuilder &b)
 {
@@ -130,7 +130,7 @@ static void geo_node_attribute_combine_xyz_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_combine_xyz_node
 
 void register_node_type_geo_attribute_combine_xyz()
 {
@@ -141,13 +141,18 @@ void register_node_type_geo_attribute_combine_xyz()
                      "Attribute Combine XYZ",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_combine_xyz_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_combine_xyz_update);
+  node_type_init(&ntype,
+                 blender::nodes::attribute_combine_xyz_node::geo_node_attribute_combine_xyz_init);
+  node_type_update(
+      &ntype, blender::nodes::attribute_combine_xyz_node::geo_node_attribute_combine_xyz_update);
   node_type_storage(
       &ntype, "NodeAttributeCombineXYZ", node_free_standard_storage, node_copy_standard_storage);
 
-  ntype.declare = blender::nodes::geo_node_attribute_combine_xyz_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_combine_xyz_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_combine_xyz_layout;
+  ntype.declare =
+      blender::nodes::attribute_combine_xyz_node::geo_node_attribute_combine_xyz_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_combine_xyz_node::geo_node_attribute_combine_xyz_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_combine_xyz_node::geo_node_attribute_combine_xyz_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_compare.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_compare.cc
index e4e43a7b724..fb9ed3485f1 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_compare.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_compare.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_compare_node {
 
 static void geo_node_attribute_compare_declare(NodeDeclarationBuilder &b)
 {
@@ -341,7 +341,7 @@ static void geo_node_attribute_compare_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_compare_node
 
 void register_node_type_geo_attribute_compare()
 {
@@ -349,12 +349,14 @@ void register_node_type_geo_attribute_compare()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_COMPARE, "Attribute Compare", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.declare = blender::nodes::geo_node_attribute_compare_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_compare_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_compare_layout;
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_compare_update);
+  ntype.declare = blender::nodes::attribute_compare_node::geo_node_attribute_compare_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_compare_node::geo_node_attribute_compare_exec;
+  ntype.draw_buttons = blender::nodes::attribute_compare_node::geo_node_attribute_compare_layout;
+  node_type_update(&ntype,
+                   blender::nodes::attribute_compare_node::geo_node_attribute_compare_update);
   node_type_storage(
       &ntype, "NodeAttributeCompare", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_compare_init);
+  node_type_init(&ntype, blender::nodes::attribute_compare_node::geo_node_attribute_compare_init);
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_curve_map.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_curve_map.cc
index 669ac21436f..97eb72b4e32 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_curve_map.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_curve_map.cc
@@ -24,7 +24,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_curve_map_node {
 
 static void geo_node_attribute_curve_map_declare(NodeDeclarationBuilder &b)
 {
@@ -204,7 +204,7 @@ static void geo_node_attribute_curve_map_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_curve_map_node
 
 void register_node_type_geo_attribute_curve_map()
 {
@@ -212,15 +212,20 @@ void register_node_type_geo_attribute_curve_map()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_CURVE_MAP, "Attribute Curve Map", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_curve_map_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_curve_map_init);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_update);
+  node_type_init(&ntype,
+                 blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_init);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  node_type_storage(&ntype,
-                    "NodeAttributeCurveMap",
-                    blender::nodes::geo_node_attribute_curve_map_free_storage,
-                    blender::nodes::geo_node_attribute_curve_map_copy_storage);
-  ntype.declare = blender::nodes::geo_node_attribute_curve_map_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_curve_map_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_curve_map_layout;
+  node_type_storage(
+      &ntype,
+      "NodeAttributeCurveMap",
+      blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_free_storage,
+      blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_copy_storage);
+  ntype.declare = blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_curve_map_node::geo_node_attribute_curve_map_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_fill.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_fill.cc
index 5cb49dd83d0..a88f16a1117 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_fill.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_fill.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_fill_node {
 
 static void geo_node_attribute_fill_declare(NodeDeclarationBuilder &b)
 {
@@ -146,7 +146,7 @@ static void geo_node_attribute_fill_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_fill_node
 
 void register_node_type_geo_attribute_fill()
 {
@@ -154,10 +154,10 @@ void register_node_type_geo_attribute_fill()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_FILL, "Attribute Fill", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_fill_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_fill_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_fill_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_fill_layout;
-  ntype.declare = blender::nodes::geo_node_attribute_fill_declare;
+  node_type_init(&ntype, blender::nodes::attribute_fill_node::geo_node_attribute_fill_init);
+  node_type_update(&ntype, blender::nodes::attribute_fill_node::geo_node_attribute_fill_update);
+  ntype.geometry_node_execute = blender::nodes::attribute_fill_node::geo_node_attribute_fill_exec;
+  ntype.draw_buttons = blender::nodes::attribute_fill_node::geo_node_attribute_fill_layout;
+  ntype.declare = blender::nodes::attribute_fill_node::geo_node_attribute_fill_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_map_range.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_map_range.cc
index 978c75187fe..62b06e20c89 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_map_range.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_map_range.cc
@@ -22,7 +22,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_map_range_node {
 
 static void geo_node_attribute_map_range_declare(NodeDeclarationBuilder &b)
 {
@@ -413,7 +413,7 @@ static void geo_node_attribute_map_range_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_map_range_node
 
 void register_node_type_geo_attribute_map_range()
 {
@@ -421,12 +421,15 @@ void register_node_type_geo_attribute_map_range()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_MAP_RANGE, "Attribute Map Range", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_map_range_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_map_range_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_map_range_update);
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_map_range_node::geo_node_attribute_map_range_exec;
+  node_type_init(&ntype,
+                 blender::nodes::attribute_map_range_node::geo_node_attribute_map_range_init);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_map_range_node::geo_node_attribute_map_range_update);
   node_type_storage(
       &ntype, "NodeAttributeMapRange", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_attribute_map_range_declare;
-  ntype.draw_buttons = blender::nodes::fn_attribute_map_range_layout;
+  ntype.declare = blender::nodes::attribute_map_range_node::geo_node_attribute_map_range_declare;
+  ntype.draw_buttons = blender::nodes::attribute_map_range_node::fn_attribute_map_range_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_math.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_math.cc
index 55d35f87cda..947e3eb2c6d 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_math.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_math.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_math_node {
 
 static void geo_node_attribute_math_declare(NodeDeclarationBuilder &b)
 {
@@ -295,7 +295,7 @@ static void geo_node_attribute_math_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_math_node
 
 void register_node_type_geo_attribute_math()
 {
@@ -303,12 +303,12 @@ void register_node_type_geo_attribute_math()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_MATH, "Attribute Math", NODE_CLASS_ATTRIBUTE, 0);
-  ntype.declare = blender::nodes::geo_node_attribute_math_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_math_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_math_layout;
-  node_type_label(&ntype, blender::nodes::geo_node_math_label);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_math_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_math_init);
+  ntype.declare = blender::nodes::attribute_math_node::geo_node_attribute_math_declare;
+  ntype.geometry_node_execute = blender::nodes::attribute_math_node::geo_node_attribute_math_exec;
+  ntype.draw_buttons = blender::nodes::attribute_math_node::geo_node_attribute_math_layout;
+  node_type_label(&ntype, blender::nodes::attribute_math_node::geo_node_math_label);
+  node_type_update(&ntype, blender::nodes::attribute_math_node::geo_node_attribute_math_update);
+  node_type_init(&ntype, blender::nodes::attribute_math_node::geo_node_attribute_math_init);
   node_type_storage(
       &ntype, "NodeAttributeMath", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_mix.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_mix.cc
index b4205bc91b7..77926e84e2f 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_mix.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_mix.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_mix_node {
 
 static void geo_node_mix_attribute_declare(NodeDeclarationBuilder &b)
 {
@@ -238,19 +238,19 @@ static void geo_node_attribute_mix_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_mix_node
 
 void register_node_type_geo_attribute_mix()
 {
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_MIX, "Attribute Mix", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_mix_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_mix_update);
-  ntype.declare = blender::nodes::geo_node_mix_attribute_declare;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_mix_layout;
+  node_type_init(&ntype, blender::nodes::attribute_mix_node::geo_node_attribute_mix_init);
+  node_type_update(&ntype, blender::nodes::attribute_mix_node::geo_node_attribute_mix_update);
+  ntype.declare = blender::nodes::attribute_mix_node::geo_node_mix_attribute_declare;
+  ntype.draw_buttons = blender::nodes::attribute_mix_node::geo_node_attribute_mix_layout;
   node_type_storage(
       &ntype, "NodeAttributeMix", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_mix_exec;
+  ntype.geometry_node_execute = blender::nodes::attribute_mix_node::geo_node_attribute_mix_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_randomize.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_randomize.cc
index 2901472d661..2501e3356ee 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_randomize.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_randomize.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_randomize_node {
 
 static void geo_node_legacy_attribute_randomize_declare(NodeDeclarationBuilder &b)
 {
@@ -174,36 +174,6 @@ static void randomize_attribute_bool(MutableSpan<bool> span,
   });
 }
 
-Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
-                                                  const AttributeDomain domain)
-{
-  const int domain_size = component.attribute_domain_size(domain);
-
-  /* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
-  GVArrayPtr hash_attribute = component.attribute_try_get_for_read("id", domain);
-  Array<uint32_t> hashes(domain_size);
-  if (hash_attribute) {
-    BLI_assert(hashes.size() == hash_attribute->size());
-    const CPPType &cpp_type = hash_attribute->type();
-    BLI_assert(cpp_type.is_hashable());
-    GVArray_GSpan items{*hash_attribute};
-    threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
-      for (const int i : range) {
-        hashes[i] = cpp_type.hash(items[i]);
-      }
-    });
-  }
-  else {
-    /* If there is no "id" attribute for per-point variation, just create it here. */
-    RandomNumberGenerator rng(0);
-    for (const int i : hashes.index_range()) {
-      hashes[i] = rng.get_uint32();
-    }
-  }
-
-  return hashes;
-}
-
 static AttributeDomain get_result_domain(const GeometryComponent &component,
                                          const GeoNodeExecParams &params,
                                          const StringRef name)
@@ -324,6 +294,40 @@ static void geo_node_legacy_random_attribute_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
+}  // namespace blender::nodes::attribute_randomize_node
+
+namespace blender::nodes {
+
+Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
+                                                  const AttributeDomain domain)
+{
+  const int domain_size = component.attribute_domain_size(domain);
+
+  /* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
+  GVArrayPtr hash_attribute = component.attribute_try_get_for_read("id", domain);
+  Array<uint32_t> hashes(domain_size);
+  if (hash_attribute) {
+    BLI_assert(hashes.size() == hash_attribute->size());
+    const CPPType &cpp_type = hash_attribute->type();
+    BLI_assert(cpp_type.is_hashable());
+    GVArray_GSpan items{*hash_attribute};
+    threading::parallel_for(hashes.index_range(), 512, [&](IndexRange range) {
+      for (const int i : range) {
+        hashes[i] = cpp_type.hash(items[i]);
+      }
+    });
+  }
+  else {
+    /* If there is no "id" attribute for per-point variation, just create it here. */
+    RandomNumberGenerator rng(0);
+    for (const int i : hashes.index_range()) {
+      hashes[i] = rng.get_uint32();
+    }
+  }
+
+  return hashes;
+}
+
 }  // namespace blender::nodes
 
 void register_node_type_geo_legacy_attribute_randomize()
@@ -332,12 +336,18 @@ void register_node_type_geo_legacy_attribute_randomize()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_RANDOMIZE, "Attribute Randomize", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_init);
-  node_type_update(&ntype, blender::nodes::geo_node_legacy_attribute_randomize_update);
-
-  ntype.declare = blender::nodes::geo_node_legacy_attribute_randomize_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_random_attribute_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_legacy_attribute_random_layout;
+  node_type_init(
+      &ntype, blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_randomize_init);
+  node_type_update(
+      &ntype,
+      blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_randomize_update);
+
+  ntype.declare =
+      blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_randomize_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_randomize_node::geo_node_legacy_random_attribute_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_randomize_node::geo_node_legacy_attribute_random_layout;
   node_type_storage(
       &ntype, "NodeAttributeRandomize", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_sample_texture.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_sample_texture.cc
index 19d6ced6eb6..77c4d21a234 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_sample_texture.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_sample_texture.cc
@@ -28,7 +28,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_sample_texture_node {
 
 static void geo_node_attribute_sample_texture_declare(NodeDeclarationBuilder &b)
 {
@@ -119,7 +119,7 @@ static void geo_node_attribute_sample_texture_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_sample_texture_node
 
 void register_node_type_geo_sample_texture()
 {
@@ -131,7 +131,9 @@ void register_node_type_geo_sample_texture()
                      NODE_CLASS_ATTRIBUTE,
                      0);
   node_type_size_preset(&ntype, NODE_SIZE_LARGE);
-  ntype.declare = blender::nodes::geo_node_attribute_sample_texture_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_sample_texture_exec;
+  ntype.declare =
+      blender::nodes::attribute_sample_texture_node::geo_node_attribute_sample_texture_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_sample_texture_node::geo_node_attribute_sample_texture_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_separate_xyz.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_separate_xyz.cc
index 809e75e73a3..a32956de858 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_separate_xyz.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_separate_xyz.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_separate_xyz_node {
 
 static void geo_node_attribute_separate_xyz_declare(NodeDeclarationBuilder &b)
 {
@@ -151,7 +151,7 @@ static void geo_node_attribute_separate_xyz_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_separate_xyz_node
 
 void register_node_type_geo_attribute_separate_xyz()
 {
@@ -162,12 +162,17 @@ void register_node_type_geo_attribute_separate_xyz()
                      "Attribute Separate XYZ",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  ntype.declare = blender::nodes::geo_node_attribute_separate_xyz_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_separate_xyz_init);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_separate_xyz_update);
+  ntype.declare =
+      blender::nodes::attribute_separate_xyz_node::geo_node_attribute_separate_xyz_declare;
+  node_type_init(
+      &ntype, blender::nodes::attribute_separate_xyz_node::geo_node_attribute_separate_xyz_init);
+  node_type_update(
+      &ntype, blender::nodes::attribute_separate_xyz_node::geo_node_attribute_separate_xyz_update);
   node_type_storage(
       &ntype, "NodeAttributeSeparateXYZ", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_separate_xyz_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_separate_xyz_layout;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_separate_xyz_node::geo_node_attribute_separate_xyz_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_separate_xyz_node::geo_node_attribute_separate_xyz_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_math.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_math.cc
index 4c351846243..85b7b1330fc 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_math.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_math.cc
@@ -26,7 +26,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_vector_math_node {
 
 static void geo_node_attribute_vector_math_declare(NodeDeclarationBuilder &b)
 {
@@ -549,7 +549,7 @@ static void geo_node_attribute_vector_math_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_vector_math_node
 
 void register_node_type_geo_attribute_vector_math()
 {
@@ -560,12 +560,17 @@ void register_node_type_geo_attribute_vector_math()
                      "Attribute Vector Math",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  ntype.declare = blender::nodes::geo_node_attribute_vector_math_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_math_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_math_layout;
-  node_type_label(&ntype, blender::nodes::geo_node_vector_math_label);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_math_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_math_init);
+  ntype.declare =
+      blender::nodes::attribute_vector_math_node::geo_node_attribute_vector_math_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_vector_math_node::geo_node_attribute_vector_math_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_vector_math_node::geo_node_attribute_vector_math_layout;
+  node_type_label(&ntype, blender::nodes::attribute_vector_math_node::geo_node_vector_math_label);
+  node_type_update(
+      &ntype, blender::nodes::attribute_vector_math_node::geo_node_attribute_vector_math_update);
+  node_type_init(&ntype,
+                 blender::nodes::attribute_vector_math_node::geo_node_attribute_vector_math_init);
   node_type_storage(
       &ntype, "NodeAttributeVectorMath", node_free_standard_storage, node_copy_standard_storage);
 
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_rotate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_rotate.cc
index 9ab8ec25fb6..ed32379aabd 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_rotate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_vector_rotate.cc
@@ -21,7 +21,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_vector_rotate_node {
 
 static void geo_node_attribute_vector_rotate_declare(NodeDeclarationBuilder &b)
 {
@@ -325,7 +325,7 @@ static void geo_node_attribute_vector_rotate_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_vector_rotate_node
 
 void register_node_type_geo_attribute_vector_rotate()
 {
@@ -336,13 +336,19 @@ void register_node_type_geo_attribute_vector_rotate()
                      "Attribute Vector Rotate",
                      NODE_CLASS_ATTRIBUTE,
                      0);
-  node_type_update(&ntype, blender::nodes::geo_node_attribute_vector_rotate_update);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_vector_rotate_init);
+  node_type_update(
+      &ntype,
+      blender::nodes::attribute_vector_rotate_node::geo_node_attribute_vector_rotate_update);
+  node_type_init(
+      &ntype, blender::nodes::attribute_vector_rotate_node::geo_node_attribute_vector_rotate_init);
   node_type_size(&ntype, 165, 100, 600);
   node_type_storage(
       &ntype, "NodeAttributeVectorRotate", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_vector_rotate_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_vector_rotate_layout;
-  ntype.declare = blender::nodes::geo_node_attribute_vector_rotate_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_vector_rotate_node::geo_node_attribute_vector_rotate_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_vector_rotate_node::geo_node_attribute_vector_rotate_layout;
+  ntype.declare =
+      blender::nodes::attribute_vector_rotate_node::geo_node_attribute_vector_rotate_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_endpoints.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_endpoints.cc
index 8b81008ff34..9d23019e1e1 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_endpoints.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_endpoints.cc
@@ -25,7 +25,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::curve_endpoints_node {
 
 static void geo_node_curve_endpoints_declare(NodeDeclarationBuilder &b)
 {
@@ -206,7 +206,7 @@ static void geo_node_curve_endpoints_exec(GeoNodeExecParams params)
   params.set_output("End Points", std::move(end_result));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::curve_endpoints_node
 
 void register_node_type_geo_legacy_curve_endpoints()
 {
@@ -214,8 +214,9 @@ void register_node_type_geo_legacy_curve_endpoints()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_ENDPOINTS, "Curve Endpoints", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_endpoints_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_endpoints_exec;
+  ntype.declare = blender::nodes::curve_endpoints_node::geo_node_curve_endpoints_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::curve_endpoints_node::geo_node_curve_endpoints_exec;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_select_by_handle_type.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_select_by_handle_type.cc
index 40d827ae141..b3850256f47 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_select_by_handle_type.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_select_by_handle_type.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::select_by_handle_type_node {
 
 static void geo_node_select_by_handle_type_declare(NodeDeclarationBuilder &b)
 {
@@ -121,7 +121,7 @@ static void geo_node_select_by_handle_type_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::select_by_handle_type_node
 
 void register_node_type_geo_legacy_select_by_handle_type()
 {
@@ -132,14 +132,19 @@ void register_node_type_geo_legacy_select_by_handle_type()
                      "Select by Handle Type",
                      NODE_CLASS_GEOMETRY,
                      0);
-  ntype.declare = blender::nodes::geo_node_select_by_handle_type_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_select_by_handle_type_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_select_by_handle_type_init);
+  ntype.declare =
+      blender::nodes::select_by_handle_type_node::geo_node_select_by_handle_type_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::select_by_handle_type_node::geo_node_select_by_handle_type_exec;
+  node_type_init(
+      &ntype,
+      blender::nodes::select_by_handle_type_node::geo_node_curve_select_by_handle_type_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSelectHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_select_by_handle_type_layout;
+  ntype.draw_buttons =
+      blender::nodes::select_by_handle_type_node::geo_node_curve_select_by_handle_type_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_set_handles.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_set_handles.cc
index 4bac9cb976e..01cb9072f8e 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_set_handles.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_set_handles.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::set_curve_handles_legacy_node {
 
 static void geo_node_curve_set_handles_decalre(NodeDeclarationBuilder &b)
 {
@@ -124,21 +124,25 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
 
   params.set_output("Curve", geometry_set);
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::set_curve_handles_legacy_node
 
 void register_node_type_geo_legacy_curve_set_handles()
 {
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_set_handles_decalre;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
+  ntype.declare =
+      blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_decalre;
+  ntype.geometry_node_execute =
+      blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_exec;
+  node_type_init(&ntype,
+                 blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSetHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
+  ntype.draw_buttons =
+      blender::nodes::set_curve_handles_legacy_node::geo_node_curve_set_handles_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_spline_type.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_spline_type.cc
index df53c96e6ca..d3eb3cdbdd2 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_spline_type.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_spline_type.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::curve_spline_type_legacy_node {
 
 static void geo_node_legacy_curve_spline_type_declare(NodeDeclarationBuilder &b)
 {
@@ -282,21 +282,26 @@ static void geo_node_legacy_curve_spline_type_exec(GeoNodeExecParams params)
   params.set_output("Curve", GeometrySet::create_with_curve(new_curve.release()));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::curve_spline_type_legacy_node
 
 void register_node_type_geo_legacy_curve_spline_type()
 {
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_curve_spline_type_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_curve_spline_type_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_legacy_curve_spline_type_init);
+  ntype.declare =
+      blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_exec;
+  node_type_init(
+      &ntype,
+      blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSplineType",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_legacy_curve_spline_type_layout;
+  ntype.draw_buttons =
+      blender::nodes::curve_spline_type_legacy_node::geo_node_legacy_curve_spline_type_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_to_points.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_to_points.cc
index c171d485a6a..5f29baefa76 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_curve_to_points.cc
@@ -26,7 +26,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::legacy_curve_to_points_node {
 
 static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
 {
@@ -133,35 +133,6 @@ static MutableSpan<T> create_attribute_and_retrieve_span(PointCloudComponent &po
   return attribute.typed<T>();
 }
 
-CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
-                                                              const CurveEval &curve)
-{
-  CurveToPointsResults attributes;
-
-  attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
-
-  attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
-  attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
-  attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
-
-  /* Because of the invariants of the curve component, we use the attributes of the
-   * first spline as a representative for the attribute meta data all splines. */
-  curve.splines().first()->attributes.foreach_attribute(
-      [&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
-        attributes.point_attributes.add_new(
-            attribute_id,
-            create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
-        return true;
-      },
-      ATTR_DOMAIN_POINT);
-
-  attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
-  attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
-  attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
-
-  return attributes;
-}
-
 /**
  * TODO: For non-poly splines, this has double copies that could be avoided as part
  * of a general look at optimizing uses of #Spline::interpolate_to_evaluated.
@@ -340,6 +311,39 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(result));
 }
 
+}  // namespace blender::nodes::legacy_curve_to_points_node
+
+namespace blender::nodes {
+CurveToPointsResults curve_to_points_create_result_attributes(PointCloudComponent &points,
+                                                              const CurveEval &curve)
+{
+  using namespace blender::nodes::legacy_curve_to_points_node;
+
+  CurveToPointsResults attributes;
+
+  attributes.result_size = points.attribute_domain_size(ATTR_DOMAIN_POINT);
+
+  attributes.positions = create_attribute_and_retrieve_span<float3>(points, "position");
+  attributes.radii = create_attribute_and_retrieve_span<float>(points, "radius");
+  attributes.tilts = create_attribute_and_retrieve_span<float>(points, "tilt");
+
+  /* Because of the invariants of the curve component, we use the attributes of the
+   * first spline as a representative for the attribute meta data all splines. */
+  curve.splines().first()->attributes.foreach_attribute(
+      [&](const AttributeIDRef &attribute_id, const AttributeMetaData &meta_data) {
+        attributes.point_attributes.add_new(
+            attribute_id,
+            create_attribute_and_retrieve_span(points, attribute_id, meta_data.data_type));
+        return true;
+      },
+      ATTR_DOMAIN_POINT);
+
+  attributes.tangents = create_attribute_and_retrieve_span<float3>(points, "tangent");
+  attributes.normals = create_attribute_and_retrieve_span<float3>(points, "normal");
+  attributes.rotations = create_attribute_and_retrieve_span<float3>(points, "rotation");
+
+  return attributes;
+}
 }  // namespace blender::nodes
 
 void register_node_type_geo_legacy_curve_to_points()
@@ -348,13 +352,17 @@ void register_node_type_geo_legacy_curve_to_points()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
+  ntype.declare = blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_exec;
+  ntype.draw_buttons =
+      blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_layout;
   node_type_storage(
       &ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
+  node_type_init(&ntype,
+                 blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_init);
+  node_type_update(&ntype,
+                   blender::nodes::legacy_curve_to_points_node::geo_node_curve_to_points_update);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_delete_geometry.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_delete_geometry.cc
index 1d76a0532a1..dd972ad5e85 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_delete_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_delete_geometry.cc
@@ -43,7 +43,7 @@ extern void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
                                           blender::Span<int> masked_poly_indices,
                                           blender::Span<int> new_loop_starts);
 
-namespace blender::nodes {
+namespace blender::nodes::delete_geometry_legacy_node {
 
 static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -662,7 +662,7 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(out_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::delete_geometry_legacy_node
 
 void register_node_type_geo_legacy_delete_geometry()
 {
@@ -671,7 +671,8 @@ void register_node_type_geo_legacy_delete_geometry()
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_DELETE_GEOMETRY, "Delete Geometry", NODE_CLASS_GEOMETRY, 0);
 
-  ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
+  ntype.declare = blender::nodes::delete_geometry_legacy_node::geo_node_delete_geometry_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::delete_geometry_legacy_node::geo_node_delete_geometry_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_edge_split.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_edge_split.cc
index 8f2bf05d2b4..16a06fe178d 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_edge_split.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_edge_split.cc
@@ -22,7 +22,7 @@ extern "C" {
 Mesh *doEdgeSplit(const Mesh *mesh, EdgeSplitModifierData *emd);
 }
 
-namespace blender::nodes {
+namespace blender::nodes::edge_split_legacy_node {
 
 static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
 {
@@ -76,14 +76,14 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::edge_split_legacy_node
 
 void register_node_type_geo_legacy_edge_split()
 {
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_LEGACY_EDGE_SPLIT, "Edge Split", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
-  ntype.declare = blender::nodes::geo_node_edge_split_declare;
+  ntype.geometry_node_execute = blender::nodes::edge_split_legacy_node::geo_node_edge_split_exec;
+  ntype.declare = blender::nodes::edge_split_legacy_node::geo_node_edge_split_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_distribute.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_distribute.cc
index 210757f986d..00f3790c766 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_distribute.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_distribute.cc
@@ -38,7 +38,7 @@
 
 using blender::bke::GeometryInstanceGroup;
 
-namespace blender::nodes {
+namespace blender::nodes::point_distribute_node {
 
 static void geo_node_point_distribute_declare(NodeDeclarationBuilder &b)
 {
@@ -654,7 +654,7 @@ static void geo_node_point_distribute_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set_out));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::point_distribute_node
 
 void register_node_type_geo_point_distribute()
 {
@@ -662,9 +662,10 @@ void register_node_type_geo_point_distribute()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_DISTRIBUTE, "Point Distribute", NODE_CLASS_GEOMETRY, 0);
-  node_type_update(&ntype, blender::nodes::node_point_distribute_update);
-  ntype.declare = blender::nodes::geo_node_point_distribute_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_distribute_layout;
+  node_type_update(&ntype, blender::nodes::point_distribute_node::node_point_distribute_update);
+  ntype.declare = blender::nodes::point_distribute_node::geo_node_point_distribute_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::point_distribute_node::geo_node_point_distribute_exec;
+  ntype.draw_buttons = blender::nodes::point_distribute_node::geo_node_point_distribute_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_scale.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_scale.cc
index 934442ee8a3..bf85ac8fd93 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_scale.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_scale.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::point_scale_node {
 
 static void geo_node_point_scale_declare(NodeDeclarationBuilder &b)
 {
@@ -120,7 +120,7 @@ static void geo_node_point_scale_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::point_scale_node
 
 void register_node_type_geo_point_scale()
 {
@@ -128,12 +128,12 @@ void register_node_type_geo_point_scale()
 
   geo_node_type_base(&ntype, GEO_NODE_LEGACY_POINT_SCALE, "Point Scale", NODE_CLASS_GEOMETRY, 0);
 
-  ntype.declare = blender::nodes::geo_node_point_scale_declare;
-  node_type_init(&ntype, blender::nodes::geo_node_point_scale_init);
-  node_type_update(&ntype, blender::nodes::geo_node_point_scale_update);
+  ntype.declare = blender::nodes::point_scale_node::geo_node_point_scale_declare;
+  node_type_init(&ntype, blender::nodes::point_scale_node::geo_node_point_scale_init);
+  node_type_update(&ntype, blender::nodes::point_scale_node::geo_node_point_scale_update);
   node_type_storage(
       &ntype, "NodeGeometryPointScale", node_free_standard_storage, node_copy_standard_storage);
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_scale_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_scale_layout;
+  ntype.geometry_node_execute = blender::nodes::point_scale_node::geo_node_point_scale_exec;
+  ntype.draw_buttons = blender::nodes::point_scale_node::geo_node_point_scale_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_separate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_separate.cc
index accdaf78439..4228d11196a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_separate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_separate.cc
@@ -25,7 +25,7 @@
 
 namespace blender::nodes {
 
-static void geo_node_point_instance_declare(NodeDeclarationBuilder &b)
+static void geo_node_point_separate_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Geometry"));
   b.add_input<decl::String>(N_("Mask"));
@@ -166,7 +166,7 @@ void register_node_type_geo_point_separate()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_SEPARATE, "Point Separate", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_point_instance_declare;
+  ntype.declare = blender::nodes::geo_node_point_separate_declare;
   ntype.geometry_node_execute = blender::nodes::geo_node_point_separate_exec;
   ntype.geometry_node_execute_supports_laziness = true;
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_translate.cc b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_translate.cc
index 34f7641995f..080238f2d9a 100644
--- a/source/blender/nodes/geometry/nodes/legacy/node_geo_point_translate.cc
+++ b/source/blender/nodes/geometry/nodes/legacy/node_geo_point_translate.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::point_translate_node {
 
 static void geo_node_point_translate_declare(NodeDeclarationBuilder &b)
 {
@@ -89,7 +89,7 @@ static void geo_node_point_translate_update(bNodeTree *UNUSED(ntree), bNode *nod
       *node, "Translation", (GeometryNodeAttributeInputMode)node_storage.input_type);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::point_translate_node
 
 void register_node_type_geo_point_translate()
 {
@@ -97,14 +97,15 @@ void register_node_type_geo_point_translate()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_POINT_TRANSLATE, "Point Translate", NODE_CLASS_GEOMETRY, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_point_translate_init);
-  node_type_update(&ntype, blender::nodes::geo_node_point_translate_update);
+  node_type_init(&ntype, blender::nodes::point_translate_node::geo_node_point_translate_init);
+  node_type_update(&ntype, blender::nodes::point_translate_node::geo_node_point_translate_update);
   node_type_storage(&ntype,
                     "NodeGeometryPointTranslate",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_point_translate_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_translate_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_translate_layout;
+  ntype.declare = blender::nodes::point_translate_node::geo_node_point_translate_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::point_translate_node::geo_node_point_translate_exec;
+  ntype.draw_buttons = blender::nodes::point_translate_node::geo_node_point_translate_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
index 165f5da5f71..88046aa19d2 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_handle_type_selection.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::handle_type_selection_node {
 
 static void geo_node_curve_handle_type_selection_declare(NodeDeclarationBuilder &b)
 {
@@ -152,7 +152,7 @@ static void geo_node_curve_handle_type_selection_exec(GeoNodeExecParams params)
   params.set_output("Selection", std::move(selection_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::handle_type_selection_node
 
 void register_node_type_geo_curve_handle_type_selection()
 {
@@ -163,14 +163,19 @@ void register_node_type_geo_curve_handle_type_selection()
                      "Handle Type Selection",
                      NODE_CLASS_GEOMETRY,
                      0);
-  ntype.declare = blender::nodes::geo_node_curve_handle_type_selection_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_handle_type_selection_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_handle_type_selection_init);
+  ntype.declare =
+      blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_exec;
+  node_type_init(
+      &ntype,
+      blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSelectHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_handle_type_selection_layout;
+  ntype.draw_buttons =
+      blender::nodes::handle_type_selection_node::geo_node_curve_handle_type_selection_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
index b1dc45a426a..ae621fe19bb 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_reverse.cc
@@ -20,7 +20,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::curve_reverse_node {
 
 static void geo_node_curve_reverse_declare(NodeDeclarationBuilder &b)
 {
@@ -60,13 +60,13 @@ static void geo_node_curve_reverse_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::curve_reverse_node
 
 void register_node_type_geo_curve_reverse()
 {
   static bNodeType ntype;
   geo_node_type_base(&ntype, GEO_NODE_REVERSE_CURVE, "Reverse Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_reverse_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_reverse_exec;
+  ntype.declare = blender::nodes::curve_reverse_node::geo_node_curve_reverse_declare;
+  ntype.geometry_node_execute = blender::nodes::curve_reverse_node::geo_node_curve_reverse_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
index 8b0a6ca840c..3c5c7888c94 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_set_handles.cc
@@ -21,7 +21,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::set_curve_handles_node {
 
 static void geo_node_curve_set_handles_declare(NodeDeclarationBuilder &b)
 {
@@ -130,21 +130,22 @@ static void geo_node_curve_set_handles_exec(GeoNodeExecParams params)
   }
   params.set_output("Curve", std::move(geometry_set));
 }
-}  // namespace blender::nodes
+}  // namespace blender::nodes::set_curve_handles_node
 
 void register_node_type_geo_curve_set_handles()
 {
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_SET_HANDLES, "Set Handle Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_set_handles_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_set_handles_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_set_handles_init);
+  ntype.declare = blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_exec;
+  node_type_init(&ntype, blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSetHandles",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_set_handles_layout;
+  ntype.draw_buttons = blender::nodes::set_curve_handles_node::geo_node_curve_set_handles_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
index ae4453929ac..b63d4cc8838 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_spline_type.cc
@@ -23,7 +23,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::curve_spline_type_node {
 
 static void geo_node_curve_spline_type_declare(NodeDeclarationBuilder &b)
 {
@@ -288,21 +288,22 @@ static void geo_node_curve_spline_type_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::curve_spline_type_node
 
 void register_node_type_geo_curve_spline_type()
 {
   static bNodeType ntype;
   geo_node_type_base(
       &ntype, GEO_NODE_CURVE_SPLINE_TYPE, "Set Spline Type", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_spline_type_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_spline_type_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_curve_spline_type_init);
+  ntype.declare = blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_exec;
+  node_type_init(&ntype, blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_init);
   node_type_storage(&ntype,
                     "NodeGeometryCurveSplineType",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.draw_buttons = blender::nodes::geo_node_curve_spline_type_layout;
+  ntype.draw_buttons = blender::nodes::curve_spline_type_node::geo_node_curve_spline_type_layout;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
index b52de822c22..96b7a20aea2 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_subdivide.cc
@@ -29,7 +29,7 @@ using blender::fn::GVArray_For_GSpan;
 using blender::fn::GVArray_For_Span;
 using blender::fn::GVArray_Typed;
 
-namespace blender::nodes {
+namespace blender::nodes::curve_subdivide_node {
 
 static void geo_node_curve_subdivide_declare(NodeDeclarationBuilder &b)
 {
@@ -355,14 +355,14 @@ static void geo_node_subdivide_exec(GeoNodeExecParams params)
   params.set_output("Curve", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::curve_subdivide_node
 
 void register_node_type_geo_curve_subdivide()
 {
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SUBDIVIDE_CURVE, "Subdivide Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_subdivide_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivide_exec;
+  ntype.declare = blender::nodes::curve_subdivide_node::geo_node_curve_subdivide_declare;
+  ntype.geometry_node_execute = blender::nodes::curve_subdivide_node::geo_node_subdivide_exec;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
index 38d7fb99e87..f0babfa07ad 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_curve_to_points.cc
@@ -26,7 +26,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::curve_to_points_node {
 
 static void geo_node_curve_to_points_declare(NodeDeclarationBuilder &b)
 {
@@ -289,18 +289,6 @@ static void copy_spline_domain_attributes(const CurveEval &curve,
       ATTR_DOMAIN_CURVE);
 }
 
-void curve_create_default_rotation_attribute(Span<float3> tangents,
-                                             Span<float3> normals,
-                                             MutableSpan<float3> rotations)
-{
-  threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
-    for (const int i : range) {
-      rotations[i] =
-          float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
-    }
-  });
-}
-
 static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
 {
   NodeGeometryCurveToPoints &node_storage = *(NodeGeometryCurveToPoints *)params.node().storage;
@@ -374,6 +362,20 @@ static void geo_node_curve_to_points_exec(GeoNodeExecParams params)
   }
 }
 
+}  // namespace blender::nodes::curve_to_points_node
+
+namespace blender::nodes {
+void curve_create_default_rotation_attribute(Span<float3> tangents,
+                                             Span<float3> normals,
+                                             MutableSpan<float3> rotations)
+{
+  threading::parallel_for(IndexRange(rotations.size()), 512, [&](IndexRange range) {
+    for (const int i : range) {
+      rotations[i] =
+          float4x4::from_normalized_axis_data({0, 0, 0}, normals[i], tangents[i]).to_euler();
+    }
+  });
+}
 }  // namespace blender::nodes
 
 void register_node_type_geo_curve_to_points()
@@ -381,13 +383,14 @@ void register_node_type_geo_curve_to_points()
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_CURVE_TO_POINTS, "Curve to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_curve_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_curve_to_points_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_curve_to_points_layout;
+  ntype.declare = blender::nodes::curve_to_points_node::geo_node_curve_to_points_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::curve_to_points_node::geo_node_curve_to_points_exec;
+  ntype.draw_buttons = blender::nodes::curve_to_points_node::geo_node_curve_to_points_layout;
   node_type_storage(
       &ntype, "NodeGeometryCurveToPoints", node_free_standard_storage, node_copy_standard_storage);
-  node_type_init(&ntype, blender::nodes::geo_node_curve_to_points_init);
-  node_type_update(&ntype, blender::nodes::geo_node_curve_to_points_update);
+  node_type_init(&ntype, blender::nodes::curve_to_points_node::geo_node_curve_to_points_init);
+  node_type_update(&ntype, blender::nodes::curve_to_points_node::geo_node_curve_to_points_update);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
index e0a3faaefb0..4ac155d2f57 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
@@ -46,7 +46,7 @@ extern void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
                                           blender::Span<int> masked_poly_indices,
                                           blender::Span<int> new_loop_starts);
 
-namespace blender::nodes {
+namespace blender::nodes::delete_geometry_node {
 
 static void geo_node_delete_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -1148,6 +1148,36 @@ static void separate_mesh_selection(GeometrySet &geometry_set,
   do_mesh_separation(geometry_set, src_component, selection, invert, selection_domain, mode);
 }
 
+static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
+{
+  GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
+
+  const Field<bool> selection_field = params.extract_input<Field<bool>>("Selection");
+
+  const bNode &node = params.node();
+  const NodeGeometryDeleteGeometry &storage = *(const NodeGeometryDeleteGeometry *)node.storage;
+  const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
+  const GeometryNodeDeleteGeometryMode mode = static_cast<GeometryNodeDeleteGeometryMode>(
+      storage.mode);
+
+  bool all_is_error = false;
+  geometry_set.modify_geometry_sets([&](GeometrySet &geometry_set) {
+    bool this_is_error = false;
+    /* Invert here because we want to keep the things not in the selection. */
+    separate_geometry(geometry_set, domain, mode, selection_field, true, this_is_error);
+    all_is_error &= this_is_error;
+  });
+  if (all_is_error) {
+    /* Only show this if none of the instances/components actually changed. */
+    params.error_message_add(NodeWarningType::Info, TIP_("No geometry with given domain"));
+  }
+
+  params.set_output("Geometry", std::move(geometry_set));
+}
+
+}  // namespace blender::nodes::delete_geometry_node
+
+namespace blender::nodes {
 void separate_geometry(GeometrySet &geometry_set,
                        const AttributeDomain domain,
                        const GeometryNodeDeleteGeometryMode mode,
@@ -1155,6 +1185,7 @@ void separate_geometry(GeometrySet &geometry_set,
                        const bool invert,
                        bool &r_is_error)
 {
+  using namespace blender::nodes::delete_geometry_node;
   bool some_valid_domain = false;
   if (geometry_set.has_pointcloud()) {
     if (domain == ATTR_DOMAIN_POINT) {
@@ -1176,34 +1207,6 @@ void separate_geometry(GeometrySet &geometry_set,
   }
   r_is_error = !some_valid_domain && geometry_set.has_realized_data();
 }
-
-static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
-{
-  GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
-
-  const Field<bool> selection_field = params.extract_input<Field<bool>>("Selection");
-
-  const bNode &node = params.node();
-  const NodeGeometryDeleteGeometry &storage = *(const NodeGeometryDeleteGeometry *)node.storage;
-  const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
-  const GeometryNodeDeleteGeometryMode mode = static_cast<GeometryNodeDeleteGeometryMode>(
-      storage.mode);
-
-  bool all_is_error = false;
-  geometry_set.modify_geometry_sets([&](GeometrySet &geometry_set) {
-    bool this_is_error = false;
-    /* Invert here because we want to keep the things not in the selection. */
-    separate_geometry(geometry_set, domain, mode, selection_field, true, this_is_error);
-    all_is_error &= this_is_error;
-  });
-  if (all_is_error) {
-    /* Only show this if none of the instances/components actually changed. */
-    params.error_message_add(NodeWarningType::Info, TIP_("No geometry with given domain"));
-  }
-
-  params.set_output("Geometry", std::move(geometry_set));
-}
-
 }  // namespace blender::nodes
 
 void register_node_type_geo_delete_geometry()
@@ -1217,10 +1220,11 @@ void register_node_type_geo_delete_geometry()
                     node_free_standard_storage,
                     node_copy_standard_storage);
 
-  node_type_init(&ntype, blender::nodes::geo_node_delete_geometry_init);
+  node_type_init(&ntype, blender::nodes::delete_geometry_node::geo_node_delete_geometry_init);
 
-  ntype.declare = blender::nodes::geo_node_delete_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_delete_geometry_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_delete_geometry_layout;
+  ntype.declare = blender::nodes::delete_geometry_node::geo_node_delete_geometry_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::delete_geometry_node::geo_node_delete_geometry_exec;
+  ntype.draw_buttons = blender::nodes::delete_geometry_node::geo_node_delete_geometry_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
index fa439b04da0..4e274bd956b 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc
@@ -38,7 +38,7 @@
 
 using blender::bke::GeometryInstanceGroup;
 
-namespace blender::nodes {
+namespace blender::nodes::distribute_points_on_faces_node {
 
 static void geo_node_point_distribute_points_on_faces_declare(NodeDeclarationBuilder &b)
 {
@@ -573,7 +573,7 @@ static void geo_node_point_distribute_points_on_faces_exec(GeoNodeExecParams par
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::distribute_points_on_faces_node
 
 void register_node_type_geo_distribute_points_on_faces()
 {
@@ -584,10 +584,15 @@ void register_node_type_geo_distribute_points_on_faces()
                      "Distribute Points on Faces",
                      NODE_CLASS_GEOMETRY,
                      0);
-  node_type_update(&ntype, blender::nodes::node_point_distribute_points_on_faces_update);
+  node_type_update(&ntype,
+                   blender::nodes::distribute_points_on_faces_node::
+                       node_point_distribute_points_on_faces_update);
   node_type_size(&ntype, 170, 100, 320);
-  ntype.declare = blender::nodes::geo_node_point_distribute_points_on_faces_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_point_distribute_points_on_faces_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_point_distribute_points_on_faces_layout;
+  ntype.declare = blender::nodes::distribute_points_on_faces_node::
+      geo_node_point_distribute_points_on_faces_declare;
+  ntype.geometry_node_execute = blender::nodes::distribute_points_on_faces_node::
+      geo_node_point_distribute_points_on_faces_exec;
+  ntype.draw_buttons = blender::nodes::distribute_points_on_faces_node::
+      geo_node_point_distribute_points_on_faces_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
index f562fb29e90..e627e147f35 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_edge_split.cc
@@ -22,7 +22,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::edge_split_node {
 
 static void geo_node_edge_split_declare(NodeDeclarationBuilder &b)
 {
@@ -81,14 +81,14 @@ static void geo_node_edge_split_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::edge_split_node
 
 void register_node_type_geo_edge_split()
 {
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_SPLIT_EDGES, "Split Edges", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_edge_split_exec;
-  ntype.declare = blender::nodes::geo_node_edge_split_declare;
+  ntype.geometry_node_execute = blender::nodes::edge_split_node::geo_node_edge_split_exec;
+  ntype.declare = blender::nodes::edge_split_node::geo_node_edge_split_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
index 34946b1115c..0f43803afea 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_raycast.cc
@@ -27,7 +27,7 @@
 
 using namespace blender::bke::mesh_surface_sample;
 
-namespace blender::nodes {
+namespace blender::nodes::raycast_node {
 
 static void geo_node_raycast_declare(NodeDeclarationBuilder &b)
 {
@@ -426,7 +426,7 @@ static void geo_node_raycast_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::raycast_node
 
 void register_node_type_geo_raycast()
 {
@@ -434,12 +434,12 @@ void register_node_type_geo_raycast()
 
   geo_node_type_base(&ntype, GEO_NODE_RAYCAST, "Raycast", NODE_CLASS_GEOMETRY, 0);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, blender::nodes::geo_node_raycast_init);
-  node_type_update(&ntype, blender::nodes::geo_node_raycast_update);
+  node_type_init(&ntype, blender::nodes::raycast_node::geo_node_raycast_init);
+  node_type_update(&ntype, blender::nodes::raycast_node::geo_node_raycast_update);
   node_type_storage(
       &ntype, "NodeGeometryRaycast", node_free_standard_storage, node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_raycast_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_raycast_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_raycast_layout;
+  ntype.declare = blender::nodes::raycast_node::geo_node_raycast_declare;
+  ntype.geometry_node_execute = blender::nodes::raycast_node::geo_node_raycast_exec;
+  ntype.draw_buttons = blender::nodes::raycast_node::geo_node_raycast_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc
index 28e214c0ccc..f4a65f3ae59 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_separate_geometry.cc
@@ -19,7 +19,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::separate_geometry_node {
 
 static void geo_node_separate_geometry_declare(NodeDeclarationBuilder &b)
 {
@@ -95,7 +95,7 @@ static void geo_node_separate_geometry_exec(GeoNodeExecParams params)
   }
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::separate_geometry_node
 
 void register_node_type_geo_separate_geometry()
 {
@@ -109,10 +109,11 @@ void register_node_type_geo_separate_geometry()
                     node_free_standard_storage,
                     node_copy_standard_storage);
 
-  node_type_init(&ntype, blender::nodes::geo_node_separate_geometry_init);
+  node_type_init(&ntype, blender::nodes::separate_geometry_node::geo_node_separate_geometry_init);
 
-  ntype.declare = blender::nodes::geo_node_separate_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_separate_geometry_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_separate_geometry_layout;
+  ntype.declare = blender::nodes::separate_geometry_node::geo_node_separate_geometry_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::separate_geometry_node::geo_node_separate_geometry_exec;
+  ntype.draw_buttons = blender::nodes::separate_geometry_node::geo_node_separate_geometry_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
index e47ce7dea30..4b937b1e8d4 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_curve_radius.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::set_curve_radius_node {
 
 static void geo_node_set_curve_radius_declare(NodeDeclarationBuilder &b)
 {
@@ -69,7 +69,7 @@ static void geo_node_set_curve_radius_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::set_curve_radius_node
 
 void register_node_type_geo_set_curve_radius()
 {
@@ -77,7 +77,8 @@ void register_node_type_geo_set_curve_radius()
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_CURVE_RADIUS, "Set Curve Radius", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_curve_radius_exec;
-  ntype.declare = blender::nodes::geo_node_set_curve_radius_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::set_curve_radius_node::geo_node_set_curve_radius_exec;
+  ntype.declare = blender::nodes::set_curve_radius_node::geo_node_set_curve_radius_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
index 9ff299542b4..d2679073691 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_set_point_radius.cc
@@ -16,7 +16,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::set_point_radius_node {
 
 static void geo_node_set_point_radius_declare(NodeDeclarationBuilder &b)
 {
@@ -70,7 +70,7 @@ static void geo_node_set_point_radius_exec(GeoNodeExecParams params)
   params.set_output("Points", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::set_point_radius_node
 
 void register_node_type_geo_set_point_radius()
 {
@@ -78,7 +78,8 @@ void register_node_type_geo_set_point_radius()
 
   geo_node_type_base(
       &ntype, GEO_NODE_SET_POINT_RADIUS, "Set Point Radius", NODE_CLASS_GEOMETRY, 0);
-  ntype.geometry_node_execute = blender::nodes::geo_node_set_point_radius_exec;
-  ntype.declare = blender::nodes::geo_node_set_point_radius_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::set_point_radius_node::geo_node_set_point_radius_exec;
+  ntype.declare = blender::nodes::set_point_radius_node::geo_node_set_point_radius_declare;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
index a889678537f..606598bb30f 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc
@@ -36,7 +36,7 @@
 using namespace blender::bke::mesh_surface_sample;
 using blender::fn::GArray;
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_transfer_node {
 
 static void geo_node_transfer_attribute_declare(NodeDeclarationBuilder &b)
 {
@@ -802,7 +802,7 @@ static void geo_node_transfer_attribute_exec(GeoNodeExecParams params)
   output_attribute_field(params, std::move(output_field));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_transfer_node
 
 void register_node_type_geo_transfer_attribute()
 {
@@ -810,14 +810,17 @@ void register_node_type_geo_transfer_attribute()
 
   geo_node_type_base(
       &ntype, GEO_NODE_TRANSFER_ATTRIBUTE, "Transfer Attribute", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_transfer_attribute_init);
-  node_type_update(&ntype, blender::nodes::geo_node_transfer_attribute_update);
+  node_type_init(&ntype,
+                 blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_init);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_update);
   node_type_storage(&ntype,
                     "NodeGeometryTransferAttribute",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_transfer_attribute_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_transfer_attribute_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_transfer_attribute_layout;
+  ntype.declare = blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_exec;
+  ntype.draw_buttons = blender::nodes::attribute_transfer_node::geo_node_transfer_attribute_layout;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_hair_info.c b/source/blender/nodes/shader/nodes/node_shader_hair_info.c
index c721fb9c77a..a1dc1aa77cc 100644
--- a/source/blender/nodes/shader/nodes/node_shader_hair_info.c
+++ b/source/blender/nodes/shader/nodes/node_shader_hair_info.c
@@ -19,7 +19,7 @@
 
 #include "../node_shader_util.h"
 
-static bNodeSocketTemplate outputs[] = {
+static bNodeSocketTemplate node_shader_hair_info_outputs[] = {
     {SOCK_FLOAT, N_("Is Strand"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_FLOAT, N_("Intercept"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_FLOAT, N_("Length"), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@@ -49,7 +49,7 @@ void register_node_type_sh_hair_info(void)
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_HAIR_INFO, "Hair Info", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, outputs);
+  node_type_socket_templates(&ntype, NULL, node_shader_hair_info_outputs);
   node_type_init(&ntype, NULL);
   node_type_storage(&ntype, "", NULL, NULL);
   node_type_gpu(&ntype, node_shader_gpu_hair_info);
diff --git a/source/blender/nodes/shader/nodes/node_shader_holdout.c b/source/blender/nodes/shader/nodes/node_shader_holdout.c
index b58f86c1fc0..4481fc473ca 100644
--- a/source/blender/nodes/shader/nodes/node_shader_holdout.c
+++ b/source/blender/nodes/shader/nodes/node_shader_holdout.c
@@ -30,11 +30,11 @@ static bNodeSocketTemplate sh_node_holdout_out[] = {
     {-1, ""},
 };
 
-static int gpu_shader_rgb(GPUMaterial *mat,
-                          bNode *node,
-                          bNodeExecData *UNUSED(execdata),
-                          GPUNodeStack *in,
-                          GPUNodeStack *out)
+static int sh_node_holdout_gpu_shader_rgb(GPUMaterial *mat,
+                                          bNode *node,
+                                          bNodeExecData *UNUSED(execdata),
+                                          GPUNodeStack *in,
+                                          GPUNodeStack *out)
 {
   return GPU_stack_link(mat, node, "node_holdout", in, out);
 }
@@ -48,7 +48,7 @@ void register_node_type_sh_holdout(void)
   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);
+  node_type_gpu(&ntype, sh_node_holdout_gpu_shader_rgb);
 
   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 c866a154e8c..5a9892fd338 100644
--- a/source/blender/nodes/shader/nodes/node_shader_map_range.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_map_range.cc
@@ -53,7 +53,7 @@ static void node_shader_init_map_range(bNodeTree *UNUSED(ntree), bNode *node)
   node->custom2 = NODE_MAP_RANGE_LINEAR; /* interpolation */
 }
 
-static const char *gpu_shader_get_name(int mode)
+static const char *gpu_shader_map_range_gpu_shader_get_name(int mode)
 {
   switch (mode) {
     case NODE_MAP_RANGE_LINEAR:
@@ -75,7 +75,7 @@ static int gpu_shader_map_range(GPUMaterial *mat,
                                 GPUNodeStack *in,
                                 GPUNodeStack *out)
 {
-  const char *name = gpu_shader_get_name(node->custom2);
+  const char *name = gpu_shader_map_range_gpu_shader_get_name(node->custom2);
 
   int ret = 0;
   if (name != nullptr) {
diff --git a/source/blender/nodes/shader/nodes/node_shader_math.cc b/source/blender/nodes/shader/nodes/node_shader_math.cc
index 284a5f1189f..641b46c2548 100644
--- a/source/blender/nodes/shader/nodes/node_shader_math.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_math.cc
@@ -46,7 +46,7 @@ static void sh_node_math_declare(NodeDeclarationBuilder &b)
 
 }  // namespace blender::nodes
 
-static const char *gpu_shader_get_name(int mode)
+static const char *sh_node_math_gpu_shader_get_name(int mode)
 {
   const blender::nodes::FloatMathOperationInfo *info =
       blender::nodes::get_float_math_operation_info(mode);
@@ -65,7 +65,7 @@ static int gpu_shader_math(GPUMaterial *mat,
                            GPUNodeStack *in,
                            GPUNodeStack *out)
 {
-  const char *name = gpu_shader_get_name(node->custom1);
+  const char *name = sh_node_math_gpu_shader_get_name(node->custom1);
   if (name != nullptr) {
     int ret = GPU_stack_link(mat, node, name, in, out);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc b/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
index 06fafff578e..f89cba8d2b0 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
@@ -62,7 +62,7 @@ static void node_shader_exec_mix_rgb(void *UNUSED(data),
   copy_v3_v3(out[0]->vec, col);
 }
 
-static const char *gpu_shader_get_name(int mode)
+static const char *gpu_shader_mix_rgb_gpu_shader_get_name(int mode)
 {
   switch (mode) {
     case MA_RAMP_BLEND:
@@ -112,7 +112,7 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat,
                               GPUNodeStack *in,
                               GPUNodeStack *out)
 {
-  const char *name = gpu_shader_get_name(node->custom1);
+  const char *name = gpu_shader_mix_rgb_gpu_shader_get_name(node->custom1);
 
   if (name != nullptr) {
     int ret = GPU_stack_link(mat, node, name, in, out);
diff --git a/source/blender/nodes/shader/nodes/node_shader_particle_info.c b/source/blender/nodes/shader/nodes/node_shader_particle_info.c
index c6eabc3b2cb..80bc1c84a69 100644
--- a/source/blender/nodes/shader/nodes/node_shader_particle_info.c
+++ b/source/blender/nodes/shader/nodes/node_shader_particle_info.c
@@ -20,7 +20,7 @@
 #include "../node_shader_util.h"
 #include "RE_texture.h"
 
-static bNodeSocketTemplate outputs[] = {
+static bNodeSocketTemplate node_shader_particle_info_outputs[] = {
     {SOCK_FLOAT, "Index"},
     {SOCK_FLOAT, "Random"},
     {SOCK_FLOAT, "Age"},
@@ -67,7 +67,7 @@ void register_node_type_sh_particle_info(void)
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_PARTICLE_INFO, "Particle Info", NODE_CLASS_INPUT, 0);
-  node_type_socket_templates(&ntype, NULL, outputs);
+  node_type_socket_templates(&ntype, NULL, node_shader_particle_info_outputs);
   node_type_exec(&ntype, NULL, NULL, node_shader_exec_particle_info);
   node_type_gpu(&ntype, gpu_shader_particle_info);
 
diff --git a/source/blender/nodes/shader/nodes/node_shader_rgb.c b/source/blender/nodes/shader/nodes/node_shader_rgb.c
index 0bdef9a2a17..85927d8d134 100644
--- a/source/blender/nodes/shader/nodes/node_shader_rgb.c
+++ b/source/blender/nodes/shader/nodes/node_shader_rgb.c
@@ -29,11 +29,11 @@ static bNodeSocketTemplate sh_node_rgb_out[] = {
     {-1, ""},
 };
 
-static int gpu_shader_rgb(GPUMaterial *mat,
-                          bNode *node,
-                          bNodeExecData *UNUSED(execdata),
-                          GPUNodeStack *in,
-                          GPUNodeStack *out)
+static int sh_node_rgb_gpu_shader_rgb(GPUMaterial *mat,
+                                      bNode *node,
+                                      bNodeExecData *UNUSED(execdata),
+                                      GPUNodeStack *in,
+                                      GPUNodeStack *out)
 {
   GPUNodeLink *link = GPU_uniformbuf_link_out(mat, node, out, 0);
   return GPU_stack_link(mat, node, "set_rgba", in, out, link);
@@ -45,7 +45,7 @@ void register_node_type_sh_rgb(void)
 
   sh_node_type_base(&ntype, SH_NODE_RGB, "RGB", NODE_CLASS_INPUT, 0);
   node_type_socket_templates(&ntype, NULL, sh_node_rgb_out);
-  node_type_gpu(&ntype, gpu_shader_rgb);
+  node_type_gpu(&ntype, sh_node_rgb_gpu_shader_rgb);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_script.c b/source/blender/nodes/shader/nodes/node_shader_script.c
index 42ab272de0e..4a72b51f1a2 100644
--- a/source/blender/nodes/shader/nodes/node_shader_script.c
+++ b/source/blender/nodes/shader/nodes/node_shader_script.c
@@ -25,7 +25,7 @@
 
 /* **************** Script ******************** */
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_shader_script_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   NodeShaderScript *nss = MEM_callocN(sizeof(NodeShaderScript), "shader script node");
   node->storage = nss;
@@ -63,7 +63,7 @@ void register_node_type_sh_script(void)
   static bNodeType ntype;
 
   sh_node_type_base(&ntype, SH_NODE_SCRIPT, "Script", NODE_CLASS_SCRIPT, 0);
-  node_type_init(&ntype, init);
+  node_type_init(&ntype, node_shader_script_init);
   node_type_storage(&ntype, "NodeShaderScript", node_free_script, node_copy_script);
 
   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 d28095edb96..81a9d44b3de 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_noise.cc
@@ -52,7 +52,7 @@ static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode *node)
   node->storage = tex;
 }
 
-static const char *gpu_shader_get_name(const int dimensions)
+static const char *node_shader_tex_noise_gpu_shader_get_name(const int dimensions)
 {
   BLI_assert(dimensions >= 1 && dimensions <= 4);
   return std::array{"node_noise_texture_1d",
@@ -72,7 +72,7 @@ static int node_shader_gpu_tex_noise(GPUMaterial *mat,
   node_shader_gpu_tex_mapping(mat, node, in, out);
 
   NodeTexNoise *tex = (NodeTexNoise *)node->storage;
-  const char *name = gpu_shader_get_name(tex->dimensions);
+  const char *name = node_shader_tex_noise_gpu_shader_get_name(tex->dimensions);
   return GPU_stack_link(mat, node, name, in, out);
 }
 
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 422268b98c3..113a3dd1770 100644
--- a/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_tex_voronoi.cc
@@ -61,7 +61,8 @@ static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode *node)
   node->storage = tex;
 }
 
-static const char *gpu_shader_get_name(const int feature, const int dimensions)
+static const char *node_shader_tex_voronoi_gpu_shader_get_name(const int feature,
+                                                               const int dimensions)
 {
   BLI_assert(feature >= 0 && feature < 5);
   BLI_assert(dimensions > 0 && dimensions < 5);
@@ -118,7 +119,7 @@ static int node_shader_gpu_tex_voronoi(GPUMaterial *mat,
   NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
   float metric = tex->distance;
 
-  const char *name = gpu_shader_get_name(tex->feature, tex->dimensions);
+  const char *name = node_shader_tex_voronoi_gpu_shader_get_name(tex->feature, tex->dimensions);
 
   return GPU_stack_link(mat, node, name, in, out, GPU_constant(&metric));
 }
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 43ee9400551..8f27c9f4518 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
@@ -39,7 +39,7 @@ static void node_shader_init_tex_white_noise(bNodeTree *UNUSED(ntree), bNode *no
   node->custom1 = 3;
 }
 
-static const char *gpu_shader_get_name(const int dimensions)
+static const char *node_shader_tex_white_noise_gpu_shader_get_name(const int dimensions)
 {
   BLI_assert(dimensions >= 1 && dimensions <= 4);
   return std::array{"node_white_noise_1d",
@@ -54,7 +54,7 @@ static int gpu_shader_tex_white_noise(GPUMaterial *mat,
                                       GPUNodeStack *in,
                                       GPUNodeStack *out)
 {
-  const char *name = gpu_shader_get_name(node->custom1);
+  const char *name = node_shader_tex_white_noise_gpu_shader_get_name(node->custom1);
   return GPU_stack_link(mat, node, name, in, out);
 }
 
@@ -183,7 +183,8 @@ class WhiteNoiseFunction : public fn::MultiFunction {
   }
 };
 
-static void sh_node_noise_build_multi_function(blender::nodes::NodeMultiFunctionBuilder &builder)
+static void sh_node_white_noise_build_multi_function(
+    blender::nodes::NodeMultiFunctionBuilder &builder)
 {
   bNode &node = builder.node();
   builder.construct_and_set_matching_fn<WhiteNoiseFunction>((int)node.custom1);
@@ -201,7 +202,7 @@ void register_node_type_sh_tex_white_noise(void)
   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;
+  ntype.build_multi_function = blender::nodes::sh_node_white_noise_build_multi_function;
 
   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 ca5aeea9a7d..64e7ba33fd2 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_math.cc
@@ -40,7 +40,7 @@ static void sh_node_vector_math_declare(NodeDeclarationBuilder &b)
 
 }  // namespace blender::nodes
 
-static const char *gpu_shader_get_name(int mode)
+static const char *sh_node_vector_math_gpu_shader_get_name(int mode)
 {
   switch (mode) {
     case NODE_VECTOR_MATH_ADD:
@@ -111,7 +111,7 @@ static int gpu_shader_vector_math(GPUMaterial *mat,
                                   GPUNodeStack *in,
                                   GPUNodeStack *out)
 {
-  const char *name = gpu_shader_get_name(node->custom1);
+  const char *name = sh_node_vector_math_gpu_shader_get_name(node->custom1);
   if (name != nullptr) {
     return GPU_stack_link(mat, node, name, in, out);
   }
@@ -187,7 +187,7 @@ static void node_shader_update_vector_math(bNodeTree *UNUSED(ntree), bNode *node
   }
 }
 
-static const blender::fn::MultiFunction *get_multi_function(bNode &node)
+static const blender::fn::MultiFunction *sh_node_vector_math_get_multi_function(bNode &node)
 {
   using blender::float3;
 
@@ -269,7 +269,7 @@ static const blender::fn::MultiFunction *get_multi_function(bNode &node)
 static void sh_node_vector_math_build_multi_function(
     blender::nodes::NodeMultiFunctionBuilder &builder)
 {
-  const blender::fn::MultiFunction *fn = get_multi_function(builder.node());
+  const blender::fn::MultiFunction *fn = sh_node_vector_math_get_multi_function(builder.node());
   builder.set_matching_fn(fn);
 }
 
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 1ab643bc3fa..5fbbe1be652 100644
--- a/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_vector_rotate.cc
@@ -38,7 +38,7 @@ static void sh_node_vector_rotate_declare(NodeDeclarationBuilder &b)
 
 }  // namespace blender::nodes
 
-static const char *gpu_shader_get_name(int mode)
+static const char *shader_nose_vector_rotate_gpu_shader_get_name(int mode)
 {
   switch (mode) {
     case NODE_VECTOR_ROTATE_TYPE_AXIS:
@@ -62,7 +62,7 @@ static int gpu_shader_vector_rotate(GPUMaterial *mat,
                                     GPUNodeStack *in,
                                     GPUNodeStack *out)
 {
-  const char *name = gpu_shader_get_name(node->custom1);
+  const char *name = shader_nose_vector_rotate_gpu_shader_get_name(node->custom1);
 
   if (name != nullptr) {
     float invert = (node->custom2) ? -1.0 : 1.0;
@@ -101,7 +101,8 @@ static float3 sh_node_vector_rotate_euler(const float3 vector,
   return result + center;
 }
 
-static const blender::fn::MultiFunction *get_multi_function(bNode &node)
+static const blender::fn::MultiFunction *sh_node_vector_rotate_euler_get_multi_function(
+    bNode &node)
 {
   bool invert = node.custom2;
   const int mode = node.custom1;
@@ -189,7 +190,8 @@ static const blender::fn::MultiFunction *get_multi_function(bNode &node)
 static void sh_node_vector_rotate_build_multi_function(
     blender::nodes::NodeMultiFunctionBuilder &builder)
 {
-  const blender::fn::MultiFunction *fn = get_multi_function(builder.node());
+  const blender::fn::MultiFunction *fn = sh_node_vector_rotate_euler_get_multi_function(
+      builder.node());
   builder.set_matching_fn(fn);
 }
 
diff --git a/source/blender/nodes/texture/node_texture_tree.c b/source/blender/nodes/texture/node_texture_tree.c
index 14597050524..49753c7e7ec 100644
--- a/source/blender/nodes/texture/node_texture_tree.c
+++ b/source/blender/nodes/texture/node_texture_tree.c
@@ -50,114 +50,114 @@
 
 #include "RE_texture.h"
 
-static void texture_get_from_context(const bContext *C,
-                                     bNodeTreeType *UNUSED(treetype),
-                                     bNodeTree **r_ntree,
-                                     ID **r_id,
-                                     ID **r_from)
-{
-  SpaceNode *snode = CTX_wm_space_node(C);
-  Scene *scene = CTX_data_scene(C);
-  ViewLayer *view_layer = CTX_data_view_layer(C);
-  Object *ob = OBACT(view_layer);
-  Tex *tx = NULL;
-
-  if (snode->texfrom == SNODE_TEX_BRUSH) {
-    struct Brush *brush = NULL;
-
-    if (ob && (ob->mode & OB_MODE_SCULPT)) {
-      brush = BKE_paint_brush(&scene->toolsettings->sculpt->paint);
-    }
-    else {
-      brush = BKE_paint_brush(&scene->toolsettings->imapaint.paint);
-    }
-
-    if (brush) {
-      *r_from = (ID *)brush;
-      tx = give_current_brush_texture(brush);
-      if (tx) {
-        *r_id = &tx->id;
-        *r_ntree = tx->nodetree;
-      }
-    }
-  }
-  else if (snode->texfrom == SNODE_TEX_LINESTYLE) {
-    FreestyleLineStyle *linestyle = BKE_linestyle_active_from_view_layer(view_layer);
-    if (linestyle) {
-      *r_from = (ID *)linestyle;
-      tx = give_current_linestyle_texture(linestyle);
-      if (tx) {
-        *r_id = &tx->id;
-        *r_ntree = tx->nodetree;
-      }
-    }
-  }
-}
-
-static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
-{
-  func(calldata, NODE_CLASS_INPUT, N_("Input"));
-  func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
-  func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
-  func(calldata, NODE_CLASS_PATTERN, N_("Patterns"));
-  func(calldata, NODE_CLASS_TEXTURE, N_("Textures"));
-  func(calldata, NODE_CLASS_CONVERTER, N_("Converter"));
-  func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
-  func(calldata, NODE_CLASS_GROUP, N_("Group"));
-  func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
-  func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
-}
-
-/* XXX muting disabled in previews because of threading issues with the main execution
- * it works here, but disabled for consistency
- */
-#if 1
-static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
-{
-  bNode *node, *node_next;
-
-  /* replace muted nodes and reroute nodes by internal links */
-  for (node = localtree->nodes.first; node; node = node_next) {
-    node_next = node->next;
-
-    if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
-      nodeInternalRelink(localtree, node);
-      ntreeFreeLocalNode(localtree, node);
-    }
-  }
-}
-#else
-static void localize(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree))
-{
-}
-#endif
-
-static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
-{
-  BKE_node_preview_sync_tree(ntree, localtree);
-}
-
-static void local_merge(Main *UNUSED(bmain), bNodeTree *localtree, bNodeTree *ntree)
-{
-  BKE_node_preview_merge_tree(ntree, localtree, true);
-}
-
-static void update(bNodeTree *ntree)
-{
-  ntree_update_reroute_nodes(ntree);
-
-  if (ntree->update & NTREE_UPDATE_NODES) {
-    /* clean up preview cache, in case nodes have been removed */
-    BKE_node_preview_remove_unused(ntree);
-  }
-}
-
-static bool texture_node_tree_socket_type_valid(bNodeTreeType *UNUSED(ntreetype),
-                                                bNodeSocketType *socket_type)
-{
-  return nodeIsStaticSocketType(socket_type) &&
-         ELEM(socket_type->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA);
-}
+// static void texture_get_from_context(const bContext *C,
+//                                      bNodeTreeType *UNUSED(treetype),
+//                                      bNodeTree **r_ntree,
+//                                      ID **r_id,
+//                                      ID **r_from)
+// {
+//   SpaceNode *snode = CTX_wm_space_node(C);
+//   Scene *scene = CTX_data_scene(C);
+//   ViewLayer *view_layer = CTX_data_view_layer(C);
+//   Object *ob = OBACT(view_layer);
+//   Tex *tx = NULL;
+
+//   if (snode->texfrom == SNODE_TEX_BRUSH) {
+//     struct Brush *brush = NULL;
+
+//     if (ob && (ob->mode & OB_MODE_SCULPT)) {
+//       brush = BKE_paint_brush(&scene->toolsettings->sculpt->paint);
+//     }
+//     else {
+//       brush = BKE_paint_brush(&scene->toolsettings->imapaint.paint);
+//     }
+
+//     if (brush) {
+//       *r_from = (ID *)brush;
+//       tx = give_current_brush_texture(brush);
+//       if (tx) {
+//         *r_id = &tx->id;
+//         *r_ntree = tx->nodetree;
+//       }
+//     }
+//   }
+//   else if (snode->texfrom == SNODE_TEX_LINESTYLE) {
+//     FreestyleLineStyle *linestyle = BKE_linestyle_active_from_view_layer(view_layer);
+//     if (linestyle) {
+//       *r_from = (ID *)linestyle;
+//       tx = give_current_linestyle_texture(linestyle);
+//       if (tx) {
+//         *r_id = &tx->id;
+//         *r_ntree = tx->nodetree;
+//       }
+//     }
+//   }
+// }
+
+// static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
+// {
+//   func(calldata, NODE_CLASS_INPUT, N_("Input"));
+//   func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
+//   func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
+//   func(calldata, NODE_CLASS_PATTERN, N_("Patterns"));
+//   func(calldata, NODE_CLASS_TEXTURE, N_("Textures"));
+//   func(calldata, NODE_CLASS_CONVERTER, N_("Converter"));
+//   func(calldata, NODE_CLASS_DISTORT, N_("Distort"));
+//   func(calldata, NODE_CLASS_GROUP, N_("Group"));
+//   func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
+//   func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
+// }
+
+// /* XXX muting disabled in previews because of threading issues with the main execution
+//  * it works here, but disabled for consistency
+//  */
+// #if 1
+// static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
+// {
+//   bNode *node, *node_next;
+
+//   /* replace muted nodes and reroute nodes by internal links */
+//   for (node = localtree->nodes.first; node; node = node_next) {
+//     node_next = node->next;
+
+//     if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
+//       nodeInternalRelink(localtree, node);
+//       ntreeFreeLocalNode(localtree, node);
+//     }
+//   }
+// }
+// #else
+// static void localize(bNodeTree *UNUSED(localtree), bNodeTree *UNUSED(ntree))
+// {
+// }
+// #endif
+
+// static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
+// {
+//   BKE_node_preview_sync_tree(ntree, localtree);
+// }
+
+// static void local_merge(Main *UNUSED(bmain), bNodeTree *localtree, bNodeTree *ntree)
+// {
+//   BKE_node_preview_merge_tree(ntree, localtree, true);
+// }
+
+// static void update(bNodeTree *ntree)
+// {
+//   ntree_update_reroute_nodes(ntree);
+
+//   if (ntree->update & NTREE_UPDATE_NODES) {
+//     /* clean up preview cache, in case nodes have been removed */
+//     BKE_node_preview_remove_unused(ntree);
+//   }
+// }
+
+// static bool texture_node_tree_socket_type_valid(bNodeTreeType *UNUSED(ntreetype),
+//                                                 bNodeSocketType *socket_type)
+// {
+//   return nodeIsStaticSocketType(socket_type) &&
+//          ELEM(socket_type->type, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA);
+// }
 
 bNodeTreeType *ntreeType_Texture;
 
@@ -172,13 +172,13 @@ void register_node_tree_type_tex(void)
   tt->ui_icon = 0; /* Defined in `drawnode.c`. */
   strcpy(tt->ui_description, N_("Texture nodes"));
 
-  tt->foreach_nodeclass = foreach_nodeclass;
-  tt->update = update;
-  tt->localize = localize;
-  tt->local_sync = local_sync;
-  tt->local_merge = local_merge;
-  tt->get_from_context = texture_get_from_context;
-  tt->valid_socket_type = texture_node_tree_socket_type_valid;
+  // tt->foreach_nodeclass = foreach_nodeclass;
+  // tt->update = update;
+  // tt->localize = localize;
+  // tt->local_sync = local_sync;
+  // tt->local_merge = local_merge;
+  // tt->get_from_context = texture_get_from_context;
+  // tt->valid_socket_type = texture_node_tree_socket_type_valid;
 
   tt->rna_ext.srna = &RNA_TextureNodeTree;
 
diff --git a/source/blender/nodes/texture/nodes/node_texture_bricks.c b/source/blender/nodes/texture/nodes/node_texture_bricks.c
index 72690d6ccfe..54e8409e2c5 100644
--- a/source/blender/nodes/texture/nodes/node_texture_bricks.c
+++ b/source/blender/nodes/texture/nodes/node_texture_bricks.c
@@ -26,7 +26,7 @@
 
 #include <math.h>
 
-static bNodeSocketTemplate inputs[] = {
+static bNodeSocketTemplate node_sh_texture_brick_inputs[] = {
     {SOCK_RGBA, N_("Bricks 1"), 0.596f, 0.282f, 0.0f, 1.0f},
     {SOCK_RGBA, N_("Bricks 2"), 0.632f, 0.504f, 0.05f, 1.0f},
     {SOCK_RGBA, N_("Mortar"), 0.0f, 0.0f, 0.0f, 1.0f},
@@ -36,18 +36,18 @@ static bNodeSocketTemplate inputs[] = {
     {SOCK_FLOAT, N_("Row Height"), 0.25f, 0.0f, 0.0f, 0.0f, 0.001f, 99.0f, PROP_UNSIGNED},
     {-1, ""},
 };
-static bNodeSocketTemplate outputs[] = {
+static bNodeSocketTemplate node_sh_texture_brick_outputs[] = {
     {SOCK_RGBA, N_("Color")},
     {-1, ""},
 };
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_sh_texture_brick_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   node->custom3 = 0.5; /* offset */
   node->custom4 = 1.0; /* squash */
 }
 
-static float noise(int n) /* fast integer noise */
+static float node_sh_texture_brick_noise(int n) /* fast integer noise */
 {
   int nn;
   n = (n >> 13) ^ n;
@@ -55,7 +55,8 @@ static float noise(int n) /* fast integer noise */
   return 0.5f * ((float)nn / 1073741824.0f);
 }
 
-static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, short thread)
+static void node_sh_texture_brick_colorfn(
+    float *out, TexParams *p, bNode *node, bNodeStack **in, short thread)
 {
   const float *co = p->co;
 
@@ -92,7 +93,7 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
   ins_x = (x + offset) - brick_width * bricknum;
   ins_y = y - row_height * rownum;
 
-  tint = noise((rownum << 16) + (bricknum & 0xFFFF)) + bias;
+  tint = node_sh_texture_brick_noise((rownum << 16) + (bricknum & 0xFFFF)) + bias;
   CLAMP(tint, 0.0f, 1.0f);
 
   if (ins_x < mortar_thickness || ins_y < mortar_thickness ||
@@ -105,14 +106,14 @@ static void colorfn(float *out, TexParams *p, bNode *node, bNodeStack **in, shor
   }
 }
 
-static void exec(void *data,
-                 int UNUSED(thread),
-                 bNode *node,
-                 bNodeExecData *execdata,
-                 bNodeStack **in,
-                 bNodeStack **out)
+static void node_sh_texture_brick_exec(void *data,
+                                       int UNUSED(thread),
+                                       bNode *node,
+                                       bNodeExecData *execdata,
+                                       bNodeStack **in,
+                                       bNodeStack **out)
 {
-  tex_output(node, execdata, in, out[0], &colorfn, data);
+  tex_output(node, execdata, in, out[0], &node_sh_texture_brick_colorfn, data);
 }
 
 void register_node_type_tex_bricks(void)
@@ -120,10 +121,10 @@ void register_node_type_tex_bricks(void)
   static bNodeType ntype;
 
   tex_node_type_base(&ntype, TEX_NODE_BRICKS, "Bricks", NODE_CLASS_PATTERN, NODE_PREVIEW);
-  node_type_socket_templates(&ntype, inputs, outputs);
+  node_type_socket_templates(&ntype, node_sh_texture_brick_inputs, node_sh_texture_brick_outputs);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, init);
-  node_type_exec(&ntype, NULL, NULL, exec);
+  node_type_init(&ntype, node_sh_texture_brick_init);
+  node_type_exec(&ntype, NULL, NULL, node_sh_texture_brick_exec);
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/texture/nodes/node_texture_image.c b/source/blender/nodes/texture/nodes/node_texture_image.c
index a85b963286b..31ab7e3fdf7 100644
--- a/source/blender/nodes/texture/nodes/node_texture_image.c
+++ b/source/blender/nodes/texture/nodes/node_texture_image.c
@@ -24,12 +24,12 @@
 #include "NOD_texture.h"
 #include "node_texture_util.h"
 
-static bNodeSocketTemplate outputs[] = {
+static bNodeSocketTemplate node_sh_texture_image_outputs[] = {
     {SOCK_RGBA, N_("Image")},
     {-1, ""},
 };
 
-static void colorfn(
+static void node_sh_texture_image_colorfn(
     float *out, TexParams *p, bNode *node, bNodeStack **UNUSED(in), short UNUSED(thread))
 {
   float x = p->co[0];
@@ -86,17 +86,17 @@ static void colorfn(
   }
 }
 
-static void exec(void *data,
-                 int UNUSED(thread),
-                 bNode *node,
-                 bNodeExecData *execdata,
-                 bNodeStack **in,
-                 bNodeStack **out)
+static void node_sh_texture_image_exec(void *data,
+                                       int UNUSED(thread),
+                                       bNode *node,
+                                       bNodeExecData *execdata,
+                                       bNodeStack **in,
+                                       bNodeStack **out)
 {
-  tex_output(node, execdata, in, out[0], &colorfn, data);
+  tex_output(node, execdata, in, out[0], &node_sh_texture_image_colorfn, data);
 }
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_sh_texture_image_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   ImageUser *iuser = MEM_callocN(sizeof(ImageUser), "node image user");
   node->storage = iuser;
@@ -109,10 +109,10 @@ void register_node_type_tex_image(void)
   static bNodeType ntype;
 
   tex_node_type_base(&ntype, TEX_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW);
-  node_type_socket_templates(&ntype, NULL, outputs);
-  node_type_init(&ntype, init);
+  node_type_socket_templates(&ntype, NULL, node_sh_texture_image_outputs);
+  node_type_init(&ntype, node_sh_texture_image_init);
   node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
-  node_type_exec(&ntype, NULL, NULL, exec);
+  node_type_exec(&ntype, NULL, NULL, node_sh_texture_image_exec);
   node_type_label(&ntype, node_image_label);
 
   nodeRegisterType(&ntype);
diff --git a/source/blender/nodes/texture/nodes/node_texture_output.c b/source/blender/nodes/texture/nodes/node_texture_output.c
index b24781e032b..f78750eff46 100644
--- a/source/blender/nodes/texture/nodes/node_texture_output.c
+++ b/source/blender/nodes/texture/nodes/node_texture_output.c
@@ -25,19 +25,19 @@
 #include "node_texture_util.h"
 
 /* **************** COMPOSITE ******************** */
-static bNodeSocketTemplate inputs[] = {
+static bNodeSocketTemplate node_cmp_texture_out_inputs[] = {
     {SOCK_RGBA, N_("Color"), 0.0f, 0.0f, 0.0f, 1.0f},
     {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, PROP_DIRECTION},
     {-1, ""},
 };
 
 /* applies to render pipeline */
-static void exec(void *data,
-                 int UNUSED(thread),
-                 bNode *node,
-                 bNodeExecData *execdata,
-                 bNodeStack **in,
-                 bNodeStack **UNUSED(out))
+static void node_cmp_texture_out_exec(void *data,
+                                      int UNUSED(thread),
+                                      bNode *node,
+                                      bNodeExecData *execdata,
+                                      bNodeStack **in,
+                                      bNodeStack **UNUSED(out))
 {
   TexCallData *cdata = (TexCallData *)data;
   TexResult *target = cdata->target;
@@ -77,7 +77,7 @@ static void exec(void *data,
   }
 }
 
-static void unique_name(bNode *node)
+static void node_cmp_texture_out_unique_name(bNode *node)
 {
   TexNodeOutput *tno = (TexNodeOutput *)node->storage;
   char new_name[sizeof(tno->name)];
@@ -121,7 +121,7 @@ static void unique_name(bNode *node)
   }
 }
 
-static void assign_index(struct bNode *node)
+static void node_cmp_texture_out_assign_index(struct bNode *node)
 {
   bNode *tnode;
   int index = 1;
@@ -144,21 +144,23 @@ check_index:
   node->custom1 = index;
 }
 
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
+static void node_cmp_texture_out_init(bNodeTree *UNUSED(ntree), bNode *node)
 {
   TexNodeOutput *tno = MEM_callocN(sizeof(TexNodeOutput), "TEX_output");
   node->storage = tno;
 
   strcpy(tno->name, "Default");
-  unique_name(node);
-  assign_index(node);
+  node_cmp_texture_out_unique_name(node);
+  node_cmp_texture_out_assign_index(node);
 }
 
-static void copy(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node)
+static void node_cmp_texture_out_copy(bNodeTree *dest_ntree,
+                                      bNode *dest_node,
+                                      const bNode *src_node)
 {
   node_copy_standard_storage(dest_ntree, dest_node, src_node);
-  unique_name(dest_node);
-  assign_index(dest_node);
+  node_cmp_texture_out_unique_name(dest_node);
+  node_cmp_texture_out_assign_index(dest_node);
 }
 
 void register_node_type_tex_output(void)
@@ -166,11 +168,12 @@ void register_node_type_tex_output(void)
   static bNodeType ntype;
 
   tex_node_type_base(&ntype, TEX_NODE_OUTPUT, "Output", NODE_CLASS_OUTPUT, NODE_PREVIEW);
-  node_type_socket_templates(&ntype, inputs, NULL);
+  node_type_socket_templates(&ntype, node_cmp_texture_out_inputs, NULL);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
-  node_type_init(&ntype, init);
-  node_type_storage(&ntype, "TexNodeOutput", node_free_standard_storage, copy);
-  node_type_exec(&ntype, NULL, NULL, exec);
+  node_type_init(&ntype, node_cmp_texture_out_init);
+  node_type_storage(
+      &ntype, "TexNodeOutput", node_free_standard_storage, node_cmp_texture_out_copy);
+  node_type_exec(&ntype, NULL, NULL, node_cmp_texture_out_exec);
 
   /* Do not allow muting output. */
   node_type_internal_links(&ntype, NULL);
diff --git a/source/blender/nodes/texture/nodes/node_texture_proc.c b/source/blender/nodes/texture/nodes/node_texture_proc.c
index a8a82153e58..7ca6384d793 100644
--- a/source/blender/nodes/texture/nodes/node_texture_proc.c
+++ b/source/blender/nodes/texture/nodes/node_texture_proc.c
@@ -29,287 +29,3 @@
 /*
  * In this file: wrappers to use procedural textures as nodes
  */
-
-static bNodeSocketTemplate outputs_both[] = {
-    {SOCK_RGBA, N_("Color"), 1.0f, 0.0f, 0.0f, 1.0f},
-    {SOCK_VECTOR, N_("Normal"), 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, PROP_DIRECTION},
-    {-1, ""}};
-static bNodeSocketTemplate outputs_color_only[] = {{SOCK_RGBA, N_("Color")}, {-1, ""}};
-
-/* Inputs common to all, #defined because nodes will need their own inputs too */
-#define I 2 /* count */
-#define COMMON_INPUTS \
-  {SOCK_RGBA, "Color 1", 0.0f, 0.0f, 0.0f, 1.0f}, \
-  { \
-    SOCK_RGBA, "Color 2", 1.0f, 1.0f, 1.0f, 1.0f \
-  }
-
-/* Calls multitex and copies the result to the outputs.
- * Called by xxx_exec, which handles inputs. */
-static void do_proc(float *result,
-                    TexParams *p,
-                    const float col1[4],
-                    const float col2[4],
-                    char is_normal,
-                    Tex *tex,
-                    const short thread)
-{
-  TexResult texres;
-  int textype;
-
-  if (is_normal) {
-    texres.nor = result;
-  }
-  else {
-    texres.nor = NULL;
-  }
-
-  textype = multitex_nodes(
-      tex, p->co, p->dxt, p->dyt, p->osatex, &texres, thread, 0, p->mtex, NULL);
-
-  if (is_normal) {
-    return;
-  }
-
-  if (textype & TEX_RGB) {
-    copy_v4_v4(result, &texres.tr);
-  }
-  else {
-    copy_v4_v4(result, col1);
-    ramp_blend(MA_RAMP_BLEND, result, texres.tin, col2);
-  }
-}
-
-typedef void (*MapFn)(Tex *tex, bNodeStack **in, TexParams *p, const short thread);
-
-static void texfn(float *result,
-                  TexParams *p,
-                  bNode *node,
-                  bNodeStack **in,
-                  char is_normal,
-                  MapFn map_inputs,
-                  short thread)
-{
-  Tex tex = *((Tex *)(node->storage));
-  float col1[4], col2[4];
-  tex_input_rgba(col1, in[0], p, thread);
-  tex_input_rgba(col2, in[1], p, thread);
-
-  map_inputs(&tex, in, p, thread);
-
-  do_proc(result, p, col1, col2, is_normal, &tex, thread);
-}
-
-static int count_outputs(bNode *node)
-{
-  bNodeSocket *sock;
-  int num = 0;
-  for (sock = node->outputs.first; sock; sock = sock->next) {
-    num++;
-  }
-  return num;
-}
-
-/* Boilerplate generators */
-
-#define ProcNoInputs(name) \
-  static void name##_map_inputs( \
-      Tex *UNUSED(tex), bNodeStack **UNUSED(in), TexParams *UNUSED(p), short UNUSED(thread)) \
-  { \
-  }
-
-#define ProcDef(name) \
-  static void name##_colorfn( \
-      float *result, TexParams *p, bNode *node, bNodeStack **in, short thread) \
-  { \
-    texfn(result, p, node, in, 0, &name##_map_inputs, thread); \
-  } \
-  static void name##_normalfn( \
-      float *result, TexParams *p, bNode *node, bNodeStack **in, short thread) \
-  { \
-    texfn(result, p, node, in, 1, &name##_map_inputs, thread); \
-  } \
-  static void name##_exec(void *data, \
-                          int UNUSED(thread), \
-                          bNode *node, \
-                          bNodeExecData *execdata, \
-                          bNodeStack **in, \
-                          bNodeStack **out) \
-  { \
-    int outs = count_outputs(node); \
-    if (outs >= 1) { \
-      tex_output(node, execdata, in, out[0], &name##_colorfn, data); \
-    } \
-    if (outs >= 2) { \
-      tex_output(node, execdata, in, out[1], &name##_normalfn, data); \
-    } \
-  }
-
-/* --- VORONOI -- */
-static bNodeSocketTemplate voronoi_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("W1"), 1.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
-    {SOCK_FLOAT, N_("W2"), 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
-    {SOCK_FLOAT, N_("W3"), 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
-    {SOCK_FLOAT, N_("W4"), 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_NONE},
-
-    {SOCK_FLOAT, N_("iScale"), 1.0f, 0.0f, 0.0f, 0.0f, 0.01f, 10.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 4.0f, PROP_UNSIGNED},
-
-    {-1, ""}};
-static void voronoi_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->vn_w1 = tex_input_value(in[I + 0], p, thread);
-  tex->vn_w2 = tex_input_value(in[I + 1], p, thread);
-  tex->vn_w3 = tex_input_value(in[I + 2], p, thread);
-  tex->vn_w4 = tex_input_value(in[I + 3], p, thread);
-
-  tex->ns_outscale = tex_input_value(in[I + 4], p, thread);
-  tex->noisesize = tex_input_value(in[I + 5], p, thread);
-}
-ProcDef(voronoi);
-
-/* --- BLEND -- */
-static bNodeSocketTemplate blend_inputs[] = {COMMON_INPUTS, {-1, ""}};
-ProcNoInputs(blend);
-ProcDef(blend);
-
-/* -- MAGIC -- */
-static bNodeSocketTemplate magic_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void magic_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->turbul = tex_input_value(in[I + 0], p, thread);
-}
-ProcDef(magic);
-
-/* --- MARBLE --- */
-static bNodeSocketTemplate marble_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void marble_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->noisesize = tex_input_value(in[I + 0], p, thread);
-  tex->turbul = tex_input_value(in[I + 1], p, thread);
-}
-ProcDef(marble);
-
-/* --- CLOUDS --- */
-static bNodeSocketTemplate clouds_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void clouds_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->noisesize = tex_input_value(in[I + 0], p, thread);
-}
-ProcDef(clouds);
-
-/* --- DISTORTED NOISE --- */
-static bNodeSocketTemplate distnoise_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Distortion"), 1.00f, 0.0f, 0.0f, 0.0f, 0.0000f, 10.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void distnoise_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->noisesize = tex_input_value(in[I + 0], p, thread);
-  tex->dist_amount = tex_input_value(in[I + 1], p, thread);
-}
-ProcDef(distnoise);
-
-/* --- WOOD --- */
-static bNodeSocketTemplate wood_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void wood_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->noisesize = tex_input_value(in[I + 0], p, thread);
-  tex->turbul = tex_input_value(in[I + 1], p, thread);
-}
-ProcDef(wood);
-
-/* --- MUSGRAVE --- */
-static bNodeSocketTemplate musgrave_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("H"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Lacunarity"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 6.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Octaves"), 2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 8.0f, PROP_UNSIGNED},
-
-    {SOCK_FLOAT, N_("iScale"), 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 10.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void musgrave_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->mg_H = tex_input_value(in[I + 0], p, thread);
-  tex->mg_lacunarity = tex_input_value(in[I + 1], p, thread);
-  tex->mg_octaves = tex_input_value(in[I + 2], p, thread);
-  tex->ns_outscale = tex_input_value(in[I + 3], p, thread);
-  tex->noisesize = tex_input_value(in[I + 4], p, thread);
-}
-ProcDef(musgrave);
-
-/* --- NOISE --- */
-static bNodeSocketTemplate noise_inputs[] = {COMMON_INPUTS, {-1, ""}};
-ProcNoInputs(noise);
-ProcDef(noise);
-
-/* --- STUCCI --- */
-static bNodeSocketTemplate stucci_inputs[] = {
-    COMMON_INPUTS,
-    {SOCK_FLOAT, N_("Size"), 0.25f, 0.0f, 0.0f, 0.0f, 0.0001f, 2.0f, PROP_UNSIGNED},
-    {SOCK_FLOAT, N_("Turbulence"), 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 200.0f, PROP_UNSIGNED},
-    {-1, ""}};
-static void stucci_map_inputs(Tex *tex, bNodeStack **in, TexParams *p, short thread)
-{
-  tex->noisesize = tex_input_value(in[I + 0], p, thread);
-  tex->turbul = tex_input_value(in[I + 1], p, thread);
-}
-ProcDef(stucci);
-
-/* --- */
-
-static void init(bNodeTree *UNUSED(ntree), bNode *node)
-{
-  Tex *tex = MEM_callocN(sizeof(Tex), "Tex");
-  node->storage = tex;
-
-  BKE_texture_default(tex);
-  tex->type = node->type - TEX_NODE_PROC;
-
-  if (tex->type == TEX_WOOD) {
-    tex->stype = TEX_BANDNOISE;
-  }
-}
-
-/* Node type definitions */
-#define TexDef(TEXTYPE, outputs, name, Name) \
-  void register_node_type_tex_proc_##name(void) \
-  { \
-    static bNodeType ntype; \
-\
-    tex_node_type_base(&ntype, TEX_NODE_PROC + TEXTYPE, Name, NODE_CLASS_TEXTURE, NODE_PREVIEW); \
-    node_type_socket_templates(&ntype, name##_inputs, outputs); \
-    node_type_size_preset(&ntype, NODE_SIZE_MIDDLE); \
-    node_type_init(&ntype, init); \
-    node_type_storage(&ntype, "Tex", node_free_standard_storage, node_copy_standard_storage); \
-    node_type_exec(&ntype, NULL, NULL, name##_exec); \
-\
-    nodeRegisterType(&ntype); \
-  }
-
-#define C outputs_color_only
-#define CV outputs_both
-
-TexDef(TEX_VORONOI, CV, voronoi, "Voronoi") TexDef(TEX_BLEND, C, blend, "Blend");
-TexDef(TEX_MAGIC, C, magic, "Magic") TexDef(TEX_MARBLE, CV, marble, "Marble");
-TexDef(TEX_CLOUDS, CV, clouds, "Clouds") TexDef(TEX_WOOD, CV, wood, "Wood");
-TexDef(TEX_MUSGRAVE, CV, musgrave, "Musgrave") TexDef(TEX_NOISE, C, noise, "Noise");
-TexDef(TEX_STUCCI, CV, stucci, "Stucci");
-TexDef(TEX_DISTNOISE, CV, distnoise, "Distorted Noise");