godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename OrientedPathFollow to PathFollowOriented

This commit is contained in:
Danilo Villa (Davi) 2019-01-11 17:03:12 -02:00
parent bf799246fd
commit e74a3add9c
7 changed files with 65 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/classes/Curve3D.xml
View File

@ -225,7 +225,7 @@
</argument>
<description>
Sets the tilt angle in radians for the point [code]idx[/code]. If the index is out of bounds, the function sends an error to the console.
The tilt controls the rotation along the look-at axis an object traveling the path would have. In the case of a curve controlling a [PathFollow] or [OrientedPathFollow], this tilt is an offset over the natural tilt the [PathFollow] or [OrientedPathFollow] calculates.
The tilt controls the rotation along the look-at axis an object traveling the path would have. In the case of a curve controlling a [PathFollow], this tilt is an offset over the natural tilt the [PathFollow] calculates.
</description>
</method>
<method name="tessellate" qualifiers="const">
@ -248,7 +248,7 @@
The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the [method get_baked_points] or [method get_baked_length] function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care.
</member>
<member name="up_vector_enabled" type="bool" setter="set_up_vector_enabled" getter="is_up_vector_enabled">
If [code]true[/code], the curve will bake up vectors used for orientation. See [OrientedPathFollow]. Changing it forces the cache to be recomputed.
If [code]true[/code], the curve will bake up vectors used for orientation. This is used when a [member PathFollow.rotation_mode] is set to [code]ROTATION_ORIENTED[/code], see [PathFollow] for details. Changing it forces the cache to be recomputed.
</member>
</members>
<constants>

40
doc/classes/OrientedPathFollow.xml
View File

@ -1,40 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="OrientedPathFollow" inherits="Spatial" category="Core" version="3.1">
<brief_description>
Oriented point sampler for a [Path].
</brief_description>
<description>
This node behaves like [PathFollow], except it uses its parent [Path] up vector information to enforce orientation.
Make sure to check if the curve of this node's parent [Path] has up vectors enabled. See [PathFollow] and [Curve3D] for further information.
</description>
<tutorials>
</tutorials>
<demos>
</demos>
<methods>
</methods>
<members>
<member name="cubic_interp" type="bool" setter="set_cubic_interpolation" getter="get_cubic_interpolation">
If [code]true[/code], the position between two cached points is interpolated cubically, and linearly otherwise.
The points along the [Curve3D] of the [Path] are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough.
There are two answers to this problem: Either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations.
</member>
<member name="h_offset" type="float" setter="set_h_offset" getter="get_h_offset">
The node's offset along the curve.
</member>
<member name="loop" type="bool" setter="set_loop" getter="has_loop">
If [code]true[/code], any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths.
</member>
<member name="offset" type="float" setter="set_offset" getter="get_offset">
The distance from the first vertex, measured in 3D units along the path. This sets this node's position to a point within the path.
</member>
<member name="unit_offset" type="float" setter="set_unit_offset" getter="get_unit_offset">
The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the offset within the path, as the offset supplied is multiplied internally by the path's length.
</member>
<member name="v_offset" type="float" setter="set_v_offset" getter="get_v_offset">
The node's offset perpendicular to the curve.
</member>
</members>
<constants>
</constants>
</class>

3
doc/classes/PathFollow.xml
View File

@ -51,5 +51,8 @@
<constant name="ROTATION_XYZ" value="3" enum="RotationMode">
Allows the PathFollow to rotate in any axis.
</constant>
<constant name="ROTATION_ORIENTED" value="4" enum="RotationMode">
Uses the up vector information in a [Curve3D] to enforce orientation. This rotation mode requires the [Path]'s [member Curve3D.up_vector_enabled] property to be set to [code]true[/code].
</constant>
</constants>
</class>

5
editor/icons/icon_oriented_path_follow.svg
View File

@ -1,5 +0,0 @@
<svg width="16" height="16" version="1.1" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg">
<g transform="translate(0 -1036.4)">
<path transform="translate(0 1036.4)" d="m13 0l-3 4h1.9473c-0.1385 1.3203-0.5583 1.9074-1.084 2.2754-0.64426 0.451-1.7129 0.60547-2.9629 0.73047s-2.6814 0.22053-3.9121 1.082c-0.89278 0.62493-1.5321 1.6522-1.8184 3.0957a2 2 0 0 0 -1.1699 1.8164 2 2 0 0 0 2 2 2 2 0 0 0 2 -2 2 2 0 0 0 -0.84961 -1.6328c0.19235-0.88496 0.55306-1.3373 0.98633-1.6406 0.64426-0.451 1.7129-0.60547 2.9629-0.73047s2.6814-0.22053 3.9121-1.082c1.0528-0.73697 1.7552-2.032 1.9375-3.9141h2.0508l-3-4z" fill="#fc9c9c" fill-opacity=".99608"/>
</g>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 660 B

