add cmake changes

source/blender/blenkernel/BKE_volume_to_mesh.hh

@@ -14,6 +14,8 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
+#pragma once
+
 #include "BLI_span.hh"
 
 #include "DNA_modifier_types.h"

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_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_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_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_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_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_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()

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
 
@@ -552,3 +552,20 @@ if(WITH_OPENVDB)
 endif()
 
 blender_add_lib(bf_nodes "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
+
+if (${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.16")
+  set_target_properties(bf_nodes PROPERTIES UNITY_BUILD ON)
+  set_target_properties(bf_nodes PROPERTIES UNITY_BUILD_BATCH_SIZE 10)
+  # target_precompile_headers(bf_nodes
+  #   PRIVATE
+  #     "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/geometry/node_geometry_util.hh>"
+  #     "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/NOD_geometry_exec.hh>"
+  #     "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/NOD_geometry_nodes_eval_log.hh>"
+  # )
+  # if(WIN32)
+  #   target_precompile_headers(bf_nodes
+  #     PRIVATE
+  #       "$<$<COMPILE_LANGUAGE:CXX>:bli_winstuff.h>"
+  # )
+  # endif()
+endif()

source/blender/nodes/composite/node_composite_tree.cc

@@ -60,7 +60,9 @@ static void composite_get_from_context(const bContext *C,
   *r_ntree = scene->nodetree;
 }
 
-static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
+static void composite_foreach_nodeclass(Scene *UNUSED(scene),
+                                        void *calldata,
+                                        bNodeClassCallback func)
 {
   func(calldata, NODE_CLASS_INPUT, N_("Input"));
   func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
@@ -75,7 +77,7 @@ static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCa
   func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
 }
 
-static void free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
+static void composite_free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
 {
   LISTBASE_FOREACH (bNodeSocket *, sock, &node->outputs) {
     if (sock->cache) {
@@ -84,15 +86,15 @@ static void free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
   }
 }
 
-static void free_cache(bNodeTree *ntree)
+static void composite_free_cache(bNodeTree *ntree)
 {
   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
-    free_node_cache(ntree, node);
+    composite_free_node_cache(ntree, node);
   }
 }
 
 /* local tree then owns all compbufs */
-static void localize(bNodeTree *localtree, bNodeTree *ntree)
+static void composite_localize(bNodeTree *localtree, bNodeTree *ntree)
 {
 
   bNode *node = (bNode *)ntree->nodes.first;
@@ -135,12 +137,12 @@ static void localize(bNodeTree *localtree, bNodeTree *ntree)
   }
 }
 
-static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
+static void composite_local_sync(bNodeTree *localtree, bNodeTree *ntree)
 {
   BKE_node_preview_sync_tree(ntree, localtree);
 }
 
-static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
+static void composite_local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
 {
   bNode *lnode;
   bNodeSocket *lsock;
@@ -181,7 +183,7 @@ static void local_merge(Main *bmain, bNodeTree *localtree, bNodeTree *ntree)
   }
 }
 
-static void update(bNodeTree *ntree)
+static void composite_update(bNodeTree *ntree)
 {
   ntreeSetOutput(ntree);
 
@@ -223,13 +225,13 @@ void register_node_tree_type_cmp(void)
   tt->ui_icon = 0; /* Defined in `drawnode.c`. */
   strcpy(tt->ui_description, N_("Compositing nodes"));
 
-  tt->free_cache = free_cache;
-  tt->free_node_cache = free_node_cache;
-  tt->foreach_nodeclass = foreach_nodeclass;
-  tt->localize = localize;
-  tt->local_sync = local_sync;
-  tt->local_merge = local_merge;
-  tt->update = update;
+  tt->free_cache = composite_free_cache;
+  tt->free_node_cache = composite_free_node_cache;
+  tt->foreach_nodeclass = composite_foreach_nodeclass;
+  tt->localize = composite_localize;
+  tt->local_sync = composite_local_sync;
+  tt->local_merge = composite_local_merge;
+  tt->update = composite_update;
   tt->get_from_context = composite_get_from_context;
   tt->node_add_init = composite_node_add_init;
   tt->valid_socket_type = composite_node_tree_socket_type_valid;

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);
 

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);
 }

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);
 

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);
 }

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);
 

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);
 

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);
 }

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);
 }

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);
 }

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);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_clamp()
 {
@@ -270,11 +270,15 @@ 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_legacy_node::geo_node_attribute_clamp_init);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_update);
+  ntype.declare = blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_clamp_legacy_node::geo_node_attribute_clamp_layout;
   node_type_storage(
       &ntype, "NodeAttributeClamp", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_color_ramp()
 {
@@ -132,10 +132,15 @@ 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_legacy_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_legacy_node::geo_node_attribute_color_ramp_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_color_ramp_legacy_node::geo_node_attribute_color_ramp_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_color_ramp_legacy_node::geo_node_attribute_color_ramp_layout;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_combine_xyz()
 {
@@ -141,13 +141,20 @@ 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_legacy_node::geo_node_attribute_combine_xyz_init);
+  node_type_update(
+      &ntype,
+      blender::nodes::attribute_combine_xyz_legacy_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_legacy_node::geo_node_attribute_combine_xyz_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_combine_xyz_legacy_node::geo_node_attribute_combine_xyz_layout;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_compare()
 {
@@ -349,12 +349,17 @@ 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_legacy_node::geo_node_attribute_compare_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_compare_legacy_node::geo_node_attribute_compare_layout;
+  node_type_update(
+      &ntype, blender::nodes::attribute_compare_legacy_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_legacy_node::geo_node_attribute_compare_init);
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_curve_map()
 {
@@ -212,15 +212,22 @@ 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_legacy_node::geo_node_attribute_curve_map_update);
+  node_type_init(
+      &ntype, blender::nodes::attribute_curve_map_legacy_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_legacy_node::geo_node_attribute_curve_map_free_storage,
+      blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_copy_storage);
+  ntype.declare =
+      blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_curve_map_legacy_node::geo_node_attribute_curve_map_layout;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_fill()
 {
@@ -154,10 +154,12 @@ 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_legacy_node::geo_node_attribute_fill_init);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_update);
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_exec;
+  ntype.draw_buttons = blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_layout;
+  ntype.declare = blender::nodes::attribute_fill_legacy_node::geo_node_attribute_fill_declare;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_map_range()
 {
@@ -421,12 +421,18 @@ 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_legacy_node::geo_node_attribute_map_range_exec;
+  node_type_init(
+      &ntype, blender::nodes::attribute_map_range_legacy_node::geo_node_attribute_map_range_init);
+  node_type_update(
+      &ntype,
+      blender::nodes::attribute_map_range_legacy_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_legacy_node::geo_node_attribute_map_range_declare;
+  ntype.draw_buttons =
+      blender::nodes::attribute_map_range_legacy_node::fn_attribute_map_range_layout;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_math()
 {
@@ -303,12 +303,14 @@ 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_legacy_node::geo_node_attribute_math_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_exec;
+  ntype.draw_buttons = blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_layout;
+  node_type_label(&ntype, blender::nodes::attribute_math_legacy_node::geo_node_math_label);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_update);
+  node_type_init(&ntype, blender::nodes::attribute_math_legacy_node::geo_node_attribute_math_init);
   node_type_storage(
       &ntype, "NodeAttributeMath", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);

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_legacy_node {
 
 static void geo_node_mix_attribute_declare(NodeDeclarationBuilder &b)
 {
@@ -238,19 +238,21 @@ static void geo_node_attribute_mix_exec(GeoNodeExecParams params)
   params.set_output("Geometry", geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_mix_legacy_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_legacy_node::geo_node_attribute_mix_init);
+  node_type_update(&ntype,
+                   blender::nodes::attribute_mix_legacy_node::geo_node_attribute_mix_update);
+  ntype.declare = blender::nodes::attribute_mix_legacy_node::geo_node_mix_attribute_declare;
+  ntype.draw_buttons = blender::nodes::attribute_mix_legacy_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_legacy_node::geo_node_attribute_mix_exec;
   nodeRegisterType(&ntype);
 }

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);
+  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::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;
+  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);

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_legacy_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_legacy_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_legacy_node::
+      geo_node_attribute_sample_texture_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_sample_texture_legacy_node::geo_node_attribute_sample_texture_exec;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_separate_xyz()
 {
@@ -162,12 +162,19 @@ 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_legacy_node::geo_node_attribute_separate_xyz_declare;
+  node_type_init(
+      &ntype,
+      blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_init);
+  node_type_update(
+      &ntype,
+      blender::nodes::attribute_separate_xyz_legacy_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_legacy_node::geo_node_attribute_separate_xyz_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_separate_xyz_legacy_node::geo_node_attribute_separate_xyz_layout;
   nodeRegisterType(&ntype);
 }

source/blender/nodes/geometry/nodes/legacy/node_geo_attribute_transfer.cc

@@ -29,7 +29,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::attribute_transfer_legacy_node {
 
 static void geo_node_attribute_transfer_declare(NodeDeclarationBuilder &b)
 {
@@ -510,7 +510,7 @@ static void geo_node_attribute_transfer_exec(GeoNodeExecParams params)
   params.set_output("Geometry", dst_geometry_set);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::attribute_transfer_legacy_node
 
 void register_node_type_geo_legacy_attribute_transfer()
 {
@@ -518,13 +518,17 @@ void register_node_type_geo_legacy_attribute_transfer()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_ATTRIBUTE_TRANSFER, "Attribute Transfer", NODE_CLASS_ATTRIBUTE, 0);
-  node_type_init(&ntype, blender::nodes::geo_node_attribute_transfer_init);
+  node_type_init(&ntype,
+                 blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_init);
   node_type_storage(&ntype,
                     "NodeGeometryAttributeTransfer",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  ntype.declare = blender::nodes::geo_node_attribute_transfer_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_attribute_transfer_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_attribute_transfer_layout;
+  ntype.declare =
+      blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_transfer_legacy_node::geo_node_attribute_transfer_layout;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_vector_math()
 {
@@ -560,12 +560,20 @@ 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_legacy_node::geo_node_attribute_vector_math_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_layout;
+  node_type_label(&ntype,
+                  blender::nodes::attribute_vector_math_legacy_node::geo_node_vector_math_label);
+  node_type_update(
+      &ntype,
+      blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_update);
+  node_type_init(
+      &ntype,
+      blender::nodes::attribute_vector_math_legacy_node::geo_node_attribute_vector_math_init);
   node_type_storage(
       &ntype, "NodeAttributeVectorMath", node_free_standard_storage, node_copy_standard_storage);
 

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_legacy_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_legacy_node
 
 void register_node_type_geo_attribute_vector_rotate()
 {
@@ -336,13 +336,20 @@ 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_legacy_node::
+                       geo_node_attribute_vector_rotate_update);
+  node_type_init(
+      &ntype,
+      blender::nodes::attribute_vector_rotate_legacy_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_legacy_node::geo_node_attribute_vector_rotate_exec;
+  ntype.draw_buttons =
+      blender::nodes::attribute_vector_rotate_legacy_node::geo_node_attribute_vector_rotate_layout;
+  ntype.declare = blender::nodes::attribute_vector_rotate_legacy_node::
+      geo_node_attribute_vector_rotate_declare;
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_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_legacy_node::geo_node_curve_endpoints_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::curve_endpoints_legacy_node::geo_node_curve_endpoints_exec;
 
   nodeRegisterType(&ntype);
 }

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_legacy_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_legacy_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_legacy_node::geo_node_select_by_handle_type_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::select_by_handle_type_legacy_node::geo_node_select_by_handle_type_exec;
+  node_type_init(&ntype,
+                 blender::nodes::select_by_handle_type_legacy_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_legacy_node::
+      geo_node_curve_select_by_handle_type_layout;
 
   nodeRegisterType(&ntype);
 }

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);
 }

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);
 }

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);
 }

source/blender/nodes/geometry/nodes/legacy/node_geo_delete_geometry.cc

@@ -29,21 +29,21 @@
 using blender::bke::CustomDataAttributes;
 
 /* Code from the mask modifier in MOD_mask.cc. */
-extern void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
-                                             Mesh &dst_mesh,
-                                             blender::Span<int> vertex_map);
-extern void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
-                                          Mesh &dst_mesh,
-                                          blender::Span<int> vertex_map,
-                                          blender::Span<int> edge_map);
-extern void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
-                                          Mesh &dst_mesh,
-                                          blender::Span<int> vertex_map,
-                                          blender::Span<int> edge_map,
-                                          blender::Span<int> masked_poly_indices,
-                                          blender::Span<int> new_loop_starts);
+void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
+                                      Mesh &dst_mesh,
+                                      blender::Span<int> vertex_map);
+void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
+                                   Mesh &dst_mesh,
+                                   blender::Span<int> vertex_map,
+                                   blender::Span<int> edge_map);
+void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
+                                   Mesh &dst_mesh,
+                                   blender::Span<int> vertex_map,
+                                   blender::Span<int> edge_map,
+                                   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);
 }

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);
 }

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);
 }

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);
 }

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);

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);
 }

