Added smoothstep built-in function

(cherry picked from commit 514a3fb96a)

core/math/expression.cpp

@@ -68,6 +68,7 @@ const char *Expression::func_name[Expression::FUNC_MAX] = {
 	"lerp",
 	"inverse_lerp",
 	"range_lerp",
+	"smoothstep",
 	"dectime",
 	"randomize",
 	"randi",
@@ -185,6 +186,7 @@ int Expression::get_func_argument_count(BuiltinFunc p_func) {
 			return 2;
 		case MATH_LERP:
 		case MATH_INVERSE_LERP:
+		case MATH_SMOOTHSTEP:
 		case MATH_DECTIME:
 		case MATH_WRAP:
 		case MATH_WRAPF:
@@ -392,6 +394,12 @@ void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant
 			VALIDATE_ARG_NUM(4);
 			*r_return = Math::range_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2], (double)*p_inputs[3], (double)*p_inputs[4]);
 		} break;
+		case MATH_SMOOTHSTEP: {
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			*r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
+		} break;
 		case MATH_DECTIME: {
 
 			VALIDATE_ARG_NUM(0);

core/math/expression.h

@@ -66,6 +66,7 @@ public:
 		MATH_LERP,
 		MATH_INVERSE_LERP,
 		MATH_RANGE_LERP,
+		MATH_SMOOTHSTEP,
 		MATH_DECTIME,
 		MATH_RANDOMIZE,
 		MATH_RAND,

core/math/math_funcs.h

@@ -208,6 +208,17 @@ public:
 	static _ALWAYS_INLINE_ double range_lerp(double p_value, double p_istart, double p_istop, double p_ostart, double p_ostop) { return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value)); }
 	static _ALWAYS_INLINE_ float range_lerp(float p_value, float p_istart, float p_istop, float p_ostart, float p_ostop) { return Math::lerp(p_ostart, p_ostop, Math::inverse_lerp(p_istart, p_istop, p_value)); }
 
+	static _ALWAYS_INLINE_ double smoothstep(double p_from, double p_to, double p_weight) {
+		if (is_equal_approx(p_from, p_to)) return p_from;
+		double x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0, 1.0);
+		return x * x * (3.0 - 2.0 * x);
+	}
+	static _ALWAYS_INLINE_ float smoothstep(float p_from, float p_to, float p_weight) {
+		if (is_equal_approx(p_from, p_to)) return p_from;
+		float x = CLAMP((p_weight - p_from) / (p_to - p_from), 0.0f, 1.0f);
+		return x * x * (3.0f - 2.0f * x);
+	}
+
 	static _ALWAYS_INLINE_ double linear2db(double p_linear) { return Math::log(p_linear) * 8.6858896380650365530225783783321; }
 	static _ALWAYS_INLINE_ float linear2db(float p_linear) { return Math::log(p_linear) * 8.6858896380650365530225783783321; }
 

doc/classes/@GDScript.xml

@@ -973,6 +973,24 @@
 				[/codeblock]
 			</description>
 		</method>
+		<method name="smoothstep">
+			<return type="float">
+			</return>
+			<argument index="0" name="from" type="float">
+			</argument>
+			<argument index="1" name="to" type="float">
+			</argument>
+			<argument index="2" name="weight" type="float">
+			</argument>
+			<description>
+				Returns a number smoothly interpolated between the [code]from[/code] and [code]to[/code], based on the [code]weight[/code]. Similar to [method lerp], but interpolates faster at the beginning and slower at the end.
+				[codeblock]
+				smooth_step(0, 2, 0.5) # returns 0.15
+				smooth_step(0, 2, 1.0) # returns 0.5
+				smooth_step(0, 2, 2.0) # returns 1.0
+				[/codeblock]
+			</description>
+		</method>
 		<method name="sqrt">
 			<return type="float">
 			</return>

modules/gdscript/gdscript_functions.cpp

@@ -74,6 +74,7 @@ const char *GDScriptFunctions::get_func_name(Function p_func) {
 		"lerp",
 		"inverse_lerp",
 		"range_lerp",
+		"smoothstep",
 		"dectime",
 		"randomize",
 		"randi",
@@ -369,6 +370,13 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 			VALIDATE_ARG_NUM(4);
 			r_ret = Math::range_lerp((double)*p_args[0], (double)*p_args[1], (double)*p_args[2], (double)*p_args[3], (double)*p_args[4]);
 		} break;
+		case MATH_SMOOTHSTEP: {
+			VALIDATE_ARG_COUNT(3);
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			r_ret = Math::smoothstep((double)*p_args[0], (double)*p_args[1], (double)*p_args[2]);
+		} break;
 		case MATH_DECTIME: {
 			VALIDATE_ARG_COUNT(3);
 			VALIDATE_ARG_NUM(0);
@@ -1435,6 +1443,7 @@ bool GDScriptFunctions::is_deterministic(Function p_func) {
 		case MATH_LERP:
 		case MATH_INVERSE_LERP:
 		case MATH_RANGE_LERP:
+		case MATH_SMOOTHSTEP:
 		case MATH_DECTIME:
 		case MATH_DEG2RAD:
 		case MATH_RAD2DEG:
@@ -1618,6 +1627,11 @@ MethodInfo GDScriptFunctions::get_info(Function p_func) {
 			mi.return_val.type = Variant::REAL;
 			return mi;
 		} break;
+		case MATH_SMOOTHSTEP: {
+			MethodInfo mi("smoothstep", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "weight"));
+			mi.return_val.type = Variant::REAL;
+			return mi;
+		} break;
 		case MATH_DECTIME: {
 			MethodInfo mi("dectime", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "amount"), PropertyInfo(Variant::REAL, "step"));
 			mi.return_val.type = Variant::REAL;

modules/gdscript/gdscript_functions.h

@@ -65,6 +65,7 @@ public:
 		MATH_LERP,
 		MATH_INVERSE_LERP,
 		MATH_RANGE_LERP,
+		MATH_SMOOTHSTEP,
 		MATH_DECTIME,
 		MATH_RANDOMIZE,
 		MATH_RAND,

modules/mono/glue/Managed/Files/Mathf.cs

@@ -261,6 +261,16 @@ namespace Godot
             return (real_t)Math.Sinh(s);
         }
 