300
scene/3d/path.cpp
View File

@ -44,10 +44,11 @@ void Path::_curve_changed() {
emit_signal("curve_changed");
}
// update the configuration warnings of all children of type OrientedPathFollows
// update the configuration warnings of all children of type PathFollow
// previously used for PathFollowOriented (now enforced orientation is done in PathFollow)
if (is_inside_tree()) {
for (int i = 0; i < get_child_count(); i++) {
OrientedPathFollow *child = Object::cast_to<OrientedPathFollow>(get_child(i));
PathFollow *child = Object::cast_to<PathFollow>(get_child(i));
if (child) {
child->update_configuration_warning();
}
@ -105,24 +106,64 @@ void PathFollow::_update_transform() {
return;
}
float bl = c->get_baked_length();
float bi = c->get_bake_interval();
float o = offset;
float o_next = offset + bi;
if (loop) {
o = Math::fposmod(o, c->get_baked_length());
o = Math::fposmod(o, bl);
o_next = Math::fposmod(o_next, bl);
} else if (rotation_mode == ROTATION_ORIENTED && o_next >= bl) {
o = bl - bi;
o_next = bl;
}
Vector3 pos = c->interpolate_baked(o, cubic);
Transform 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 formely used
t.origin = pos;
Vector3 pos_offset = Vector3(h_offset, v_offset, 0);
if (rotation_mode == ROTATION_ORIENTED) {
if (rotation_mode != ROTATION_NONE) {
Vector3 pos = c->interpolate_baked(o, cubic);
Vector3 forward = c->interpolate_baked(o_next, cubic) - pos;
if (forward.length_squared() < CMP_EPSILON2)
forward = Vector3(0, 0, 1);
else
forward.normalize();
Vector3 up = c->interpolate_baked_up_vector(o, true);
if (o_next < o) {
Vector3 up1 = c->interpolate_baked_up_vector(o_next, true);
Vector3 axis = up.cross(up1);
if (axis.length_squared() < CMP_EPSILON2)
axis = forward;
else
axis.normalize();
up.rotate(axis, up.angle_to(up1) * 0.5f);
}
Vector3 scale = t.basis.get_scale();
Vector3 sideways = up.cross(forward).normalized();
up = forward.cross(sideways).normalized();
t.basis.set(sideways, up, forward);
t.basis.scale_local(scale);
t.origin = pos + sideways * h_offset + up * v_offset;
} else if (rotation_mode != ROTATION_NONE) {
// perform parallel transport
//
// see C. Dougan, The Parallel Transport Frame, Game Programming Gems 2 for example
// for a discussion about why not Frenet frame.
t.origin = pos;
Vector3 t_prev = (pos - c->interpolate_baked(o - delta_offset, cubic)).normalized();
Vector3 t_cur = (c->interpolate_baked(o + delta_offset, cubic) - pos).normalized();
@ -165,9 +206,9 @@ void PathFollow::_update_transform() {
}
}
t.translate(pos_offset);
t.translate(Vector3(h_offset, v_offset, 0));
} else {
t.origin += pos_offset;
t.origin = pos + Vector3(h_offset, v_offset, 0);
}
set_transform(t);
@ -224,6 +265,11 @@ String PathFollow::get_configuration_warning() const {
if (!Object::cast_to<Path>(get_parent())) {
return TTR("PathFollow only works when set as a child of a Path node.");
} else {
Path *path = Object::cast_to<Path>(get_parent());
if (path->get_curve().is_valid() && !path->get_curve()->is_up_vector_enabled() && rotation_mode == ROTATION_ORIENTED) {
return TTR("PathFollow ROTATION_ORIENTED requires \"Up Vector\" enabled in its parent Path's Curve resource.");
}
}
return String();
@ -256,7 +302,7 @@ void PathFollow::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::REAL, "unit_offset", PROPERTY_HINT_RANGE, "0,1,0.0001,or_greater", PROPERTY_USAGE_EDITOR), "set_unit_offset", "get_unit_offset");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "h_offset"), "set_h_offset", "get_h_offset");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "v_offset"), "set_v_offset", "get_v_offset");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rotation_mode", PROPERTY_HINT_ENUM, "None,Y,XY,XYZ"), "set_rotation_mode", "get_rotation_mode");
ADD_PROPERTY(PropertyInfo(Variant::INT, "rotation_mode", PROPERTY_HINT_ENUM, "None,Y,XY,XYZ,Oriented"), "set_rotation_mode", "get_rotation_mode");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cubic_interp"), "set_cubic_interpolation", "get_cubic_interpolation");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop"), "set_loop", "has_loop");
@ -264,6 +310,7 @@ void PathFollow::_bind_methods() {
BIND_ENUM_CONSTANT(ROTATION_Y);
BIND_ENUM_CONSTANT(ROTATION_XY);
BIND_ENUM_CONSTANT(ROTATION_XYZ);
BIND_ENUM_CONSTANT(ROTATION_ORIENTED);
}
void PathFollow::set_offset(float p_offset) {
@ -322,6 +369,8 @@ float PathFollow::get_unit_offset() const {
void PathFollow::set_rotation_mode(RotationMode p_rotation_mode) {
rotation_mode = p_rotation_mode;
update_configuration_warning();
_update_transform();
}
@ -351,236 +400,3 @@ PathFollow::PathFollow() {
cubic = true;
loop = true;
}
//////////////
void OrientedPathFollow::_update_transform() {
if (!path)
return;
Ref<Curve3D> c = path->get_curve();
if (!c.is_valid())
return;
int count = c->get_point_count();
if (count < 2)
return;
if (delta_offset == 0) {
return;
}
float offset = get_offset();
float bl = c->get_baked_length();
float bi = c->get_bake_interval();
float o = offset;
float o_next = offset + bi;
if (has_loop()) {
o = Math::fposmod(o, bl);
o_next = Math::fposmod(o_next, bl);
} else if (o_next >= bl) {
o = bl - bi;
o_next = bl;
}
bool cubic = get_cubic_interpolation();
Vector3 pos = c->interpolate_baked(o, cubic);
Vector3 forward = c->interpolate_baked(o_next, cubic) - pos;
if (forward.length_squared() < CMP_EPSILON2)
forward = Vector3(0, 0, 1);
else
forward.normalize();
Vector3 up = c->interpolate_baked_up_vector(o, true);
if (o_next < o) {
Vector3 up1 = c->interpolate_baked_up_vector(o_next, true);
Vector3 axis = up.cross(up1);
if (axis.length_squared() < CMP_EPSILON2)
axis = forward;
else
axis.normalize();
up.rotate(axis, up.angle_to(up1) * 0.5f);
}
Transform t = get_transform();
Vector3 scale = t.basis.get_scale();
Vector3 sideways = up.cross(forward).normalized();
up = forward.cross(sideways).normalized();
t.basis.set(sideways, up, forward);
t.basis.scale_local(scale);
t.origin = pos + sideways * get_h_offset() + up * get_v_offset();
set_transform(t);
}
void OrientedPathFollow::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_TREE: {
Node *parent = get_parent();
if (parent) {
path = Object::cast_to<Path>(parent);
if (path) {
_update_transform();
}
}
} break;
case NOTIFICATION_EXIT_TREE: {
path = NULL;
} break;
}
}
void OrientedPathFollow::set_cubic_interpolation(bool p_enable) {
cubic = p_enable;
}
bool OrientedPathFollow::get_cubic_interpolation() const {
return cubic;
}
void OrientedPathFollow::_validate_property(PropertyInfo &property) const {
if (property.name == "offset") {
float max = 10000;
if (path && path->get_curve().is_valid())
max = path->get_curve()->get_baked_length();
property.hint_string = "0," + rtos(max) + ",0.01";
}
}
String OrientedPathFollow::get_configuration_warning() const {
if (!is_visible_in_tree() || !is_inside_tree())
return String();
if (!Object::cast_to<Path>(get_parent())) {
return TTR("OrientedPathFollow only works when set as a child of a Path node.");
} else {
Path *path = Object::cast_to<Path>(get_parent());
if (path->get_curve().is_valid() && !path->get_curve()->is_up_vector_enabled()) {
return TTR("OrientedPathFollow requires \"Up Vector\" enabled in its parent Path's Curve resource.");
}
}
return String();
}
void OrientedPathFollow::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_offset", "offset"), &OrientedPathFollow::set_offset);
ClassDB::bind_method(D_METHOD("get_offset"), &OrientedPathFollow::get_offset);
ClassDB::bind_method(D_METHOD("set_h_offset", "h_offset"), &OrientedPathFollow::set_h_offset);
ClassDB::bind_method(D_METHOD("get_h_offset"), &OrientedPathFollow::get_h_offset);
ClassDB::bind_method(D_METHOD("set_v_offset", "v_offset"), &OrientedPathFollow::set_v_offset);
ClassDB::bind_method(D_METHOD("get_v_offset"), &OrientedPathFollow::get_v_offset);
ClassDB::bind_method(D_METHOD("set_unit_offset", "unit_offset"), &OrientedPathFollow::set_unit_offset);
ClassDB::bind_method(D_METHOD("get_unit_offset"), &OrientedPathFollow::get_unit_offset);
ClassDB::bind_method(D_METHOD("set_cubic_interpolation", "enable"), &OrientedPathFollow::set_cubic_interpolation);
ClassDB::bind_method(D_METHOD("get_cubic_interpolation"), &OrientedPathFollow::get_cubic_interpolation);
ClassDB::bind_method(D_METHOD("set_loop", "loop"), &OrientedPathFollow::set_loop);
ClassDB::bind_method(D_METHOD("has_loop"), &OrientedPathFollow::has_loop);
ADD_PROPERTY(PropertyInfo(Variant::REAL, "offset", PROPERTY_HINT_RANGE, "0,10000,0.01"), "set_offset", "get_offset");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "unit_offset", PROPERTY_HINT_RANGE, "0,1,0.0001", PROPERTY_USAGE_EDITOR), "set_unit_offset", "get_unit_offset");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "h_offset"), "set_h_offset", "get_h_offset");
ADD_PROPERTY(PropertyInfo(Variant::REAL, "v_offset"), "set_v_offset", "get_v_offset");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cubic_interp"), "set_cubic_interpolation", "get_cubic_interpolation");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop"), "set_loop", "has_loop");
}
void OrientedPathFollow::set_offset(float p_offset) {
delta_offset = p_offset - offset;
offset = p_offset;
if (path)
_update_transform();
_change_notify("offset");
_change_notify("unit_offset");
}
void OrientedPathFollow::set_h_offset(float p_h_offset) {
h_offset = p_h_offset;
if (path)
_update_transform();
}
float OrientedPathFollow::get_h_offset() const {
return h_offset;
}
void OrientedPathFollow::set_v_offset(float p_v_offset) {
v_offset = p_v_offset;
if (path)
_update_transform();
}
float OrientedPathFollow::get_v_offset() const {
return v_offset;
}
float OrientedPathFollow::get_offset() const {
return offset;
}
void OrientedPathFollow::set_unit_offset(float p_unit_offset) {
if (path && path->get_curve().is_valid() && path->get_curve()->get_baked_length())
set_offset(p_unit_offset * path->get_curve()->get_baked_length());
}
float OrientedPathFollow::get_unit_offset() const {
if (path && path->get_curve().is_valid() && path->get_curve()->get_baked_length())
return get_offset() / path->get_curve()->get_baked_length();
else
return 0;
}
void OrientedPathFollow::set_loop(bool p_loop) {
loop = p_loop;
}
bool OrientedPathFollow::has_loop() const {
return loop;
}
OrientedPathFollow::OrientedPathFollow() {
offset = 0;
delta_offset = 0;
h_offset = 0;
v_offset = 0;
path = NULL;
cubic = true;
loop = true;
}