source/blender/nodes/geometry/nodes/legacy/node_geo_subdivision_surface.cc

@@ -23,7 +23,7 @@
 #include "UI_resources.h"
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::subdivision_surface_legacy_node {
 
 static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
 {
@@ -126,7 +126,7 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
   params.set_output("Geometry", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::subdivision_surface_legacy_node
 
 void register_node_type_geo_legacy_subdivision_surface()
 {
@@ -134,10 +134,14 @@ void register_node_type_geo_legacy_subdivision_surface()
 
   geo_node_type_base(
       &ntype, GEO_NODE_LEGACY_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
-  node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
+  ntype.declare =
+      blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_exec;
+  ntype.draw_buttons =
+      blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_layout;
+  node_type_init(
+      &ntype, blender::nodes::subdivision_surface_legacy_node::geo_node_subdivision_surface_init);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
   node_type_storage(&ntype,
                     "NodeGeometrySubdivisionSurface",

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);
 }

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);
 }

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);
 }

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);
 }

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);
 }

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);
 }

source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc

@@ -32,21 +32,21 @@
 using blender::bke::CustomDataAttributes;
 
 /* Code from the mask modifier in MOD_mask.cc. */
-extern void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
-                                             Mesh &dst_mesh,
-                                             blender::Span<int> vertex_map);
-extern void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
-                                          Mesh &dst_mesh,
-                                          blender::Span<int> vertex_map,
-                                          blender::Span<int> edge_map);
-extern void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
-                                          Mesh &dst_mesh,
-                                          blender::Span<int> vertex_map,
-                                          blender::Span<int> edge_map,
-                                          blender::Span<int> masked_poly_indices,
-                                          blender::Span<int> new_loop_starts);
+void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
+                                      Mesh &dst_mesh,
+                                      blender::Span<int> vertex_map);
+void copy_masked_edges_to_new_mesh(const Mesh &src_mesh,
+                                   Mesh &dst_mesh,
+                                   blender::Span<int> vertex_map,
+                                   blender::Span<int> edge_map);
+void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
+                                   Mesh &dst_mesh,
+                                   blender::Span<int> vertex_map,
+                                   blender::Span<int> edge_map,
+                                   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,35 +1148,6 @@ static void separate_mesh_selection(GeometrySet &geometry_set,
   do_mesh_separation(geometry_set, src_component, selection, invert, selection_domain, mode);
 }
 
