[Bf-blender-cvs] [b85bded21b2] geometry-nodes-deduplicate-float-math: cleanup
Jacques Lucke
noreply at git.blender.org
Tue Nov 24 17:17:47 CET 2020
Commit: b85bded21b28e55b9419967fcc5017fbba3048d8
Author: Jacques Lucke
Date: Tue Nov 24 16:19:30 2020 +0100
Branches: geometry-nodes-deduplicate-float-math
https://developer.blender.org/rBb85bded21b28e55b9419967fcc5017fbba3048d8
cleanup
===================================================================
M source/blender/nodes/NOD_math_functions.hh
M source/blender/nodes/shader/nodes/node_shader_math.cc
===================================================================
diff --git a/source/blender/nodes/NOD_math_functions.hh b/source/blender/nodes/NOD_math_functions.hh
index 1997a0bdbe8..3e2db131c29 100644
--- a/source/blender/nodes/NOD_math_functions.hh
+++ b/source/blender/nodes/NOD_math_functions.hh
@@ -45,59 +45,38 @@ inline bool dispatch_float_math_fl_fl_to_fl(const int operation, OpType &&op)
return false;
}
+ auto dispatch = [&](auto function) -> bool {
+ op(function, *info);
+ return true;
+ };
+
switch (operation) {
- case NODE_MATH_ADD: {
- op([](float a, float b) { return a + b; }, *info);
- return true;
- }
- case NODE_MATH_SUBTRACT: {
- op([](float a, float b) { return a - b; }, *info);
- return true;
- }
- case NODE_MATH_MULTIPLY: {
- op([](float a, float b) { return a * b; }, *info);
- return true;
- }
- case NODE_MATH_DIVIDE: {
- op(safe_divide, *info);
- return true;
- }
- case NODE_MATH_POWER: {
- op(safe_powf, *info);
- return true;
- }
- case NODE_MATH_LOGARITHM: {
- op(safe_logf, *info);
- return true;
- }
- case NODE_MATH_MINIMUM: {
- op([](float a, float b) { return std::min(a, b); }, *info);
- return true;
- }
- case NODE_MATH_MAXIMUM: {
- op([](float a, float b) { return std::max(a, b); }, *info);
- return true;
- }
- case NODE_MATH_LESS_THAN: {
- op([](float a, float b) { return (float)(a < b); }, *info);
- return true;
- }
- case NODE_MATH_GREATER_THAN: {
- op([](float a, float b) { return (float)(a > b); }, *info);
- return true;
- }
- case NODE_MATH_MODULO: {
- op(safe_modf, *info);
- return true;
- }
- case NODE_MATH_SNAP: {
- op([](float a, float b) { return floorf(safe_divide(a, b)) * b; }, *info);
- return true;
- }
- case NODE_MATH_ARCTAN2: {
- op([](float a, float b) { return atan2f(a, b); }, *info);
- return true;
- }
+ case NODE_MATH_ADD:
+ return dispatch([](float a, float b) { return a + b; });
+ case NODE_MATH_SUBTRACT:
+ return dispatch([](float a, float b) { return a - b; });
+ case NODE_MATH_MULTIPLY:
+ return dispatch([](float a, float b) { return a * b; });
+ case NODE_MATH_DIVIDE:
+ return dispatch(safe_divide);
+ case NODE_MATH_POWER:
+ return dispatch(safe_powf);
+ case NODE_MATH_LOGARITHM:
+ return dispatch(safe_logf);
+ case NODE_MATH_MINIMUM:
+ return dispatch([](float a, float b) { return std::min(a, b); });
+ case NODE_MATH_MAXIMUM:
+ return dispatch([](float a, float b) { return std::max(a, b); });
+ case NODE_MATH_LESS_THAN:
+ return dispatch([](float a, float b) { return (float)(a < b); });
+ case NODE_MATH_GREATER_THAN:
+ return dispatch([](float a, float b) { return (float)(a > b); });
+ case NODE_MATH_MODULO:
+ return dispatch(safe_modf);
+ case NODE_MATH_SNAP:
+ return dispatch([](float a, float b) { return floorf(safe_divide(a, b)) * b; });
+ case NODE_MATH_ARCTAN2:
+ return dispatch([](float a, float b) { return atan2f(a, b); });
}
return false;
}
@@ -110,91 +89,54 @@ inline bool dispatch_float_math_fl_to_fl(const int operation, OpType &&op)
return false;
}
+ auto dispatch = [&](auto function) -> bool {
+ op(function, *info);
+ return true;
+ };
+
switch (operation) {
- case NODE_MATH_EXPONENT: {
- op(expf, *info);
- return true;
- }
- case NODE_MATH_SQRT: {
- op(safe_sqrtf, *info);
- return true;
- }
- case NODE_MATH_INV_SQRT: {
- op(safe_inverse_sqrtf, *info);
- return true;
- }
- case NODE_MATH_ABSOLUTE: {
- op([](float a) { return fabs(a); }, *info);
- return true;
- }
- case NODE_MATH_RADIANS: {
- op([](float a) { return DEG2RAD(a); }, *info);
- return true;
- }
- case NODE_MATH_DEGREES: {
- op([](float a) { return RAD2DEG(a); }, *info);
- return true;
- }
- case NODE_MATH_SIGN: {
- op(compatible_signf, *info);
- return true;
- }
- case NODE_MATH_ROUND: {
- op([](float a) { return floorf(a + 0.5f); }, *info);
- return true;
- }
- case NODE_MATH_FLOOR: {
- op([](float a) { return floorf(a); }, *info);
- return true;
- }
- case NODE_MATH_CEIL: {
- op([](float a) { return ceilf(a); }, *info);
- return true;
- }
- case NODE_MATH_FRACTION: {
- op([](float a) { return a - floorf(a); }, *info);
- return true;
- }
- case NODE_MATH_TRUNC: {
- op([](float a) { return a >= 0.0f ? floorf(a) : ceilf(a); }, *info);
- return true;
- }
- case NODE_MATH_SINE: {
- op([](float a) { return sinf(a); }, *info);
- return true;
- }
- case NODE_MATH_COSINE: {
- op([](float a) { return cosf(a); }, *info);
- return true;
- }
- case NODE_MATH_TANGENT: {
- op([](float a) { return tanf(a); }, *info);
- return true;
- }
- case NODE_MATH_SINH: {
- op([](float a) { return sinhf(a); }, *info);
- return true;
- }
- case NODE_MATH_COSH: {
- op([](float a) { return coshf(a); }, *info);
- return true;
- }
- case NODE_MATH_TANH: {
- op([](float a) { return tanhf(a); }, *info);
- return true;
- }
- case NODE_MATH_ARCSINE: {
- op([](float a) { return safe_asinf(a); }, *info);
- return true;
- }
- case NODE_MATH_ARCCOSINE: {
- op([](float a) { return safe_acosf(a); }, *info);
- return true;
- }
- case NODE_MATH_ARCTANGENT: {
- op([](float a) { return atanf(a); }, *info);
- return true;
- }
+ case NODE_MATH_EXPONENT:
+ return dispatch(expf);
+ case NODE_MATH_SQRT:
+ return dispatch(safe_sqrtf);
+ case NODE_MATH_INV_SQRT:
+ return dispatch(safe_inverse_sqrtf);
+ case NODE_MATH_ABSOLUTE:
+ return dispatch([](float a) { return fabs(a); });
+ case NODE_MATH_RADIANS:
+ return dispatch([](float a) { return DEG2RAD(a); });
+ case NODE_MATH_DEGREES:
+ return dispatch([](float a) { return RAD2DEG(a); });
+ case NODE_MATH_SIGN:
+ return dispatch(compatible_signf);
+ case NODE_MATH_ROUND:
+ return dispatch([](float a) { return floorf(a + 0.5f); });
+ case NODE_MATH_FLOOR:
+ return dispatch([](float a) { return floorf(a); });
+ case NODE_MATH_CEIL:
+ return dispatch([](float a) { return ceilf(a); });
+ case NODE_MATH_FRACTION:
+ return dispatch([](float a) { return a - floorf(a); });
+ case NODE_MATH_TRUNC:
+ return dispatch([](float a) { return a >= 0.0f ? floorf(a) : ceilf(a); });
+ case NODE_MATH_SINE:
+ return dispatch([](float a) { return sinf(a); });
+ case NODE_MATH_COSINE:
+ return dispatch([](float a) { return cosf(a); });
+ case NODE_MATH_TANGENT:
+ return dispatch([](float a) { return tanf(a); });
+ case NODE_MATH_SINH:
+ return dispatch([](float a) { return sinhf(a); });
+ case NODE_MATH_COSH:
+ return dispatch([](float a) { return coshf(a); });
+ case NODE_MATH_TANH:
+ return dispatch([](float a) { return tanhf(a); });
+ case NODE_MATH_ARCSINE:
+ return dispatch([](float a) { return safe_asinf(a); });
+ case NODE_MATH_ARCCOSINE:
+ return dispatch([](float a) { return safe_acosf(a); });
+ case NODE_MATH_ARCTANGENT:
+ return dispatch([](float a) { return atanf(a); });
}
return false;
}
diff --git a/source/blender/nodes/shader/nodes/node_shader_math.cc b/source/blender/nodes/shader/nodes/node_shader_math.cc
index 7f0eb928bf1..493158a5f28 100644
--- a/source/blender/nodes/shader/nodes/node_shader_math.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_math.cc
@@ -75,6 +75,7 @@ static const blender::fn::MultiFunction &get_base_multi_function(
const int mode = builder.bnode().custom1;
const blender::fn::MultiFunction *base_fn = nullptr;
+
blender::nodes::dispatch_float_math_fl_fl_to_fl(
mode, [&](auto function, const blender::nodes::FloatMathOperationInfo &info) {
static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{info.title_case_name,
@@ -85,93 +86,23 @@ static const blender::fn::MultiFunction &get_base_multi_function(
return *base_fn;
}
+ blender::nodes::dispatch_float_math_fl_to_fl(
+ mode, [&](auto function, const blender::nodes::FloatMathOperationInfo &info) {
+ static blender::fn::CustomMF_SI_SO<float, float> fn{info.title_case_name, function};
+ base_fn = &fn;
+ });
+ if (base_fn != nullptr) {
+ return *base_fn;
+ }
+
+ return builder.get_not_implemented_fn();
+
switch (mode) {
- case NODE_MATH_ADD: {
- static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
- "Add", [](float a, float b) { return a + b; }};
- return fn;
- }
- case NODE_MATH_SUBTRACT: {
- static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
- "Subtract", [](float a, float b) { return a - b; }};
- return fn;
- }
- case NODE_MATH_MULTIPLY: {
- static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{
- "Multiply", [](float a, float b) { return a * b; }};
- return fn;
- }
- case NODE_MATH_DIVIDE: {
- static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{"Divide", safe_divide};
- return fn;
- }
case NODE_MATH_MULTIPLY_ADD: {
static blender::fn::CustomMF_SI_SI_SI_SO<float, float, float, float> fn{
"Multiply Add", [](float a, float b, float c) { return a * b + c; }};
return fn;
}
-
- case NODE_MATH_POWER: {
- static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{"Power", safe_powf};
- return fn;
- }
- case NODE_MATH_LOGARITHM: {
- static blender::fn::CustomMF_SI_SI_SO<float, float, float> fn{"Logarithm", safe_logf};
- return fn;
- }
- case NODE_MATH_EXPONENT: {
- static blender::fn::CustomMF_SI_SO<float, float> fn{"Exponent", expf};
- return fn;
- }
- case NODE_MATH_SQRT: {
- static blender::fn::CustomMF_SI_SO<float, float> fn{"Sqrt", safe_sqrtf};
- return fn;
- }
- case NODE_MATH_INV_SQRT: {
- static blender::fn::CustomMF_SI_SO<float, float> fn{"Inverse
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list