Cleanup: Remove unnecessary namespace specification

Ever since d5b72fb06cd0405c46, shader nodes have been in the
`blender::nodes` namespace, so they don't need to use that to access
Blender's C++ types and functions.

1 files changed, 33 insertions, 44 deletions

diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.cc b/source/blender/nodes/shader/nodes/node_shader_curves.cc
index 64a5cd97250..b1db0248d9f 100644
--- a/source/blender/nodes/shader/nodes/node_shader_curves.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_curves.cc
@@ -72,35 +72,31 @@ static int gpu_shader_curve_vec(GPUMaterial *mat,
                         GPU_uniform(ext_xyz[2]));
 }
 
-class CurveVecFunction : public blender::fn::MultiFunction {
+class CurveVecFunction : public fn::MultiFunction {
  private:
   const CurveMapping &cumap_;
 
  public:
   CurveVecFunction(const CurveMapping &cumap) : cumap_(cumap)
   {
-    static blender::fn::MFSignature signature = create_signature();
+    static fn::MFSignature signature = create_signature();
     this->set_signature(&signature);
   }
 
-  static blender::fn::MFSignature create_signature()
+  static fn::MFSignature create_signature()
   {
-    blender::fn::MFSignatureBuilder signature{"Curve Vec"};
+    fn::MFSignatureBuilder signature{"Curve Vec"};
     signature.single_input<float>("Fac");
-    signature.single_input<blender::float3>("Vector");
-    signature.single_output<blender::float3>("Vector");
+    signature.single_input<float3>("Vector");
+    signature.single_output<float3>("Vector");
     return signature.build();
   }
 
-  void call(blender::IndexMask mask,
-            blender::fn::MFParams params,
-            blender::fn::MFContext UNUSED(context)) const override
+  void call(IndexMask mask, fn::MFParams params, fn::MFContext UNUSED(context)) const override
   {
-    const blender::VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
-    const blender::VArray<blender::float3> &vec_in = params.readonly_single_input<blender::float3>(
-        1, "Vector");
-    blender::MutableSpan<blender::float3> vec_out =
-        params.uninitialized_single_output<blender::float3>(2, "Vector");
+    const VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
+    const VArray<float3> &vec_in = params.readonly_single_input<float3>(1, "Vector");
+    MutableSpan<float3> vec_out = params.uninitialized_single_output<float3>(2, "Vector");
 
     for (int64_t i : mask) {
       BKE_curvemapping_evaluate3F(&cumap_, vec_out[i], vec_in[i]);
@@ -111,8 +107,7 @@ class CurveVecFunction : public blender::fn::MultiFunction {
   }
 };
 
-static void sh_node_curve_vec_build_multi_function(
-    blender::nodes::NodeMultiFunctionBuilder &builder)
+static void sh_node_curve_vec_build_multi_function(NodeMultiFunctionBuilder &builder)
 {
   bNode &bnode = builder.node();
   CurveMapping *cumap = (CurveMapping *)bnode.storage;
@@ -230,35 +225,33 @@ static int gpu_shader_curve_rgb(GPUMaterial *mat,
                         GPU_uniform(ext_rgba[3]));
 }
 
-class CurveRGBFunction : public blender::fn::MultiFunction {
+class CurveRGBFunction : public fn::MultiFunction {
  private:
   const CurveMapping &cumap_;
 
  public:
   CurveRGBFunction(const CurveMapping &cumap) : cumap_(cumap)
   {
-    static blender::fn::MFSignature signature = create_signature();
+    static fn::MFSignature signature = create_signature();
     this->set_signature(&signature);
   }
 
-  static blender::fn::MFSignature create_signature()
+  static fn::MFSignature create_signature()
   {
-    blender::fn::MFSignatureBuilder signature{"Curve RGB"};
+    fn::MFSignatureBuilder signature{"Curve RGB"};
     signature.single_input<float>("Fac");
-    signature.single_input<blender::ColorGeometry4f>("Color");
-    signature.single_output<blender::ColorGeometry4f>("Color");
+    signature.single_input<ColorGeometry4f>("Color");
+    signature.single_output<ColorGeometry4f>("Color");
     return signature.build();
   }
 
-  void call(blender::IndexMask mask,
-            blender::fn::MFParams params,
-            blender::fn::MFContext UNUSED(context)) const override
+  void call(IndexMask mask, fn::MFParams params, fn::MFContext UNUSED(context)) const override
   {
-    const blender::VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
-    const blender::VArray<blender::ColorGeometry4f> &col_in =
-        params.readonly_single_input<blender::ColorGeometry4f>(1, "Color");
-    blender::MutableSpan<blender::ColorGeometry4f> col_out =
-        params.uninitialized_single_output<blender::ColorGeometry4f>(2, "Color");
+    const VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
+    const VArray<ColorGeometry4f> &col_in = params.readonly_single_input<ColorGeometry4f>(1,
+                                                                                          "Color");
+    MutableSpan<ColorGeometry4f> col_out = params.uninitialized_single_output<ColorGeometry4f>(
+        2, "Color");
 
     for (int64_t i : mask) {
       BKE_curvemapping_evaluateRGBF(&cumap_, col_out[i], col_in[i]);
@@ -269,8 +262,7 @@ class CurveRGBFunction : public blender::fn::MultiFunction {
   }
 };
 
-static void sh_node_curve_rgb_build_multi_function(
-    blender::nodes::NodeMultiFunctionBuilder &builder)
+static void sh_node_curve_rgb_build_multi_function(NodeMultiFunctionBuilder &builder)
 {
   bNode &bnode = builder.node();
   CurveMapping *cumap = (CurveMapping *)bnode.storage;
@@ -360,33 +352,31 @@ static int gpu_shader_curve_float(GPUMaterial *mat,
                         GPU_uniform(ext_xyz));
 }
 
-class CurveFloatFunction : public blender::fn::MultiFunction {
+class CurveFloatFunction : public fn::MultiFunction {
  private:
   const CurveMapping &cumap_;
 
  public:
   CurveFloatFunction(const CurveMapping &cumap) : cumap_(cumap)
   {
-    static blender::fn::MFSignature signature = create_signature();
+    static fn::MFSignature signature = create_signature();
     this->set_signature(&signature);
   }
 
-  static blender::fn::MFSignature create_signature()
+  static fn::MFSignature create_signature()
   {
-    blender::fn::MFSignatureBuilder signature{"Curve Float"};
+    fn::MFSignatureBuilder signature{"Curve Float"};
     signature.single_input<float>("Factor");
     signature.single_input<float>("Value");
     signature.single_output<float>("Value");
     return signature.build();
   }
 
-  void call(blender::IndexMask mask,
-            blender::fn::MFParams params,
-            blender::fn::MFContext UNUSED(context)) const override
+  void call(IndexMask mask, fn::MFParams params, fn::MFContext UNUSED(context)) const override
   {
-    const blender::VArray<float> &fac = params.readonly_single_input<float>(0, "Factor");
-    const blender::VArray<float> &val_in = params.readonly_single_input<float>(1, "Value");
-    blender::MutableSpan<float> val_out = params.uninitialized_single_output<float>(2, "Value");
+    const VArray<float> &fac = params.readonly_single_input<float>(0, "Factor");
+    const VArray<float> &val_in = params.readonly_single_input<float>(1, "Value");
+    MutableSpan<float> val_out = params.uninitialized_single_output<float>(2, "Value");
 
     for (int64_t i : mask) {
       val_out[i] = BKE_curvemapping_evaluateF(&cumap_, 0, val_in[i]);
@@ -397,8 +387,7 @@ class CurveFloatFunction : public blender::fn::MultiFunction {
   }
 };
 
-static void sh_node_curve_float_build_multi_function(
-    blender::nodes::NodeMultiFunctionBuilder &builder)
+static void sh_node_curve_float_build_multi_function(NodeMultiFunctionBuilder &builder)
 {
   bNode &bnode = builder.node();
   CurveMapping *cumap = (CurveMapping *)bnode.storage;