Cleanup: replace C-style casts with functional casts for numeric types

Use function style casts in C++ headers & source.

1 files changed, 12 insertions, 18 deletions

diff --git a/source/blender/blenkernel/BKE_attribute_math.hh b/source/blender/blenkernel/BKE_attribute_math.hh
index abd8b33b260..5c0e5f428a4 100644
--- a/source/blender/blenkernel/BKE_attribute_math.hh
+++ b/source/blender/blenkernel/BKE_attribute_math.hh
@@ -60,12 +60,12 @@ template<> inline bool mix2(const float factor, const bool &a, const bool &b)
 
 template<> inline int8_t mix2(const float factor, const int8_t &a, const int8_t &b)
 {
-  return static_cast<int8_t>(std::round((1.0f - factor) * a + factor * b));
+  return int8_t(std::round((1.0f - factor) * a + factor * b));
 }
 
 template<> inline int mix2(const float factor, const int &a, const int &b)
 {
-  return static_cast<int>(std::round((1.0f - factor) * a + factor * b));
+  return int(std::round((1.0f - factor) * a + factor * b));
 }
 
 template<> inline float mix2(const float factor, const float &a, const float &b)
@@ -108,7 +108,7 @@ template<typename T> T mix3(const float3 &weights, const T &v0, const T &v1, con
 template<>
 inline int8_t mix3(const float3 &weights, const int8_t &v0, const int8_t &v1, const int8_t &v2)
 {
-  return static_cast<int8_t>(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2));
+  return int8_t(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2));
 }
 
 template<> inline bool mix3(const float3 &weights, const bool &v0, const bool &v1, const bool &v2)
@@ -118,7 +118,7 @@ template<> inline bool mix3(const float3 &weights, const bool &v0, const bool &v
 
 template<> inline int mix3(const float3 &weights, const int &v0, const int &v1, const int &v2)
 {
-  return static_cast<int>(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2));
+  return int(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2));
 }
 
 template<>
@@ -160,10 +160,8 @@ inline ColorGeometry4b mix3(const float3 &weights,
   const float4 v1_f{&v1.r};
   const float4 v2_f{&v2.r};
   const float4 mixed = v0_f * weights[0] + v1_f * weights[1] + v2_f * weights[2];
-  return ColorGeometry4b{static_cast<uint8_t>(mixed[0]),
-                         static_cast<uint8_t>(mixed[1]),
-                         static_cast<uint8_t>(mixed[2]),
-                         static_cast<uint8_t>(mixed[3])};
+  return ColorGeometry4b{
+      uint8_t(mixed[0]), uint8_t(mixed[1]), uint8_t(mixed[2]), uint8_t(mixed[3])};
 }
 
 /** \} */
@@ -180,8 +178,7 @@ template<>
 inline int8_t mix4(
     const float4 &weights, const int8_t &v0, const int8_t &v1, const int8_t &v2, const int8_t &v3)
 {
-  return static_cast<int8_t>(
-      std::round(weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3));
+  return int8_t(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3));
 }
 
 template<>
@@ -194,8 +191,7 @@ inline bool mix4(
 template<>
 inline int mix4(const float4 &weights, const int &v0, const int &v1, const int &v2, const int &v3)
 {
-  return static_cast<int>(
-      std::round(weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3));
+  return int(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3));
 }
 
 template<>
@@ -244,10 +240,8 @@ inline ColorGeometry4b mix4(const float4 &weights,
   const float4 v3_f{&v3.r};
   float4 mixed;
   interp_v4_v4v4v4v4(mixed, v0_f, v1_f, v2_f, v3_f, weights);
-  return ColorGeometry4b{static_cast<uint8_t>(mixed[0]),
-                         static_cast<uint8_t>(mixed[1]),
-                         static_cast<uint8_t>(mixed[2]),
-                         static_cast<uint8_t>(mixed[3])};
+  return ColorGeometry4b{
+      uint8_t(mixed[0]), uint8_t(mixed[1]), uint8_t(mixed[2]), uint8_t(mixed[3])};
 }
 
 /** \} */
@@ -523,7 +517,7 @@ template<> struct DefaultMixerStruct<ColorGeometry4b> {
 template<> struct DefaultMixerStruct<int> {
   static int double_to_int(const double &value)
   {
-    return static_cast<int>(std::round(value));
+    return int(std::round(value));
   }
   /* Store interpolated ints in a double temporarily, so that weights are handled correctly. It
    * uses double instead of float so that it is accurate for all 32 bit integers. */
@@ -542,7 +536,7 @@ template<> struct DefaultMixerStruct<bool> {
 template<> struct DefaultMixerStruct<int8_t> {
   static int8_t float_to_int8_t(const float &value)
   {
-    return static_cast<int8_t>(std::round(value));
+    return int8_t(std::round(value));
   }
   /* Store interpolated 8 bit integers in a float temporarily to increase accuracy. */
   using type = SimpleMixerWithAccumulationType<int8_t, float, float_to_int8_t>;