mirror of
https://github.com/godotengine/godot
synced 2024-09-05 04:38:26 +00:00
Rename Curve/Curve2D/Curve3D/Gradient interpolate()
to sample()
"sampling" is a more accurate term than "interpolating" for what's happening when using that function.
This commit is contained in:
parent
de5f13e935
commit
ae18928748
|
@ -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" />
|
||||
|
|
|
@ -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">
|
||||
|
|
|
@ -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">
|
||||
|
|
|
@ -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" />
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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)))) {
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -122,7 +122,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
// Return interpolated value.
|
||||
// Return sampled value.
|
||||
if (points[middle].offset > p_offset) {
|
||||
middle--;
|
||||
}
|
||||
|
|
|
@ -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));
|
||||
|
|
|
@ -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 {
|
||||
|
|
|
@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue