Merge pull request #63394 from Calinou/curve-gradient-rename-interpolate

Rename Curve/Curve2D/Curve3D/Gradient `interpolate()` to `sample()`

doc/classes/Curve.xml

@@ -74,27 +74,27 @@
 				Returns the right tangent angle (in degrees) for the point at [param index].
 			</description>
 		</method>
-		<method name="interpolate" qualifiers="const">
+		<method name="remove_point">
+			<return type="void" />
+			<param index="0" name="index" type="int" />
+			<description>
+				Removes the point at [code]index[/code] from the curve.
+			</description>
+		</method>
+		<method name="sample" qualifiers="const">
 			<return type="float" />
 			<param index="0" name="offset" type="float" />
 			<description>
 				Returns the Y value for the point that would exist at the X position [param offset] along the curve.
 			</description>
 		</method>
-		<method name="interpolate_baked" qualifiers="const">
+		<method name="sample_baked" qualifiers="const">
 			<return type="float" />
 			<param index="0" name="offset" type="float" />
 			<description>
 				Returns the Y value for the point that would exist at the X position [param offset] along the curve using the baked cache. Bakes the curve's points if not already baked.
 			</description>
 		</method>
-		<method name="remove_point">
-			<return type="void" />
-			<param index="0" name="index" type="int" />
-			<description>
-				Removes the point at [param index] from the curve.
-			</description>
-		</method>
 		<method name="set_point_left_mode">
 			<return type="void" />
 			<param index="0" name="index" type="int" />

doc/classes/Curve2D.xml

@@ -43,7 +43,7 @@
 			<return type="float" />
 			<param index="0" name="to_point" type="Vector2" />
 			<description>
-				Returns the closest offset to [param to_point]. This offset is meant to be used in [method interpolate_baked].
+				Returns the closest offset to [param to_point]. This offset is meant to be used in [method sample_baked].
 				[param to_point] must be in this curve's local space.
 			</description>
 		</method>
@@ -76,7 +76,14 @@
 				Returns the position of the vertex [param idx]. If the index is out of bounds, the function sends an error to the console, and returns [code](0, 0)[/code].
 			</description>
 		</method>
-		<method name="interpolate" qualifiers="const">
+		<method name="remove_point">
+			<return type="void" />
+			<param index="0" name="idx" type="int" />
+			<description>
+				Deletes the point [code]idx[/code] from the curve. Sends an error to the console if [code]idx[/code] is out of bounds.
+			</description>
+		</method>
+		<method name="sample" qualifiers="const">
 			<return type="Vector2" />
 			<param index="0" name="idx" type="int" />
 			<param index="1" name="t" type="float" />
@@ -85,7 +92,7 @@
 				If [param idx] is out of bounds it is truncated to the first or last vertex, and [param t] is ignored. If the curve has no points, the function sends an error to the console, and returns [code](0, 0)[/code].
 			</description>
 		</method>
-		<method name="interpolate_baked" qualifiers="const">
+		<method name="sample_baked" qualifiers="const">
 			<return type="Vector2" />
 			<param index="0" name="offset" type="float" />
 			<param index="1" name="cubic" type="bool" default="false" />
@@ -95,18 +102,11 @@
 				Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough).
 			</description>
 		</method>
-		<method name="interpolatef" qualifiers="const">
+		<method name="samplef" qualifiers="const">
 			<return type="Vector2" />
 			<param index="0" name="fofs" type="float" />
 			<description>
-				Returns the position at the vertex [param fofs]. It calls [method interpolate] using the integer part of [param fofs] as [code]idx[/code], and its fractional part as [code]t[/code].
-			</description>
-		</method>
-		<method name="remove_point">
-			<return type="void" />
-			<param index="0" name="idx" type="int" />
-			<description>
-				Deletes the point [param idx] from the curve. Sends an error to the console if [param idx] is out of bounds.
+				Returns the position at the vertex [param fofs]. It calls [method sample] using the integer part of [param fofs] as [code]idx[/code], and its fractional part as [code]t[/code].
 			</description>
 		</method>
 		<method name="set_point_in">

doc/classes/Curve3D.xml

@@ -56,7 +56,7 @@
 			<return type="float" />
 			<param index="0" name="to_point" type="Vector3" />
 			<description>
-				Returns the closest offset to [param to_point]. This offset is meant to be used in [method interpolate_baked] or [method interpolate_baked_up_vector].
+				Returns the closest offset to [param to_point]. This offset is meant to be used in [method sample_baked] or [method sample_baked_up_vector].
 				[param to_point] must be in this curve's local space.
 			</description>
 		</method>
@@ -96,7 +96,14 @@
 				Returns the tilt angle in radians for the point [param idx]. If the index is out of bounds, the function sends an error to the console, and returns [code]0[/code].
 			</description>
 		</method>
-		<method name="interpolate" qualifiers="const">
+		<method name="remove_point">
+			<return type="void" />
+			<param index="0" name="idx" type="int" />
+			<description>
+				Deletes the point [code]idx[/code] from the curve. Sends an error to the console if [code]idx[/code] is out of bounds.
+			</description>
+		</method>
+		<method name="sample" qualifiers="const">
 			<return type="Vector3" />
 			<param index="0" name="idx" type="int" />
 			<param index="1" name="t" type="float" />
@@ -105,7 +112,7 @@
 				If [param idx] is out of bounds it is truncated to the first or last vertex, and [param t] is ignored. If the curve has no points, the function sends an error to the console, and returns [code](0, 0, 0)[/code].
 			</description>
 		</method>
-		<method name="interpolate_baked" qualifiers="const">
+		<method name="sample_baked" qualifiers="const">
 			<return type="Vector3" />
 			<param index="0" name="offset" type="float" />
 			<param index="1" name="cubic" type="bool" default="false" />
@@ -115,7 +122,7 @@
 				Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough).
 			</description>
 		</method>
-		<method name="interpolate_baked_up_vector" qualifiers="const">
+		<method name="sample_baked_up_vector" qualifiers="const">
 			<return type="Vector3" />
 			<param index="0" name="offset" type="float" />
 			<param index="1" name="apply_tilt" type="bool" default="false" />
@@ -125,18 +132,11 @@
 				If the curve has no up vectors, the function sends an error to the console, and returns [code](0, 1, 0)[/code].
 			</description>
 		</method>
-		<method name="interpolatef" qualifiers="const">
+		<method name="samplef" qualifiers="const">
 			<return type="Vector3" />
 			<param index="0" name="fofs" type="float" />
 			<description>
-				Returns the position at the vertex [param fofs]. It calls [method interpolate] using the integer part of [param fofs] as [code]idx[/code], and its fractional part as [code]t[/code].
-			</description>
-		</method>
-		<method name="remove_point">
-			<return type="void" />
-			<param index="0" name="idx" type="int" />
-			<description>
-				Deletes the point [param idx] from the curve. Sends an error to the console if [param idx] is out of bounds.
+				Returns the position at the vertex [param fofs]. It calls [method sample] using the integer part of [param fofs] as [code]idx[/code], and its fractional part as [code]t[/code].
 			</description>
 		</method>
 		<method name="set_point_in">

doc/classes/Gradient.xml

@@ -38,13 +38,6 @@
 				Returns the number of colors in the gradient.
 			</description>
 		</method>
-		<method name="interpolate">
-			<return type="Color" />
-			<param index="0" name="offset" type="float" />
-			<description>
-				Returns the interpolated color specified by [param offset].
-			</description>
-		</method>
 		<method name="remove_point">
 			<return type="void" />
 			<param index="0" name="point" type="int" />
@@ -58,6 +51,13 @@
 				Reverses/mirrors the gradient.
 			</description>
 		</method>
+		<method name="sample">
+			<return type="Color" />
+			<param index="0" name="offset" type="float" />
+			<description>
+				Returns the interpolated color specified by [code]offset[/code].
+			</description>
+		</method>
 		<method name="set_color">
 			<return type="void" />
 			<param index="0" name="point" type="int" />

editor/plugins/curve_editor_plugin.cpp

@@ -579,7 +579,7 @@ template <typename T>
 static void plot_curve_accurate(const Curve &curve, float step, T plot_func) {
 	if (curve.get_point_count() <= 1) {
 		// Not enough points to make a curve, so it's just a straight line
-		float y = curve.interpolate(0);
+		float y = curve.sample(0);
 		plot_func(Vector2(0, y), Vector2(1.f, y), true);
 
 	} else {
@@ -603,7 +603,7 @@ static void plot_curve_accurate(const Curve &curve, float step, T plot_func) {
 
 			for (float x = step; x < len; x += step) {
 				pos.x = a.x + x;
-				pos.y = curve.interpolate_local_nocheck(i - 1, x);
+				pos.y = curve.sample_local_nocheck(i - 1, x);
 				plot_func(prev_pos, pos, true);
 				prev_pos = pos;
 			}
@@ -817,7 +817,7 @@ Ref<Texture2D> CurvePreviewGenerator::generate(const Ref<Resource> &p_from, cons
 	int prev_y = 0;
 	for (int x = 0; x < im.get_width(); ++x) {
 		float t = static_cast<float>(x) / im.get_width();
-		float v = (curve.interpolate_baked(t) - curve.get_min_value()) / range_y;
+		float v = (curve.sample_baked(t) - curve.get_min_value()) / range_y;
 		int y = CLAMP(im.get_height() - v * im.get_height(), 0, im.get_height());
 
 		// Plot point

editor/project_converter_3_to_4.cpp

@@ -397,6 +397,7 @@ static const char *gdscript_function_renames[][2] = {
 	{ "http_unescape", "uri_decode" }, // String
 	{ "import_scene_from_other_importer", "_import_scene" }, //EditorSceneFormatImporter
 	{ "instance_set_surface_material", "instance_set_surface_override_material" }, // RenderingServer
+	{ "interpolate", "sample" }, // Curve, Curve2D, Curve3D, Gradient
 	{ "intersect_polygons_2d", "intersect_polygons" }, // Geometry2D
 	{ "intersect_polyline_with_polygon_2d", "intersect_polyline_with_polygon" }, // Geometry2D
 	{ "is_a_parent_of", "is_ancestor_of" }, // Node

modules/csg/csg_shape.cpp

@@ -1852,13 +1852,13 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				base_xform = path->get_global_transform();
 			}
 
-			Vector3 current_point = curve->interpolate_baked(0);
-			Vector3 next_point = curve->interpolate_baked(extrusion_step);
+			Vector3 current_point = curve->sample_baked(0);
+			Vector3 next_point = curve->sample_baked(extrusion_step);
 			Vector3 current_up = Vector3(0, 1, 0);
 			Vector3 direction = next_point - current_point;
 
 			if (path_joined) {
-				Vector3 last_point = curve->interpolate_baked(curve->get_baked_length());
+				Vector3 last_point = curve->sample_baked(curve->get_baked_length());
 				direction = next_point - last_point;
 			}
 
@@ -1869,7 +1869,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				case PATH_ROTATION_PATH:
 					break;
 				case PATH_ROTATION_PATH_FOLLOW:
-					current_up = curve->interpolate_baked_up_vector(0);
+					current_up = curve->sample_baked_up_vector(0);
 					break;
 			}
 
@@ -1931,9 +1931,9 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 						}
 					}
 
-					Vector3 previous_point = curve->interpolate_baked(previous_offset);
-					Vector3 current_point = curve->interpolate_baked(current_offset);
-					Vector3 next_point = curve->interpolate_baked(next_offset);
+					Vector3 previous_point = curve->sample_baked(previous_offset);
+					Vector3 current_point = curve->sample_baked(current_offset);
+					Vector3 next_point = curve->sample_baked(next_offset);
 					Vector3 current_up = Vector3(0, 1, 0);
 					Vector3 direction = next_point - previous_point;
 					Vector3 current_dir = (current_point - previous_point).normalized();
@@ -1956,7 +1956,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 						case PATH_ROTATION_PATH:
 							break;
 						case PATH_ROTATION_PATH_FOLLOW:
-							current_up = curve->interpolate_baked_up_vector(current_offset);
+							current_up = curve->sample_baked_up_vector(current_offset);
 							break;
 					}
 

scene/2d/cpu_particles_2d.cpp

@@ -719,17 +719,17 @@ void CPUParticles2D::_particles_process(double p_delta) {
 
 			/*real_t tex_linear_velocity = 0;
 			if (curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid()) {
-				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->interpolate(0);
+				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->sample(0);
 			}*/
 
 			real_t tex_angle = 0.0;
 			if (curve_parameters[PARAM_ANGLE].is_valid()) {
-				tex_angle = curve_parameters[PARAM_ANGLE]->interpolate(tv);
+				tex_angle = curve_parameters[PARAM_ANGLE]->sample(tv);
 			}
 
 			real_t tex_anim_offset = 0.0;
 			if (curve_parameters[PARAM_ANGLE].is_valid()) {
-				tex_anim_offset = curve_parameters[PARAM_ANGLE]->interpolate(tv);
+				tex_anim_offset = curve_parameters[PARAM_ANGLE]->sample(tv);
 			}
 
 			p.seed = Math::rand();
@@ -825,51 +825,51 @@ void CPUParticles2D::_particles_process(double p_delta) {
 
 			real_t tex_linear_velocity = 1.0;
 			if (curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid()) {
-				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->interpolate(tv);
+				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->sample(tv);
 			}
 
 			real_t tex_orbit_velocity = 1.0;
 			if (curve_parameters[PARAM_ORBIT_VELOCITY].is_valid()) {
-				tex_orbit_velocity = curve_parameters[PARAM_ORBIT_VELOCITY]->interpolate(tv);
+				tex_orbit_velocity = curve_parameters[PARAM_ORBIT_VELOCITY]->sample(tv);
 			}
 
 			real_t tex_angular_velocity = 1.0;
 			if (curve_parameters[PARAM_ANGULAR_VELOCITY].is_valid()) {
-				tex_angular_velocity = curve_parameters[PARAM_ANGULAR_VELOCITY]->interpolate(tv);
+				tex_angular_velocity = curve_parameters[PARAM_ANGULAR_VELOCITY]->sample(tv);
 			}
 
 			real_t tex_linear_accel = 1.0;
 			if (curve_parameters[PARAM_LINEAR_ACCEL].is_valid()) {
-				tex_linear_accel = curve_parameters[PARAM_LINEAR_ACCEL]->interpolate(tv);
+				tex_linear_accel = curve_parameters[PARAM_LINEAR_ACCEL]->sample(tv);
 			}
 
 			real_t tex_tangential_accel = 1.0;
 			if (curve_parameters[PARAM_TANGENTIAL_ACCEL].is_valid()) {
-				tex_tangential_accel = curve_parameters[PARAM_TANGENTIAL_ACCEL]->interpolate(tv);
+				tex_tangential_accel = curve_parameters[PARAM_TANGENTIAL_ACCEL]->sample(tv);
 			}
 
 			real_t tex_radial_accel = 1.0;
 			if (curve_parameters[PARAM_RADIAL_ACCEL].is_valid()) {
-				tex_radial_accel = curve_parameters[PARAM_RADIAL_ACCEL]->interpolate(tv);
+				tex_radial_accel = curve_parameters[PARAM_RADIAL_ACCEL]->sample(tv);
 			}
 
 			real_t tex_damping = 1.0;
 			if (curve_parameters[PARAM_DAMPING].is_valid()) {
-				tex_damping = curve_parameters[PARAM_DAMPING]->interpolate(tv);
+				tex_damping = curve_parameters[PARAM_DAMPING]->sample(tv);
 			}
 
 			real_t tex_angle = 1.0;
 			if (curve_parameters[PARAM_ANGLE].is_valid()) {
-				tex_angle = curve_parameters[PARAM_ANGLE]->interpolate(tv);
+				tex_angle = curve_parameters[PARAM_ANGLE]->sample(tv);
 			}
 			real_t tex_anim_speed = 1.0;
 			if (curve_parameters[PARAM_ANIM_SPEED].is_valid()) {
-				tex_anim_speed = curve_parameters[PARAM_ANIM_SPEED]->interpolate(tv);
+				tex_anim_speed = curve_parameters[PARAM_ANIM_SPEED]->sample(tv);
 			}
 
 			real_t tex_anim_offset = 1.0;
 			if (curve_parameters[PARAM_ANIM_OFFSET].is_valid()) {
-				tex_anim_offset = curve_parameters[PARAM_ANIM_OFFSET]->interpolate(tv);
+				tex_anim_offset = curve_parameters[PARAM_ANIM_OFFSET]->sample(tv);
 			}
 
 			Vector2 force = gravity;
@@ -921,18 +921,18 @@ void CPUParticles2D::_particles_process(double p_delta) {
 		Vector2 tex_scale = Vector2(1.0, 1.0);
 		if (split_scale) {
 			if (scale_curve_x.is_valid()) {
-				tex_scale.x = scale_curve_x->interpolate(tv);
+				tex_scale.x = scale_curve_x->sample(tv);
 			} else {
 				tex_scale.x = 1.0;
 			}
 			if (scale_curve_y.is_valid()) {
-				tex_scale.y = scale_curve_y->interpolate(tv);
+				tex_scale.y = scale_curve_y->sample(tv);
 			} else {
 				tex_scale.y = 1.0;
 			}
 		} else {
 			if (curve_parameters[PARAM_SCALE].is_valid()) {
-				real_t tmp_scale = curve_parameters[PARAM_SCALE]->interpolate(tv);
+				real_t tmp_scale = curve_parameters[PARAM_SCALE]->sample(tv);
 				tex_scale.x = tmp_scale;
 				tex_scale.y = tmp_scale;
 			}
@@ -940,7 +940,7 @@ void CPUParticles2D::_particles_process(double p_delta) {
 
 		real_t tex_hue_variation = 0.0;
 		if (curve_parameters[PARAM_HUE_VARIATION].is_valid()) {
-			tex_hue_variation = curve_parameters[PARAM_HUE_VARIATION]->interpolate(tv);
+			tex_hue_variation = curve_parameters[PARAM_HUE_VARIATION]->sample(tv);
 		}
 
 		real_t hue_rot_angle = (tex_hue_variation)*Math_TAU * Math::lerp(parameters_min[PARAM_HUE_VARIATION], parameters_max[PARAM_HUE_VARIATION], p.hue_rot_rand);

scene/2d/line_builder.cpp

@@ -137,14 +137,14 @@ void LineBuilder::build() {
 		// The line's outer length will be a little higher due to begin and end caps
 		if (begin_cap_mode == Line2D::LINE_CAP_BOX || begin_cap_mode == Line2D::LINE_CAP_ROUND) {
 			if (retrieve_curve) {
-				total_distance += width * curve->interpolate_baked(0.f) * 0.5f;
+				total_distance += width * curve->sample_baked(0.f) * 0.5f;
 			} else {
 				total_distance += width * 0.5f;
 			}
 		}
 		if (end_cap_mode == Line2D::LINE_CAP_BOX || end_cap_mode == Line2D::LINE_CAP_ROUND) {
 			if (retrieve_curve) {
-				total_distance += width * curve->interpolate_baked(1.f) * 0.5f;
+				total_distance += width * curve->sample_baked(1.f) * 0.5f;
 			} else {
 				total_distance += width * 0.5f;
 			}
@@ -160,7 +160,7 @@ void LineBuilder::build() {
 	float uvx1 = 0.f;
 
 	if (retrieve_curve) {
-		width_factor = curve->interpolate_baked(0.f);
+		width_factor = curve->sample_baked(0.f);
 	}
 
 	pos_up0 += u0 * hw * width_factor;
@@ -219,7 +219,7 @@ void LineBuilder::build() {
 			color1 = gradient->get_color_at_offset(current_distance1 / total_distance);
 		}
 		if (retrieve_curve) {
-			width_factor = curve->interpolate_baked(current_distance1 / total_distance);
+			width_factor = curve->sample_baked(current_distance1 / total_distance);
 		}
 
 		Vector2 inner_normal0, inner_normal1;
@@ -383,7 +383,7 @@ void LineBuilder::build() {
 		color1 = gradient->get_color(gradient->get_points_count() - 1);
 	}
 	if (retrieve_curve) {
-		width_factor = curve->interpolate_baked(1.f);
+		width_factor = curve->sample_baked(1.f);
 	}
 
 	Vector2 pos_up1 = pos1 + u0 * hw * width_factor;

scene/2d/path_2d.cpp

@@ -47,7 +47,7 @@ Rect2 Path2D::_edit_get_rect() const {
 	for (int i = 0; i < curve->get_point_count(); i++) {
 		for (int j = 0; j <= 8; j++) {
 			real_t frac = j / 8.0;
-			Vector2 p = curve->interpolate(i, frac);
+			Vector2 p = curve->sample(i, frac);
 			aabb.expand_to(p);
 		}
 	}
@@ -70,7 +70,7 @@ bool Path2D::_edit_is_selected_on_click(const Point2 &p_point, double p_toleranc
 
 		for (int j = 1; j <= 8; j++) {
 			real_t frac = j / 8.0;
-			s[1] = curve->interpolate(i, frac);
+			s[1] = curve->sample(i, frac);
 
 			Vector2 p = Geometry2D::get_closest_point_to_segment(p_point, s);
 			if (p.distance_to(p_point) <= p_tolerance) {
@@ -112,7 +112,7 @@ void Path2D::_notification(int p_what) {
 			for (int i = 0; i < curve->get_point_count(); i++) {
 				for (int j = 0; j < 8; j++) {
 					real_t frac = j * (1.0 / 8.0);
-					Vector2 p = curve->interpolate(i, frac);
+					Vector2 p = curve->sample(i, frac);
 					_cached_draw_pts.set(count++, p);
 				}
 			}
@@ -175,7 +175,7 @@ void PathFollow2D::_update_transform() {
 	if (path_length == 0) {
 		return;
 	}
-	Vector2 pos = c->interpolate_baked(progress, cubic);
+	Vector2 pos = c->sample_baked(progress, cubic);
 
 	if (rotates) {
 		real_t ahead = progress + lookahead;
@@ -195,14 +195,14 @@ void PathFollow2D::_update_transform() {
 			}
 		}
 
-		Vector2 ahead_pos = c->interpolate_baked(ahead, cubic);
+		Vector2 ahead_pos = c->sample_baked(ahead, cubic);
 
 		Vector2 tangent_to_curve;
 		if (ahead_pos == pos) {
 			// This will happen at the end of non-looping or non-closed paths.
 			// We'll try a look behind instead, in order to get a meaningful angle.
 			tangent_to_curve =
-					(pos - c->interpolate_baked(progress - lookahead, cubic)).normalized();
+					(pos - c->sample_baked(progress - lookahead, cubic)).normalized();
 		} else {
 			tangent_to_curve = (ahead_pos - pos).normalized();
 		}

scene/3d/cpu_particles_3d.cpp

@@ -739,17 +739,17 @@ void CPUParticles3D::_particles_process(double p_delta) {
 
 			/*real_t tex_linear_velocity = 0;
 			if (curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid()) {
-				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->interpolate(0);
+				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->sample(0);
 			}*/
 
 			real_t tex_angle = 0.0;
 			if (curve_parameters[PARAM_ANGLE].is_valid()) {
-				tex_angle = curve_parameters[PARAM_ANGLE]->interpolate(tv);
+				tex_angle = curve_parameters[PARAM_ANGLE]->sample(tv);
 			}
 
 			real_t tex_anim_offset = 0.0;
 			if (curve_parameters[PARAM_ANGLE].is_valid()) {
-				tex_anim_offset = curve_parameters[PARAM_ANGLE]->interpolate(tv);
+				tex_anim_offset = curve_parameters[PARAM_ANGLE]->sample(tv);
 			}
 
 			p.seed = Math::rand();
@@ -907,53 +907,53 @@ void CPUParticles3D::_particles_process(double p_delta) {
 
 			real_t tex_linear_velocity = 1.0;
 			if (curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid()) {
-				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->interpolate(tv);
+				tex_linear_velocity = curve_parameters[PARAM_INITIAL_LINEAR_VELOCITY]->sample(tv);
 			}
 
 			real_t tex_orbit_velocity = 1.0;
 			if (particle_flags[PARTICLE_FLAG_DISABLE_Z]) {
 				if (curve_parameters[PARAM_ORBIT_VELOCITY].is_valid()) {
-					tex_orbit_velocity = curve_parameters[PARAM_ORBIT_VELOCITY]->interpolate(tv);
+					tex_orbit_velocity = curve_parameters[PARAM_ORBIT_VELOCITY]->sample(tv);
 				}
 			}
 
 			real_t tex_angular_velocity = 1.0;
 			if (curve_parameters[PARAM_ANGULAR_VELOCITY].is_valid()) {
-				tex_angular_velocity = curve_parameters[PARAM_ANGULAR_VELOCITY]->interpolate(tv);
+				tex_angular_velocity = curve_parameters[PARAM_ANGULAR_VELOCITY]->sample(tv);
 			}
 
 			real_t tex_linear_accel = 1.0;
 			if (curve_parameters[PARAM_LINEAR_ACCEL].is_valid()) {
-				tex_linear_accel = curve_parameters[PARAM_LINEAR_ACCEL]->interpolate(tv);
+				tex_linear_accel = curve_parameters[PARAM_LINEAR_ACCEL]->sample(tv);
 			}
 
 			real_t tex_tangential_accel = 1.0;
 			if (curve_parameters[PARAM_TANGENTIAL_ACCEL].is_valid()) {
-				tex_tangential_accel = curve_parameters[PARAM_TANGENTIAL_ACCEL]->interpolate(tv);
+				tex_tangential_accel = curve_parameters[PARAM_TANGENTIAL_ACCEL]->sample(tv);
 			}
 
 			real_t tex_radial_accel = 1.0;
 			if (curve_parameters[PARAM_RADIAL_ACCEL].is_valid()) {
-				tex_radial_accel = curve_parameters[PARAM_RADIAL_ACCEL]->interpolate(tv);
+				tex_radial_accel = curve_parameters[PARAM_RADIAL_ACCEL]->sample(tv);
 			}
 
 			real_t tex_damping = 1.0;
 			if (curve_parameters[PARAM_DAMPING].is_valid()) {
-				tex_damping = curve_parameters[PARAM_DAMPING]->interpolate(tv);
+				tex_damping = curve_parameters[PARAM_DAMPING]->sample(tv);
 			}
 
 			real_t tex_angle = 1.0;
 			if (curve_parameters[PARAM_ANGLE].is_valid()) {
-				tex_angle = curve_parameters[PARAM_ANGLE]->interpolate(tv);
+				tex_angle = curve_parameters[PARAM_ANGLE]->sample(tv);
 			}
 			real_t tex_anim_speed = 1.0;
 			if (curve_parameters[PARAM_ANIM_SPEED].is_valid()) {
-				tex_anim_speed = curve_parameters[PARAM_ANIM_SPEED]->interpolate(tv);
+				tex_anim_speed = curve_parameters[PARAM_ANIM_SPEED]->sample(tv);
 			}
 
 			real_t tex_anim_offset = 1.0;
 			if (curve_parameters[PARAM_ANIM_OFFSET].is_valid()) {
-				tex_anim_offset = curve_parameters[PARAM_ANIM_OFFSET]->interpolate(tv);
+				tex_anim_offset = curve_parameters[PARAM_ANIM_OFFSET]->sample(tv);
 			}
 
 			Vector3 force = gravity;
@@ -1016,23 +1016,23 @@ void CPUParticles3D::_particles_process(double p_delta) {
 		Vector3 tex_scale = Vector3(1.0, 1.0, 1.0);
 		if (split_scale) {
 			if (scale_curve_x.is_valid()) {
-				tex_scale.x = scale_curve_x->interpolate(tv);
+				tex_scale.x = scale_curve_x->sample(tv);
 			} else {
 				tex_scale.x = 1.0;
 			}
 			if (scale_curve_y.is_valid()) {
-				tex_scale.y = scale_curve_y->interpolate(tv);
+				tex_scale.y = scale_curve_y->sample(tv);
 			} else {
 				tex_scale.y = 1.0;
 			}
 			if (scale_curve_z.is_valid()) {
-				tex_scale.z = scale_curve_z->interpolate(tv);
+				tex_scale.z = scale_curve_z->sample(tv);
 			} else {
 				tex_scale.z = 1.0;
 			}
 		} else {
 			if (curve_parameters[PARAM_SCALE].is_valid()) {
-				float tmp_scale = curve_parameters[PARAM_SCALE]->interpolate(tv);
+				float tmp_scale = curve_parameters[PARAM_SCALE]->sample(tv);
 				tex_scale.x = tmp_scale;
 				tex_scale.y = tmp_scale;
 				tex_scale.z = tmp_scale;
@@ -1041,7 +1041,7 @@ void CPUParticles3D::_particles_process(double p_delta) {
 
 		real_t tex_hue_variation = 0.0;
 		if (curve_parameters[PARAM_HUE_VARIATION].is_valid()) {
-			tex_hue_variation = curve_parameters[PARAM_HUE_VARIATION]->interpolate(tv);
+			tex_hue_variation = curve_parameters[PARAM_HUE_VARIATION]->sample(tv);
 		}
 
 		real_t hue_rot_angle = (tex_hue_variation)*Math_TAU * Math::lerp(parameters_min[PARAM_HUE_VARIATION], parameters_max[PARAM_HUE_VARIATION], p.hue_rot_rand);

scene/3d/path_3d.cpp

@@ -198,17 +198,17 @@ void PathFollow3D::_update_transform(bool p_update_xyz_rot) {
 		}
 	}
 
-	Vector3 pos = c->interpolate_baked(progress, cubic);
+	Vector3 pos = c->sample_baked(progress, cubic);
 	Transform3D t = get_transform();
 	// Vector3 pos_offset = Vector3(h_offset, v_offset, 0); not used in all cases
 	// will be replaced by "Vector3(h_offset, v_offset, 0)" where it was formerly used
 
 	if (rotation_mode == ROTATION_ORIENTED) {
-		Vector3 forward = c->interpolate_baked(o_next, cubic) - pos;
+		Vector3 forward = c->sample_baked(o_next, cubic) - pos;
 
 		// Try with the previous position
 		if (forward.length_squared() < CMP_EPSILON2) {
-			forward = pos - c->interpolate_baked(o_prev, cubic);
+			forward = pos - c->sample_baked(o_prev, cubic);
 		}
 
 		if (forward.length_squared() < CMP_EPSILON2) {
@@ -217,10 +217,10 @@ void PathFollow3D::_update_transform(bool p_update_xyz_rot) {
 			forward.normalize();
 		}
 
-		Vector3 up = c->interpolate_baked_up_vector(progress, true);
+		Vector3 up = c->sample_baked_up_vector(progress, true);
 
 		if (o_next < progress) {
-			Vector3 up1 = c->interpolate_baked_up_vector(o_next, true);
+			Vector3 up1 = c->sample_baked_up_vector(o_next, true);
 			Vector3 axis = up.cross(up1);
 
 			if (axis.length_squared() < CMP_EPSILON2) {
@@ -249,10 +249,10 @@ void PathFollow3D::_update_transform(bool p_update_xyz_rot) {
 		t.origin = pos;
 		if (p_update_xyz_rot && prev_offset != progress) { // Only update rotation if some parameter has changed - i.e. not on addition to scene tree.
 			real_t sample_distance = bi * 0.01;
-			Vector3 t_prev_pos_a = c->interpolate_baked(prev_offset - sample_distance, cubic);
-			Vector3 t_prev_pos_b = c->interpolate_baked(prev_offset + sample_distance, cubic);
-			Vector3 t_cur_pos_a = c->interpolate_baked(progress - sample_distance, cubic);
-			Vector3 t_cur_pos_b = c->interpolate_baked(progress + sample_distance, cubic);
+			Vector3 t_prev_pos_a = c->sample_baked(prev_offset - sample_distance, cubic);
+			Vector3 t_prev_pos_b = c->sample_baked(prev_offset + sample_distance, cubic);
+			Vector3 t_cur_pos_a = c->sample_baked(progress - sample_distance, cubic);
+			Vector3 t_cur_pos_b = c->sample_baked(progress + sample_distance, cubic);
 			Vector3 t_prev = (t_prev_pos_a - t_prev_pos_b).normalized();
 			Vector3 t_cur = (t_cur_pos_a - t_cur_pos_b).normalized();
 
@@ -277,7 +277,7 @@ void PathFollow3D::_update_transform(bool p_update_xyz_rot) {
 			}
 
 			// do the additional tilting
-			real_t tilt_angle = c->interpolate_baked_tilt(progress);
+			real_t tilt_angle = c->sample_baked_tilt(progress);
 			Vector3 tilt_axis = t_cur; // not sure what tilt is supposed to do, is this correct??
 
 			if (likely(!Math::is_zero_approx(Math::abs(tilt_angle)))) {

scene/animation/animation_blend_tree.cpp

@@ -750,7 +750,7 @@ double AnimationNodeTransition::process(double p_time, bool p_seek, bool p_seek_
 
 		float blend = xfade_time == 0 ? 0 : (prev_xfading / xfade_time);
 		if (xfade_curve.is_valid()) {
-			blend = xfade_curve->interpolate(blend);
+			blend = xfade_curve->sample(blend);
 		}
 
 		if (from_start && !p_seek && switched) { //just switched, seek to start of current

scene/animation/animation_node_state_machine.cpp

@@ -433,7 +433,7 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 	}
 
 	if (current_curve.is_valid()) {
-		fade_blend = current_curve->interpolate(fade_blend);
+		fade_blend = current_curve->sample(fade_blend);
 	}
 	float rem = p_state_machine->blend_node(current, p_state_machine->states[current].node, p_time, p_seek, p_seek_root, fade_blend, AnimationNode::FILTER_IGNORE, true);
 

scene/resources/curve.cpp

@@ -313,7 +313,7 @@ void Curve::set_max_value(real_t p_max) {
 	emit_signal(SNAME(SIGNAL_RANGE_CHANGED));
 }
 
-real_t Curve::interpolate(real_t p_offset) const {
+real_t Curve::sample(real_t p_offset) const {
 	if (_points.size() == 0) {
 		return 0;
 	}
@@ -333,10 +333,10 @@ real_t Curve::interpolate(real_t p_offset) const {
 		return _points[0].position.y;
 	}
 
-	return interpolate_local_nocheck(i, local);
+	return sample_local_nocheck(i, local);
 }
 
-real_t Curve::interpolate_local_nocheck(int p_index, real_t p_local_offset) const {
+real_t Curve::sample_local_nocheck(int p_index, real_t p_local_offset) const {
 	const Point a = _points[p_index];
 	const Point b = _points[p_index + 1];
 
@@ -440,7 +440,7 @@ void Curve::bake() {
 
 	for (int i = 1; i < _bake_resolution - 1; ++i) {
 		real_t x = i / static_cast<real_t>(_bake_resolution);
-		real_t y = interpolate(x);
+		real_t y = sample(x);
 		_baked_cache.write[i] = y;
 	}
 
@@ -459,7 +459,7 @@ void Curve::set_bake_resolution(int p_resolution) {
 	_baked_cache_dirty = true;
 }
 
-real_t Curve::interpolate_baked(real_t p_offset) const {
+real_t Curve::sample_baked(real_t p_offset) const {
 	if (_baked_cache_dirty) {
 		// Last-second bake if not done already
 		const_cast<Curve *>(this)->bake();
@@ -486,7 +486,7 @@ real_t Curve::interpolate_baked(real_t p_offset) const {
 		fi = 0;
 	}
 
-	// Interpolate
+	// Sample
 	if (i + 1 < _baked_cache.size()) {
 		real_t t = fi - i;
 		return Math::lerp(_baked_cache[i], _baked_cache[i + 1], t);
@@ -595,8 +595,8 @@ void Curve::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_point_position", "index"), &Curve::get_point_position);
 	ClassDB::bind_method(D_METHOD("set_point_value", "index", "y"), &Curve::set_point_value);
 	ClassDB::bind_method(D_METHOD("set_point_offset", "index", "offset"), &Curve::set_point_offset);
-	ClassDB::bind_method(D_METHOD("interpolate", "offset"), &Curve::interpolate);
-	ClassDB::bind_method(D_METHOD("interpolate_baked", "offset"), &Curve::interpolate_baked);
+	ClassDB::bind_method(D_METHOD("sample", "offset"), &Curve::sample);
+	ClassDB::bind_method(D_METHOD("sample_baked", "offset"), &Curve::sample_baked);
 	ClassDB::bind_method(D_METHOD("get_point_left_tangent", "index"), &Curve::get_point_left_tangent);
 	ClassDB::bind_method(D_METHOD("get_point_right_tangent", "index"), &Curve::get_point_right_tangent);
 	ClassDB::bind_method(D_METHOD("get_point_left_mode", "index"), &Curve::get_point_left_mode);
@@ -720,7 +720,7 @@ void Curve2D::clear_points() {
 	}
 }
 
-Vector2 Curve2D::interpolate(int p_index, const real_t p_offset) const {
+Vector2 Curve2D::sample(int p_index, const real_t p_offset) const {
 	int pc = points.size();
 	ERR_FAIL_COND_V(pc == 0, Vector2());
 
@@ -738,14 +738,14 @@ Vector2 Curve2D::interpolate(int p_index, const real_t p_offset) const {
 	return p0.bezier_interpolate(p1, p2, p3, p_offset);
 }
 
-Vector2 Curve2D::interpolatef(real_t p_findex) const {
+Vector2 Curve2D::samplef(real_t p_findex) const {
 	if (p_findex < 0) {
 		p_findex = 0;
 	} else if (p_findex >= points.size()) {
 		p_findex = points.size();
 	}
 
-	return interpolate((int)p_findex, Math::fmod(p_findex, (real_t)1.0));
+	return sample((int)p_findex, Math::fmod(p_findex, (real_t)1.0));
 }
 
 void Curve2D::mark_dirty() {
@@ -883,7 +883,7 @@ real_t Curve2D::get_baked_length() const {
 	return baked_max_ofs;
 }
 
-Vector2 Curve2D::interpolate_baked(real_t p_offset, bool p_cubic) const {
+Vector2 Curve2D::sample_baked(real_t p_offset, bool p_cubic) const {
 	if (baked_cache_dirty) {
 		_bake();
 	}
@@ -923,7 +923,7 @@ Vector2 Curve2D::interpolate_baked(real_t p_offset, bool p_cubic) const {
 	real_t offset_end = baked_dist_cache[idx + 1];
 
 	real_t idx_interval = offset_end - offset_begin;
-	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, Vector2(), "failed to find baked segment");
+	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, Vector2(), "Couldn't find baked segment.");
 
 	real_t frac = (p_offset - offset_begin) / idx_interval;
 
@@ -1176,14 +1176,14 @@ void Curve2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_point_out", "idx"), &Curve2D::get_point_out);
 	ClassDB::bind_method(D_METHOD("remove_point", "idx"), &Curve2D::remove_point);
 	ClassDB::bind_method(D_METHOD("clear_points"), &Curve2D::clear_points);
-	ClassDB::bind_method(D_METHOD("interpolate", "idx", "t"), &Curve2D::interpolate);
-	ClassDB::bind_method(D_METHOD("interpolatef", "fofs"), &Curve2D::interpolatef);
+	ClassDB::bind_method(D_METHOD("sample", "idx", "t"), &Curve2D::sample);
+	ClassDB::bind_method(D_METHOD("samplef", "fofs"), &Curve2D::samplef);
 	//ClassDB::bind_method(D_METHOD("bake","subdivs"),&Curve2D::bake,DEFVAL(10));
 	ClassDB::bind_method(D_METHOD("set_bake_interval", "distance"), &Curve2D::set_bake_interval);
 	ClassDB::bind_method(D_METHOD("get_bake_interval"), &Curve2D::get_bake_interval);
 
 	ClassDB::bind_method(D_METHOD("get_baked_length"), &Curve2D::get_baked_length);
-	ClassDB::bind_method(D_METHOD("interpolate_baked", "offset", "cubic"), &Curve2D::interpolate_baked, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("sample_baked", "offset", "cubic"), &Curve2D::sample_baked, DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("get_baked_points"), &Curve2D::get_baked_points);
 	ClassDB::bind_method(D_METHOD("get_closest_point", "to_point"), &Curve2D::get_closest_point);
 	ClassDB::bind_method(D_METHOD("get_closest_offset", "to_point"), &Curve2D::get_closest_offset);
@@ -1309,7 +1309,7 @@ void Curve3D::clear_points() {
 	}
 }
 
-Vector3 Curve3D::interpolate(int p_index, real_t p_offset) const {
+Vector3 Curve3D::sample(int p_index, real_t p_offset) const {
 	int pc = points.size();
 	ERR_FAIL_COND_V(pc == 0, Vector3());
 
@@ -1327,14 +1327,14 @@ Vector3 Curve3D::interpolate(int p_index, real_t p_offset) const {
 	return p0.bezier_interpolate(p1, p2, p3, p_offset);
 }
 
-Vector3 Curve3D::interpolatef(real_t p_findex) const {
+Vector3 Curve3D::samplef(real_t p_findex) const {
 	if (p_findex < 0) {
 		p_findex = 0;
 	} else if (p_findex >= points.size()) {
 		p_findex = points.size();
 	}
 
-	return interpolate((int)p_findex, Math::fmod(p_findex, (real_t)1.0));
+	return sample((int)p_findex, Math::fmod(p_findex, (real_t)1.0));
 }
 
 void Curve3D::mark_dirty() {
@@ -1536,7 +1536,7 @@ real_t Curve3D::get_baked_length() const {
 	return baked_max_ofs;
 }
 
-Vector3 Curve3D::interpolate_baked(real_t p_offset, bool p_cubic) const {
+Vector3 Curve3D::sample_baked(real_t p_offset, bool p_cubic) const {
 	if (baked_cache_dirty) {
 		_bake();
 	}
@@ -1576,7 +1576,7 @@ Vector3 Curve3D::interpolate_baked(real_t p_offset, bool p_cubic) const {
 	real_t offset_end = baked_dist_cache[idx + 1];
 
 	real_t idx_interval = offset_end - offset_begin;
-	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, Vector3(), "failed to find baked segment");
+	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, Vector3(), "Couldn't find baked segment.");
 
 	real_t frac = (p_offset - offset_begin) / idx_interval;
 
@@ -1589,7 +1589,7 @@ Vector3 Curve3D::interpolate_baked(real_t p_offset, bool p_cubic) const {
 	}
 }
 
-real_t Curve3D::interpolate_baked_tilt(real_t p_offset) const {
+real_t Curve3D::sample_baked_tilt(real_t p_offset) const {
 	if (baked_cache_dirty) {
 		_bake();
 	}
@@ -1629,14 +1629,14 @@ real_t Curve3D::interpolate_baked_tilt(real_t p_offset) const {
 	real_t offset_end = baked_dist_cache[idx + 1];
 
 	real_t idx_interval = offset_end - offset_begin;
-	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, 0, "failed to find baked segment");
+	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, 0, "Couldn't find baked segment.");
 
 	real_t frac = (p_offset - offset_begin) / idx_interval;
 
 	return Math::lerp(r[idx], r[idx + 1], (real_t)frac);
 }
 
-Vector3 Curve3D::interpolate_baked_up_vector(real_t p_offset, bool p_apply_tilt) const {
+Vector3 Curve3D::sample_baked_up_vector(real_t p_offset, bool p_apply_tilt) const {
 	if (baked_cache_dirty) {
 		_bake();
 	}
@@ -1671,7 +1671,7 @@ Vector3 Curve3D::interpolate_baked_up_vector(real_t p_offset, bool p_apply_tilt)
 	real_t offset_end = baked_dist_cache[idx + 1];
 
 	real_t idx_interval = offset_end - offset_begin;
-	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, Vector3(0, 1, 0), "failed to find baked segment");
+	ERR_FAIL_COND_V_MSG(p_offset < offset_begin || p_offset > offset_end, Vector3(0, 1, 0), "Couldn't find baked segment.");
 
 	real_t frac = (p_offset - offset_begin) / idx_interval;
 
@@ -1983,8 +1983,8 @@ void Curve3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_point_out", "idx"), &Curve3D::get_point_out);
 	ClassDB::bind_method(D_METHOD("remove_point", "idx"), &Curve3D::remove_point);
 	ClassDB::bind_method(D_METHOD("clear_points"), &Curve3D::clear_points);
-	ClassDB::bind_method(D_METHOD("interpolate", "idx", "t"), &Curve3D::interpolate);
-	ClassDB::bind_method(D_METHOD("interpolatef", "fofs"), &Curve3D::interpolatef);
+	ClassDB::bind_method(D_METHOD("sample", "idx", "t"), &Curve3D::sample);
+	ClassDB::bind_method(D_METHOD("samplef", "fofs"), &Curve3D::samplef);
 	//ClassDB::bind_method(D_METHOD("bake","subdivs"),&Curve3D::bake,DEFVAL(10));
 	ClassDB::bind_method(D_METHOD("set_bake_interval", "distance"), &Curve3D::set_bake_interval);
 	ClassDB::bind_method(D_METHOD("get_bake_interval"), &Curve3D::get_bake_interval);
@@ -1992,8 +1992,8 @@ void Curve3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_up_vector_enabled"), &Curve3D::is_up_vector_enabled);
 
 	ClassDB::bind_method(D_METHOD("get_baked_length"), &Curve3D::get_baked_length);
-	ClassDB::bind_method(D_METHOD("interpolate_baked", "offset", "cubic"), &Curve3D::interpolate_baked, DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("interpolate_baked_up_vector", "offset", "apply_tilt"), &Curve3D::interpolate_baked_up_vector, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("sample_baked", "offset", "cubic"), &Curve3D::sample_baked, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("sample_baked_up_vector", "offset", "apply_tilt"), &Curve3D::sample_baked_up_vector, DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("get_baked_points"), &Curve3D::get_baked_points);
 	ClassDB::bind_method(D_METHOD("get_baked_tilts"), &Curve3D::get_baked_tilts);
 	ClassDB::bind_method(D_METHOD("get_baked_up_vectors"), &Curve3D::get_baked_up_vectors);

scene/resources/curve.h

@@ -100,8 +100,8 @@ public:
 	real_t get_max_value() const { return _max_value; }
 	void set_max_value(real_t p_max);
 
-	real_t interpolate(real_t p_offset) const;
-	real_t interpolate_local_nocheck(int p_index, real_t p_local_offset) const;
+	real_t sample(real_t p_offset) const;
+	real_t sample_local_nocheck(int p_index, real_t p_local_offset) const;
 
 	void clean_dupes();
 
@@ -123,7 +123,7 @@ public:
 	void bake();
 	int get_bake_resolution() const { return _bake_resolution; }
 	void set_bake_resolution(int p_resolution);
-	real_t interpolate_baked(real_t p_offset) const;
+	real_t sample_baked(real_t p_offset) const;
 
 	void ensure_default_setup(real_t p_min, real_t p_max);
 
@@ -208,14 +208,14 @@ public:
 	void remove_point(int p_index);
 	void clear_points();
 
-	Vector2 interpolate(int p_index, real_t p_offset) const;
-	Vector2 interpolatef(real_t p_findex) const;
+	Vector2 sample(int p_index, real_t p_offset) const;
+	Vector2 samplef(real_t p_findex) const;
 
 	void set_bake_interval(real_t p_tolerance);
 	real_t get_bake_interval() const;
 
 	real_t get_baked_length() const;
-	Vector2 interpolate_baked(real_t p_offset, bool p_cubic = false) const;
+	Vector2 sample_baked(real_t p_offset, bool p_cubic = false) const;
 	PackedVector2Array get_baked_points() const; //useful for going through
 	Vector2 get_closest_point(const Vector2 &p_to_point) const;
 	real_t get_closest_offset(const Vector2 &p_to_point) const;
@@ -285,8 +285,8 @@ public:
 	void remove_point(int p_index);
 	void clear_points();
 
-	Vector3 interpolate(int p_index, real_t p_offset) const;
-	Vector3 interpolatef(real_t p_findex) const;
+	Vector3 sample(int p_index, real_t p_offset) const;
+	Vector3 samplef(real_t p_findex) const;
 
 	void set_bake_interval(real_t p_tolerance);
 	real_t get_bake_interval() const;
@@ -294,9 +294,9 @@ public:
 	bool is_up_vector_enabled() const;
 
 	real_t get_baked_length() const;
-	Vector3 interpolate_baked(real_t p_offset, bool p_cubic = false) const;
-	real_t interpolate_baked_tilt(real_t p_offset) const;
-	Vector3 interpolate_baked_up_vector(real_t p_offset, bool p_apply_tilt = false) const;
+	Vector3 sample_baked(real_t p_offset, bool p_cubic = false) const;
+	real_t sample_baked_tilt(real_t p_offset) const;
+	Vector3 sample_baked_up_vector(real_t p_offset, bool p_apply_tilt = false) const;
 	PackedVector3Array get_baked_points() const; //useful for going through
 	Vector<real_t> get_baked_tilts() const; //useful for going through
 	PackedVector3Array get_baked_up_vectors() const;

scene/resources/gradient.cpp

@@ -56,7 +56,7 @@ void Gradient::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_color", "point", "color"), &Gradient::set_color);
 	ClassDB::bind_method(D_METHOD("get_color", "point"), &Gradient::get_color);
 
-	ClassDB::bind_method(D_METHOD("interpolate", "offset"), &Gradient::get_color_at_offset);
+	ClassDB::bind_method(D_METHOD("sample", "offset"), &Gradient::get_color_at_offset);
 
 	ClassDB::bind_method(D_METHOD("get_point_count"), &Gradient::get_points_count);
 

scene/resources/gradient.h

@@ -122,7 +122,7 @@ public:
 			}
 		}
 
-		// Return interpolated value.
+		// Return sampled value.
 		if (points[middle].offset > p_offset) {
 			middle--;
 		}

scene/resources/primitive_meshes.cpp

@@ -1822,7 +1822,7 @@ void TubeTrailMesh::_create_mesh_array(Array &p_arr) const {
 
 			float r = radius;
 			if (curve.is_valid() && curve->get_point_count() > 0) {
-				r *= curve->interpolate_baked(v);
+				r *= curve->sample_baked(v);
 			}
 			float x = sin(u * Math_TAU);
 			float z = cos(u * Math_TAU);
@@ -1863,7 +1863,7 @@ void TubeTrailMesh::_create_mesh_array(Array &p_arr) const {
 	// add top
 	float scale_pos = 1.0;
 	if (curve.is_valid() && curve->get_point_count() > 0) {
-		scale_pos = curve->interpolate_baked(0);
+		scale_pos = curve->sample_baked(0);
 	}
 
 	if (scale_pos > CMP_EPSILON) {
@@ -1925,7 +1925,7 @@ void TubeTrailMesh::_create_mesh_array(Array &p_arr) const {
 
 	float scale_neg = 1.0;
 	if (curve.is_valid() && curve->get_point_count() > 0) {
-		scale_neg = curve->interpolate_baked(1.0);
+		scale_neg = curve->sample_baked(1.0);
 	}
 
 	// add bottom
@@ -2138,7 +2138,7 @@ void RibbonTrailMesh::_create_mesh_array(Array &p_arr) const {
 		float s = size;
 
 		if (curve.is_valid() && curve->get_point_count() > 0) {
-			s *= curve->interpolate_baked(v);
+			s *= curve->sample_baked(v);
 		}
 
 		points.push_back(Vector3(-s * 0.5, y, 0));

scene/resources/texture.cpp

@@ -1866,11 +1866,11 @@ void CurveTexture::_update() {
 			for (int i = 0; i < _width; ++i) {
 				float t = i / static_cast<float>(_width);
 				if (texture_mode == TEXTURE_MODE_RGB) {
-					wd[i * 3 + 0] = curve.interpolate_baked(t);
+					wd[i * 3 + 0] = curve.sample_baked(t);
 					wd[i * 3 + 1] = wd[i * 3 + 0];
 					wd[i * 3 + 2] = wd[i * 3 + 0];
 				} else {
-					wd[i] = curve.interpolate_baked(t);
+					wd[i] = curve.sample_baked(t);
 				}
 			}
 
@@ -2054,7 +2054,7 @@ void CurveXYZTexture::_update() {
 			Curve &curve_x = **_curve_x;
 			for (int i = 0; i < _width; ++i) {
 				float t = i / static_cast<float>(_width);
-				wd[i * 3 + 0] = curve_x.interpolate_baked(t);
+				wd[i * 3 + 0] = curve_x.sample_baked(t);
 			}
 
 		} else {
@@ -2067,7 +2067,7 @@ void CurveXYZTexture::_update() {
 			Curve &curve_y = **_curve_y;
 			for (int i = 0; i < _width; ++i) {
 				float t = i / static_cast<float>(_width);
-				wd[i * 3 + 1] = curve_y.interpolate_baked(t);
+				wd[i * 3 + 1] = curve_y.sample_baked(t);
 			}
 
 		} else {
@@ -2080,7 +2080,7 @@ void CurveXYZTexture::_update() {
 			Curve &curve_z = **_curve_z;
 			for (int i = 0; i < _width; ++i) {
 				float t = i / static_cast<float>(_width);
-				wd[i * 3 + 2] = curve_z.interpolate_baked(t);
+				wd[i * 3 + 2] = curve_z.sample_baked(t);
 			}
 
 		} else {

tests/scene/test_curve.h

@@ -44,13 +44,13 @@ TEST_CASE("[Curve] Default curve") {
 			curve->get_point_count() == 0,
 			"Default curve should contain the expected number of points.");
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate(0)),
+			Math::is_zero_approx(curve->sample(0)),
 			"Default curve should return the expected value at offset 0.0.");
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate(0.5)),
+			Math::is_zero_approx(curve->sample(0.5)),
 			"Default curve should return the expected value at offset 0.5.");
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate(1)),
+			Math::is_zero_approx(curve->sample(1)),
 			"Default curve should return the expected value at offset 1.0.");
 }
 
@@ -80,57 +80,57 @@ TEST_CASE("[Curve] Custom curve with free tangents") {
 			"Custom free curve should contain the expected number of points.");
 
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate(-0.1)),
+			Math::is_zero_approx(curve->sample(-0.1)),
 			"Custom free curve should return the expected value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.1), (real_t)0.352),
+			Math::is_equal_approx(curve->sample(0.1), (real_t)0.352),
 			"Custom free curve should return the expected value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.4), (real_t)0.352),
+			Math::is_equal_approx(curve->sample(0.4), (real_t)0.352),
 			"Custom free curve should return the expected value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.7), (real_t)0.896),
+			Math::is_equal_approx(curve->sample(0.7), (real_t)0.896),
 			"Custom free curve should return the expected value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(1), 1),
+			Math::is_equal_approx(curve->sample(1), 1),
 			"Custom free curve should return the expected value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(2), 1),
+			Math::is_equal_approx(curve->sample(2), 1),
 			"Custom free curve should return the expected value at offset 0.1.");
 
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate_baked(-0.1)),
+			Math::is_zero_approx(curve->sample_baked(-0.1)),
 			"Custom free curve should return the expected baked value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.1), (real_t)0.352),
+			Math::is_equal_approx(curve->sample_baked(0.1), (real_t)0.352),
 			"Custom free curve should return the expected baked value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.4), (real_t)0.352),
+			Math::is_equal_approx(curve->sample_baked(0.4), (real_t)0.352),
 			"Custom free curve should return the expected baked value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.7), (real_t)0.896),
+			Math::is_equal_approx(curve->sample_baked(0.7), (real_t)0.896),
 			"Custom free curve should return the expected baked value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(1), 1),
+			Math::is_equal_approx(curve->sample_baked(1), 1),
 			"Custom free curve should return the expected baked value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(2), 1),
+			Math::is_equal_approx(curve->sample_baked(2), 1),
 			"Custom free curve should return the expected baked value at offset 0.1.");
 
 	curve->remove_point(1);
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.1), 0),
+			Math::is_equal_approx(curve->sample(0.1), 0),
 			"Custom free curve should return the expected value at offset 0.1 after removing point at index 1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.1), 0),
+			Math::is_equal_approx(curve->sample_baked(0.1), 0),
 			"Custom free curve should return the expected baked value at offset 0.1 after removing point at index 1.");
 
 	curve->clear_points();
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.6), 0),
+			Math::is_equal_approx(curve->sample(0.6), 0),
 			"Custom free curve should return the expected value at offset 0.6 after clearing all points.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.6), 0),
+			Math::is_equal_approx(curve->sample_baked(0.6), 0),
 			"Custom free curve should return the expected baked value at offset 0.6 after clearing all points.");
 }
 
@@ -169,51 +169,51 @@ TEST_CASE("[Curve] Custom curve with linear tangents") {
 			"Custom linear curve should contain the expected number of points.");
 
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate(-0.1)),
+			Math::is_zero_approx(curve->sample(-0.1)),
 			"Custom linear curve should return the expected value at offset -0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.1), (real_t)0.4),
+			Math::is_equal_approx(curve->sample(0.1), (real_t)0.4),
 			"Custom linear curve should return the expected value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.4), (real_t)0.4),
+			Math::is_equal_approx(curve->sample(0.4), (real_t)0.4),
 			"Custom linear curve should return the expected value at offset 0.4.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.7), (real_t)0.8),
+			Math::is_equal_approx(curve->sample(0.7), (real_t)0.8),
 			"Custom linear curve should return the expected value at offset 0.7.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(1), 1),
+			Math::is_equal_approx(curve->sample(1), 1),
 			"Custom linear curve should return the expected value at offset 1.0.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(2), 1),
+			Math::is_equal_approx(curve->sample(2), 1),
 			"Custom linear curve should return the expected value at offset 2.0.");
 
 	CHECK_MESSAGE(
-			Math::is_zero_approx(curve->interpolate_baked(-0.1)),
+			Math::is_zero_approx(curve->sample_baked(-0.1)),
 			"Custom linear curve should return the expected baked value at offset -0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.1), (real_t)0.4),
+			Math::is_equal_approx(curve->sample_baked(0.1), (real_t)0.4),
 			"Custom linear curve should return the expected baked value at offset 0.1.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.4), (real_t)0.4),
+			Math::is_equal_approx(curve->sample_baked(0.4), (real_t)0.4),
 			"Custom linear curve should return the expected baked value at offset 0.4.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.7), (real_t)0.8),
+			Math::is_equal_approx(curve->sample_baked(0.7), (real_t)0.8),
 			"Custom linear curve should return the expected baked value at offset 0.7.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(1), 1),
+			Math::is_equal_approx(curve->sample_baked(1), 1),
 			"Custom linear curve should return the expected baked value at offset 1.0.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(2), 1),
+			Math::is_equal_approx(curve->sample_baked(2), 1),
 			"Custom linear curve should return the expected baked value at offset 2.0.");
 
 	ERR_PRINT_OFF;
 	curve->remove_point(10);
 	ERR_PRINT_ON;
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate(0.7), (real_t)0.8),
+			Math::is_equal_approx(curve->sample(0.7), (real_t)0.8),
 			"Custom free curve should return the expected value at offset 0.7 after removing point at invalid index 10.");
 	CHECK_MESSAGE(
-			Math::is_equal_approx(curve->interpolate_baked(0.7), (real_t)0.8),
+			Math::is_equal_approx(curve->sample_baked(0.7), (real_t)0.8),
 			"Custom free curve should return the expected baked value at offset 0.7 after removing point at invalid index 10.");
 }
 
@@ -228,8 +228,8 @@ TEST_CASE("[Curve2D] Linear sampling should return exact value") {
 	CHECK(len == baked_length);
 
 	for (int i = 0; i < len; i++) {
-		Vector2 pos = curve->interpolate_baked(i);
-		CHECK_MESSAGE(pos.x == i, "interpolate_baked should return exact value");
+		Vector2 pos = curve->sample_baked(i);
+		CHECK_MESSAGE(pos.x == i, "sample_baked should return exact value");
 	}
 }
 
@@ -244,8 +244,8 @@ TEST_CASE("[Curve3D] Linear sampling should return exact value") {
 	CHECK(len == baked_length);
 
 	for (int i = 0; i < len; i++) {
-		Vector3 pos = curve->interpolate_baked(i);
-		CHECK_MESSAGE(pos.x == i, "interpolate_baked should return exact value");
+		Vector3 pos = curve->sample_baked(i);
+		CHECK_MESSAGE(pos.x == i, "sample_baked should return exact value");
 	}
 }