+        public static real_t SmoothStep(real_t from, real_t to, real_t weight)
+        {
+            if (IsEqualApprox(from, to))
+            {
+                return from;
+            }
+            real_t x = Clamp((weight - from) / (to - from), (real_t)0.0, (real_t)1.0);
+            return x * x * (3 - 2 * x);
+        }
+
         public static real_t Sqrt(real_t s)
         {
             return (real_t)Math.Sqrt(s);

modules/visual_script/doc_classes/VisualScriptBuiltinFunc.xml

@@ -202,7 +202,14 @@
 		<constant name="COLORN" value="62" enum="BuiltinFunc">
 			Return the [Color] with the given name and alpha ranging from 0 to 1. Note: names are defined in color_names.inc.
 		</constant>
-		<constant name="FUNC_MAX" value="63" enum="BuiltinFunc">
+		<constant name="MATH_SMOOTHSTEP" value="63" enum="BuiltinFunc">
+			Return a number smoothly interpolated between the first two inputs, based on the third input. Similar to [code]MATH_LERP[/code], but interpolates faster at the beginning and slower at the end. Using Hermite interpolation formula:
+			[codeblock]
+			var t = clamp((weight - from) / (to - from), 0.0, 1.0)
+			return t * t * (3.0 - 2.0 * t)
+			[/codeblock]
+		</constant>
+		<constant name="FUNC_MAX" value="64" enum="BuiltinFunc">
 			The maximum value the [member function] property can have.
 		</constant>
 	</constants>

modules/visual_script/visual_script_builtin_funcs.cpp

@@ -102,6 +102,7 @@ const char *VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX
 	"var2bytes",
 	"bytes2var",
 	"color_named",
+	"smoothstep",
 };
 
 VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(const String &p_string) {
@@ -204,6 +205,7 @@ int VisualScriptBuiltinFunc::get_func_argument_count(BuiltinFunc p_func) {
 			return 2;
 		case MATH_LERP:
 		case MATH_INVERSE_LERP:
+		case MATH_SMOOTHSTEP:
 		case MATH_DECTIME:
 		case MATH_WRAP:
 		case MATH_WRAPF:
@@ -337,6 +339,14 @@ PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const
 			else
 				return PropertyInfo(Variant::REAL, "ostop");
 		} break;
+		case MATH_SMOOTHSTEP: {
+			if (p_idx == 0)
+				return PropertyInfo(Variant::REAL, "from");
+			else if (p_idx == 1)
+				return PropertyInfo(Variant::REAL, "to");
+			else
+				return PropertyInfo(Variant::REAL, "weight");
+		} break;
 		case MATH_DECTIME: {
 			if (p_idx == 0)
 				return PropertyInfo(Variant::REAL, "value");
@@ -569,6 +579,7 @@ PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) cons
 		case MATH_LERP:
 		case MATH_INVERSE_LERP:
 		case MATH_RANGE_LERP:
+		case MATH_SMOOTHSTEP:
 		case MATH_DECTIME: {
 			t = Variant::REAL;
 
@@ -899,6 +910,12 @@ void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func, const Variant **p_in
 			VALIDATE_ARG_NUM(4);
 			*r_return = Math::range_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2], (double)*p_inputs[3], (double)*p_inputs[4]);
 		} break;
+		case VisualScriptBuiltinFunc::MATH_SMOOTHSTEP: {
+			VALIDATE_ARG_NUM(0);
+			VALIDATE_ARG_NUM(1);
+			VALIDATE_ARG_NUM(2);
+			*r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
+		} break;
 		case VisualScriptBuiltinFunc::MATH_DECTIME: {
 
 			VALIDATE_ARG_NUM(0);
@@ -1379,6 +1396,7 @@ void VisualScriptBuiltinFunc::_bind_methods() {
 	BIND_ENUM_CONSTANT(VAR_TO_BYTES);
 	BIND_ENUM_CONSTANT(BYTES_TO_VAR);
 	BIND_ENUM_CONSTANT(COLORN);
+	BIND_ENUM_CONSTANT(MATH_SMOOTHSTEP);
 	BIND_ENUM_CONSTANT(FUNC_MAX);
 }
 
@@ -1433,6 +1451,7 @@ void register_visual_script_builtin_func_node() {
 	VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP>);
 	VisualScriptLanguage::singleton->add_register_func("functions/built_in/inverse_lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_INVERSE_LERP>);
 	VisualScriptLanguage::singleton->add_register_func("functions/built_in/range_lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANGE_LERP>);
+	VisualScriptLanguage::singleton->add_register_func("functions/built_in/smoothstep", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SMOOTHSTEP>);
 	VisualScriptLanguage::singleton->add_register_func("functions/built_in/dectime", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECTIME>);
 	VisualScriptLanguage::singleton->add_register_func("functions/built_in/randomize", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOMIZE>);
 	VisualScriptLanguage::singleton->add_register_func("functions/built_in/rand", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAND>);

modules/visual_script/visual_script_builtin_funcs.h

@@ -101,6 +101,7 @@ public:
 		VAR_TO_BYTES,
 		BYTES_TO_VAR,
 		COLORN,
+		MATH_SMOOTHSTEP,
 		FUNC_MAX
 	};