48
scene/3d/path.h
View File

@ -63,7 +63,8 @@ public:
ROTATION_NONE,
ROTATION_Y,
ROTATION_XY,
ROTATION_XYZ
ROTATION_XYZ,
ROTATION_ORIENTED
};
private:
@ -113,49 +114,4 @@ public:
VARIANT_ENUM_CAST(PathFollow::RotationMode);
class OrientedPathFollow : public Spatial {
GDCLASS(OrientedPathFollow, Spatial);
private:
Path *path;
real_t delta_offset; // change in offset since last _update_transform
real_t offset;
real_t h_offset;
real_t v_offset;
bool cubic;
bool loop;
void _update_transform();
protected:
virtual void _validate_property(PropertyInfo &property) const;
void _notification(int p_what);
static void _bind_methods();
public:
void set_offset(float p_offset);
float get_offset() const;
void set_h_offset(float p_h_offset);
float get_h_offset() const;
void set_v_offset(float p_v_offset);
float get_v_offset() const;
void set_unit_offset(float p_unit_offset);
float get_unit_offset() const;
void set_loop(bool p_loop);
bool has_loop() const;
void set_cubic_interpolation(bool p_enable);
bool get_cubic_interpolation() const;
String get_configuration_warning() const;
OrientedPathFollow();
};
#endif // PATH_H

1
scene/register_scene_types.cpp
View File

@ -452,7 +452,6 @@ void register_scene_types() {
ClassDB::register_class<Curve3D>();
ClassDB::register_class<Path>();
ClassDB::register_class<PathFollow>();
ClassDB::register_class<OrientedPathFollow>();
ClassDB::register_class<VisibilityNotifier>();
ClassDB::register_class<VisibilityEnabler>();
ClassDB::register_class<WorldEnvironment>();