-void separate_geometry(GeometrySet &geometry_set,
-                       const AttributeDomain domain,
-                       const GeometryNodeDeleteGeometryMode mode,
-                       const Field<bool> &selection_field,
-                       const bool invert,
-                       bool &r_is_error)
-{
-  bool some_valid_domain = false;
-  if (geometry_set.has_pointcloud()) {
-    if (domain == ATTR_DOMAIN_POINT) {
-      separate_point_cloud_selection(geometry_set, selection_field, invert);
-      some_valid_domain = true;
-    }
-  }
-  if (geometry_set.has_mesh()) {
-    if (domain != ATTR_DOMAIN_CURVE) {
-      separate_mesh_selection(geometry_set, selection_field, domain, mode, invert);
-      some_valid_domain = true;
-    }
-  }
-  if (geometry_set.has_curve()) {
-    if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE)) {
-      separate_curve_selection(geometry_set, selection_field, domain, invert);
-      some_valid_domain = true;
-    }
-  }
-  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");
@@ -1204,6 +1175,38 @@ static void geo_node_delete_geometry_exec(GeoNodeExecParams params)
   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,
+                       const Field<bool> &selection_field,
+                       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) {
+      separate_point_cloud_selection(geometry_set, selection_field, invert);
+      some_valid_domain = true;
+    }
+  }
+  if (geometry_set.has_mesh()) {
+    if (domain != ATTR_DOMAIN_CURVE) {
+      separate_mesh_selection(geometry_set, selection_field, domain, mode, invert);
+      some_valid_domain = true;
+    }
+  }
+  if (geometry_set.has_curve()) {
+    if (ELEM(domain, ATTR_DOMAIN_POINT, ATTR_DOMAIN_CURVE)) {
+      separate_curve_selection(geometry_set, selection_field, domain, invert);
+      some_valid_domain = true;
+    }
+  }
+  r_is_error = !some_valid_domain && geometry_set.has_realized_data();
+}
 }  // 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);
 }

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);
 }

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);
 }

source/blender/nodes/geometry/nodes/node_geo_mesh_to_curve.cc

@@ -18,7 +18,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::mesh_to_curve_node {
 
 static void geo_node_legacy_mesh_to_curve_declare(NodeDeclarationBuilder &b)
 {
@@ -56,14 +56,15 @@ static void geo_node_legacy_mesh_to_curve_exec(GeoNodeExecParams params)
   params.set_output("Curve", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::mesh_to_curve_node
 
 void register_node_type_geo_mesh_to_curve()
 {
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_TO_CURVE, "Mesh to Curve", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_legacy_mesh_to_curve_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_legacy_mesh_to_curve_exec;
+  ntype.declare = blender::nodes::mesh_to_curve_node::geo_node_legacy_mesh_to_curve_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::mesh_to_curve_node::geo_node_legacy_mesh_to_curve_exec;
   nodeRegisterType(&ntype);
 }

source/blender/nodes/geometry/nodes/node_geo_mesh_to_points.cc

@@ -26,7 +26,7 @@
 
 using blender::Array;
 
-namespace blender::nodes {
+namespace blender::nodes::mesh_to_points_node {
 
 static void geo_node_mesh_to_points_declare(NodeDeclarationBuilder &b)
 {
@@ -172,17 +172,17 @@ static void geo_node_mesh_to_points_exec(GeoNodeExecParams params)
   params.set_output("Points", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::mesh_to_points_node
 
 void register_node_type_geo_mesh_to_points()
 {
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_MESH_TO_POINTS, "Mesh to Points", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_mesh_to_points_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_mesh_to_points_exec;
-  node_type_init(&ntype, blender::nodes::geo_node_mesh_to_points_init);
-  ntype.draw_buttons = blender::nodes::geo_node_mesh_to_points_layout;
+  ntype.declare = blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_declare;
+  ntype.geometry_node_execute = blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_exec;
+  node_type_init(&ntype, blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_init);
+  ntype.draw_buttons = blender::nodes::mesh_to_points_node::geo_node_mesh_to_points_layout;
   node_type_storage(
       &ntype, "NodeGeometryMeshToPoints", node_free_standard_storage, node_copy_standard_storage);
   nodeRegisterType(&ntype);

source/blender/nodes/geometry/nodes/node_geo_points_to_volume.cc

@@ -28,7 +28,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::points_to_volume_node {
 
 static void geo_node_points_to_volume_declare(NodeDeclarationBuilder &b)
 {
@@ -253,7 +253,7 @@ static void geo_node_points_to_volume_exec(GeoNodeExecParams params)
 #endif
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::points_to_volume_node
 
 void register_node_type_geo_points_to_volume()
 {
@@ -266,10 +266,12 @@ void register_node_type_geo_points_to_volume()
                     node_free_standard_storage,
                     node_copy_standard_storage);
   node_type_size(&ntype, 170, 120, 700);
-  node_type_init(&ntype, blender::nodes::geo_node_points_to_volume_init);
-  node_type_update(&ntype, blender::nodes::geo_node_points_to_volume_update);
-  ntype.declare = blender::nodes::geo_node_points_to_volume_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_points_to_volume_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_points_to_volume_layout;
+  node_type_init(&ntype, blender::nodes::points_to_volume_node::geo_node_points_to_volume_init);
+  node_type_update(&ntype,
+                   blender::nodes::points_to_volume_node::geo_node_points_to_volume_update);
+  ntype.declare = blender::nodes::points_to_volume_node::geo_node_points_to_volume_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::points_to_volume_node::geo_node_points_to_volume_exec;
+  ntype.draw_buttons = blender::nodes::points_to_volume_node::geo_node_points_to_volume_layout;
   nodeRegisterType(&ntype);
 }

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);
 }

source/blender/nodes/geometry/nodes/node_geo_separate_components.cc

@@ -16,9 +16,9 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::separate_components_node {
 
-static void geo_node_join_geometry_declare(NodeDeclarationBuilder &b)
+static void geo_node_separate_components_declare(NodeDeclarationBuilder &b)
 {
   b.add_input<decl::Geometry>(N_("Geometry"));
   b.add_output<decl::Geometry>(N_("Mesh"));
@@ -61,7 +61,7 @@ static void geo_node_separate_components_exec(GeoNodeExecParams params)
   params.set_output("Instances", instances);
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::separate_components_node
 
 void register_node_type_geo_separate_components()
 {
@@ -69,7 +69,8 @@ void register_node_type_geo_separate_components()
 
   geo_node_type_base(
       &ntype, GEO_NODE_SEPARATE_COMPONENTS, "Separate Components", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_join_geometry_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_separate_components_exec;
+  ntype.declare = blender::nodes::separate_components_node::geo_node_separate_components_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::separate_components_node::geo_node_separate_components_exec;
   nodeRegisterType(&ntype);
 }

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);
 }

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);
 }

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);
 }

source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc

@@ -27,7 +27,7 @@
 
 #include "node_geometry_util.hh"
 
-namespace blender::nodes {
+namespace blender::nodes::subdivision_surface_node {
 
 static void geo_node_subdivision_surface_declare(NodeDeclarationBuilder &b)
 {
@@ -145,7 +145,7 @@ static void geo_node_subdivision_surface_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::subdivision_surface_node
 
 void register_node_type_geo_subdivision_surface()
 {
@@ -153,10 +153,13 @@ void register_node_type_geo_subdivision_surface()
 
   geo_node_type_base(
       &ntype, GEO_NODE_SUBDIVISION_SURFACE, "Subdivision Surface", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_subdivision_surface_declare;
-  ntype.geometry_node_execute = blender::nodes::geo_node_subdivision_surface_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_subdivision_surface_layout;
-  node_type_init(&ntype, blender::nodes::geo_node_subdivision_surface_init);
+  ntype.declare = blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_declare;
+  ntype.geometry_node_execute =
+      blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_exec;
+  ntype.draw_buttons =
+      blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_layout;
+  node_type_init(&ntype,
+                 blender::nodes::subdivision_surface_node::geo_node_subdivision_surface_init);
   node_type_size_preset(&ntype, NODE_SIZE_MIDDLE);
   node_type_storage(&ntype,
                     "NodeGeometrySubdivisionSurface",

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);
 }

source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc

@@ -35,7 +35,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-namespace blender::nodes {
+namespace blender::nodes::volume_to_mesh_node {
 
 static void geo_node_volume_to_mesh_declare(NodeDeclarationBuilder &b)
 {
@@ -192,20 +192,20 @@ static void geo_node_volume_to_mesh_exec(GeoNodeExecParams params)
   params.set_output("Mesh", std::move(geometry_set));
 }
 
-}  // namespace blender::nodes
+}  // namespace blender::nodes::volume_to_mesh_node
 
 void register_node_type_geo_volume_to_mesh()
 {
   static bNodeType ntype;
 
   geo_node_type_base(&ntype, GEO_NODE_VOLUME_TO_MESH, "Volume to Mesh", NODE_CLASS_GEOMETRY, 0);
-  ntype.declare = blender::nodes::geo_node_volume_to_mesh_declare;
+  ntype.declare = blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_declare;
   node_type_storage(
       &ntype, "NodeGeometryVolumeToMesh", node_free_standard_storage, node_copy_standard_storage);
   node_type_size(&ntype, 170, 120, 700);
-  node_type_init(&ntype, blender::nodes::geo_node_volume_to_mesh_init);
-  node_type_update(&ntype, blender::nodes::geo_node_volume_to_mesh_update);
-  ntype.geometry_node_execute = blender::nodes::geo_node_volume_to_mesh_exec;
-  ntype.draw_buttons = blender::nodes::geo_node_volume_to_mesh_layout;
+  node_type_init(&ntype, blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_init);
+  node_type_update(&ntype, blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_update);
+  ntype.geometry_node_execute = blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_exec;
+  ntype.draw_buttons = blender::nodes::volume_to_mesh_node::geo_node_volume_to_mesh_layout;
   nodeRegisterType(&ntype);
 }

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);

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);
 }

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) {

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);
 

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);

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);
 

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);
 }

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);

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);
 }
 

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));
 }

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);
 }

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);
 }
 

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);
 }
 

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;
+// 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 (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 (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;
-      }
-    }
-  }
-}
+//     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"));
-}
+// 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;
+// /* 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;
+//   /* 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
+//     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_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 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);
+// 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);
-  }
-}
+//   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 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;
 

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);
 }

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);

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);

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");