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

Merge pull request #66747 from aaronfranke/move-euler-order

Browse Source 
Move EulerOrder enum to math_defs.h and global scope
This commit is contained in:
Rémi Verschelde
2022-11-02 22:37:12 +01:00
parent 18380817f2 8556fdd4bc
commit 08d56ac2f1
16 changed files with 105 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
core/core_constants.cpp
View File

@ -167,6 +167,13 @@ void register_global_constants() {
BIND_CORE_ENUM_CONSTANT(INLINE_ALIGNMENT_IMAGE_MASK); BIND_CORE_ENUM_CONSTANT(INLINE_ALIGNMENT_IMAGE_MASK);
BIND_CORE_ENUM_CONSTANT(INLINE_ALIGNMENT_TEXT_MASK); BIND_CORE_ENUM_CONSTANT(INLINE_ALIGNMENT_TEXT_MASK);
BIND_CORE_ENUM_CLASS_CONSTANT(EulerOrder, EULER_ORDER, XYZ);
BIND_CORE_ENUM_CLASS_CONSTANT(EulerOrder, EULER_ORDER, XZY);
BIND_CORE_ENUM_CLASS_CONSTANT(EulerOrder, EULER_ORDER, YXZ);
BIND_CORE_ENUM_CLASS_CONSTANT(EulerOrder, EULER_ORDER, YZX);
BIND_CORE_ENUM_CLASS_CONSTANT(EulerOrder, EULER_ORDER, ZXY);
BIND_CORE_ENUM_CLASS_CONSTANT(EulerOrder, EULER_ORDER, ZYX);
BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, NONE); BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, NONE);
BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, SPECIAL); BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, SPECIAL);
BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, ESCAPE); BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, ESCAPE);

24
core/math/basis.cpp
View File

@ -453,7 +453,7 @@ void Basis::get_rotation_axis_angle_local(Vector3 &p_axis, real_t &p_angle) cons
Vector3 Basis::get_euler(EulerOrder p_order) const { Vector3 Basis::get_euler(EulerOrder p_order) const {
switch (p_order) { switch (p_order) {
case EULER_ORDER_XYZ: { case EulerOrder::XYZ: {
// Euler angles in XYZ convention. // Euler angles in XYZ convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
// //
@ -488,7 +488,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
} }
return euler; return euler;
} break; } break;
case EULER_ORDER_XZY: { case EulerOrder::XZY: {
// Euler angles in XZY convention. // Euler angles in XZY convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
// //
@ -517,7 +517,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
} }
return euler; return euler;
} break; } break;
case EULER_ORDER_YXZ: { case EulerOrder::YXZ: {
// Euler angles in YXZ convention. // Euler angles in YXZ convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
// //
@ -555,7 +555,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
return euler; return euler;
} break; } break;
case EULER_ORDER_YZX: { case EulerOrder::YZX: {
// Euler angles in YZX convention. // Euler angles in YZX convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
// //
@ -584,7 +584,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
} }
return euler; return euler;
} break; } break;
case EULER_ORDER_ZXY: { case EulerOrder::ZXY: {
// Euler angles in ZXY convention. // Euler angles in ZXY convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
// //
@ -612,7 +612,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
} }
return euler; return euler;
} break; } break;
case EULER_ORDER_ZYX: { case EulerOrder::ZYX: {
// Euler angles in ZYX convention. // Euler angles in ZYX convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
// //
@ -663,22 +663,22 @@ void Basis::set_euler(const Vector3 &p_euler, EulerOrder p_order) {
Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1); Basis zmat(c, -s, 0, s, c, 0, 0, 0, 1);
switch (p_order) { switch (p_order) {
case EULER_ORDER_XYZ: { case EulerOrder::XYZ: {
*this = xmat * (ymat * zmat); *this = xmat * (ymat * zmat);
} break; } break;
case EULER_ORDER_XZY: { case EulerOrder::XZY: {
*this = xmat * zmat * ymat; *this = xmat * zmat * ymat;
} break; } break;
case EULER_ORDER_YXZ: { case EulerOrder::YXZ: {
*this = ymat * xmat * zmat; *this = ymat * xmat * zmat;
} break; } break;
case EULER_ORDER_YZX: { case EulerOrder::YZX: {
*this = ymat * zmat * xmat; *this = ymat * zmat * xmat;
} break; } break;
case EULER_ORDER_ZXY: { case EulerOrder::ZXY: {
*this = zmat * xmat * ymat; *this = zmat * xmat * ymat;
} break; } break;
case EULER_ORDER_ZYX: { case EulerOrder::ZYX: {
*this = zmat * ymat * xmat; *this = zmat * ymat * xmat;
} break; } break;
default: { default: {

23
core/math/basis.h
View File

@ -56,15 +56,6 @@ struct _NO_DISCARD_ Basis {
_FORCE_INLINE_ real_t determinant() const; _FORCE_INLINE_ real_t determinant() const;
enum EulerOrder {
EULER_ORDER_XYZ,
EULER_ORDER_XZY,
EULER_ORDER_YXZ,
EULER_ORDER_YZX,
EULER_ORDER_ZXY,
EULER_ORDER_ZYX
};
void from_z(const Vector3 &p_z); void from_z(const Vector3 &p_z);
void rotate(const Vector3 &p_axis, real_t p_angle); void rotate(const Vector3 &p_axis, real_t p_angle);
@ -73,13 +64,13 @@ struct _NO_DISCARD_ Basis {
void rotate_local(const Vector3 &p_axis, real_t p_angle); void rotate_local(const Vector3 &p_axis, real_t p_angle);
Basis rotated_local(const Vector3 &p_axis, real_t p_angle) const; Basis rotated_local(const Vector3 &p_axis, real_t p_angle) const;
void rotate(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ); void rotate(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ);
Basis rotated(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ) const; Basis rotated(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ) const;
void rotate(const Quaternion &p_quaternion); void rotate(const Quaternion &p_quaternion);
Basis rotated(const Quaternion &p_quaternion) const; Basis rotated(const Quaternion &p_quaternion) const;
Vector3 get_euler_normalized(EulerOrder p_order = EULER_ORDER_YXZ) const; Vector3 get_euler_normalized(EulerOrder p_order = EulerOrder::YXZ) const;
void get_rotation_axis_angle(Vector3 &p_axis, real_t &p_angle) const; void get_rotation_axis_angle(Vector3 &p_axis, real_t &p_angle) const;
void get_rotation_axis_angle_local(Vector3 &p_axis, real_t &p_angle) const; void get_rotation_axis_angle_local(Vector3 &p_axis, real_t &p_angle) const;
Quaternion get_rotation_quaternion() const; Quaternion get_rotation_quaternion() const;
@ -88,9 +79,9 @@ struct _NO_DISCARD_ Basis {
Vector3 rotref_posscale_decomposition(Basis &rotref) const; Vector3 rotref_posscale_decomposition(Basis &rotref) const;
Vector3 get_euler(EulerOrder p_order = EULER_ORDER_YXZ) const; Vector3 get_euler(EulerOrder p_order = EulerOrder::YXZ) const;
void set_euler(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ); void set_euler(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ);
static Basis from_euler(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ) { static Basis from_euler(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ) {
Basis b; Basis b;
b.set_euler(p_euler, p_order); b.set_euler(p_euler, p_order);
return b; return b;
@ -119,7 +110,7 @@ struct _NO_DISCARD_ Basis {
Vector3 get_scale_local() const; Vector3 get_scale_local() const;
void set_axis_angle_scale(const Vector3 &p_axis, real_t p_angle, const Vector3 &p_scale); void set_axis_angle_scale(const Vector3 &p_axis, real_t p_angle, const Vector3 &p_scale);
void set_euler_scale(const Vector3 &p_euler, const Vector3 &p_scale, EulerOrder p_order = EULER_ORDER_YXZ); void set_euler_scale(const Vector3 &p_euler, const Vector3 &p_scale, EulerOrder p_order = EulerOrder::YXZ);
void set_quaternion_scale(const Quaternion &p_quaternion, const Vector3 &p_scale); void set_quaternion_scale(const Quaternion &p_quaternion, const Vector3 &p_scale);
// transposed dot products // transposed dot products

9
core/math/math_defs.h
View File

@ -116,6 +116,15 @@ enum Corner {
CORNER_BOTTOM_LEFT CORNER_BOTTOM_LEFT
}; };
enum class EulerOrder {
XYZ,
XZY,
YXZ,
YZX,
ZXY,
ZYX
};
/** /**
* The "Real" type is an abstract type used for real numbers, such as 1.5, * The "Real" type is an abstract type used for real numbers, such as 1.5,
* in contrast to integer numbers. Precision can be controlled with the * in contrast to integer numbers. Precision can be controlled with the

4
core/math/quaternion.cpp
View File

@ -44,7 +44,7 @@ real_t Quaternion::angle_to(const Quaternion &p_to) const {
// This implementation uses XYZ convention (Z is the first rotation). // This implementation uses XYZ convention (Z is the first rotation).
Vector3 Quaternion::get_euler_xyz() const { Vector3 Quaternion::get_euler_xyz() const {
Basis m(*this); Basis m(*this);
return m.get_euler(Basis::EULER_ORDER_XYZ); return m.get_euler(EulerOrder::XYZ);
} }
// get_euler_yxz returns a vector containing the Euler angles in the format // get_euler_yxz returns a vector containing the Euler angles in the format
@ -56,7 +56,7 @@ Vector3 Quaternion::get_euler_yxz() const {
ERR_FAIL_COND_V_MSG(!is_normalized(), Vector3(0, 0, 0), "The quaternion must be normalized."); ERR_FAIL_COND_V_MSG(!is_normalized(), Vector3(0, 0, 0), "The quaternion must be normalized.");
#endif #endif
Basis m(*this); Basis m(*this);
return m.get_euler(Basis::EULER_ORDER_YXZ); return m.get_euler(EulerOrder::YXZ);
} }
void Quaternion::operator*=(const Quaternion &p_q) { void Quaternion::operator*=(const Quaternion &p_q) {

2
core/variant/binder_common.h
View File

@ -138,7 +138,7 @@ VARIANT_ENUM_CAST(Vector3::Axis);
VARIANT_ENUM_CAST(Vector3i::Axis); VARIANT_ENUM_CAST(Vector3i::Axis);
VARIANT_ENUM_CAST(Vector4::Axis); VARIANT_ENUM_CAST(Vector4::Axis);
VARIANT_ENUM_CAST(Vector4i::Axis); VARIANT_ENUM_CAST(Vector4i::Axis);
VARIANT_ENUM_CAST(Basis::EulerOrder); VARIANT_ENUM_CAST(EulerOrder);
VARIANT_ENUM_CAST(Projection::Planes); VARIANT_ENUM_CAST(Projection::Planes);
VARIANT_ENUM_CAST(Error); VARIANT_ENUM_CAST(Error);

18
core/variant/variant_call.cpp
View File

@ -1927,7 +1927,7 @@ static void _register_variant_builtin_methods() {
bind_methodv(Basis, rotated, static_cast<Basis (Basis::*)(const Vector3 &, real_t) const>(&Basis::rotated), sarray("axis", "angle"), varray()); bind_methodv(Basis, rotated, static_cast<Basis (Basis::*)(const Vector3 &, real_t) const>(&Basis::rotated), sarray("axis", "angle"), varray());
bind_method(Basis, scaled, sarray("scale"), varray()); bind_method(Basis, scaled, sarray("scale"), varray());
bind_method(Basis, get_scale, sarray(), varray()); bind_method(Basis, get_scale, sarray(), varray());
bind_method(Basis, get_euler, sarray("order"), varray((int64_t)Basis::EULER_ORDER_YXZ)); bind_method(Basis, get_euler, sarray("order"), varray((int64_t)EulerOrder::YXZ));
bind_method(Basis, tdotx, sarray("with"), varray()); bind_method(Basis, tdotx, sarray("with"), varray());
bind_method(Basis, tdoty, sarray("with"), varray()); bind_method(Basis, tdoty, sarray("with"), varray());
bind_method(Basis, tdotz, sarray("with"), varray()); bind_method(Basis, tdotz, sarray("with"), varray());
@ -1937,7 +1937,7 @@ static void _register_variant_builtin_methods() {
bind_method(Basis, get_rotation_quaternion, sarray(), varray()); bind_method(Basis, get_rotation_quaternion, sarray(), varray());
bind_static_method(Basis, looking_at, sarray("target", "up"), varray(Vector3(0, 1, 0))); bind_static_method(Basis, looking_at, sarray("target", "up"), varray(Vector3(0, 1, 0)));
bind_static_method(Basis, from_scale, sarray("scale"), varray()); bind_static_method(Basis, from_scale, sarray("scale"), varray());
bind_static_method(Basis, from_euler, sarray("euler", "order"), varray((int64_t)Basis::EULER_ORDER_YXZ)); bind_static_method(Basis, from_euler, sarray("euler", "order"), varray((int64_t)EulerOrder::YXZ));
/* AABB */ /* AABB */
@ -2434,20 +2434,6 @@ static void _register_variant_builtin_methods() {
_VariantCall::add_variant_constant(Variant::VECTOR2I, "UP", Vector2i(0, -1)); _VariantCall::add_variant_constant(Variant::VECTOR2I, "UP", Vector2i(0, -1));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "DOWN", Vector2i(0, 1)); _VariantCall::add_variant_constant(Variant::VECTOR2I, "DOWN", Vector2i(0, 1));
_VariantCall::add_constant(Variant::BASIS, "EULER_ORDER_XYZ", Basis::EULER_ORDER_XYZ);
_VariantCall::add_constant(Variant::BASIS, "EULER_ORDER_XZY", Basis::EULER_ORDER_XZY);
_VariantCall::add_constant(Variant::BASIS, "EULER_ORDER_YXZ", Basis::EULER_ORDER_YXZ);
_VariantCall::add_constant(Variant::BASIS, "EULER_ORDER_YZX", Basis::EULER_ORDER_YZX);
_VariantCall::add_constant(Variant::BASIS, "EULER_ORDER_ZXY", Basis::EULER_ORDER_ZXY);
_VariantCall::add_constant(Variant::BASIS, "EULER_ORDER_ZYX", Basis::EULER_ORDER_ZYX);
_VariantCall::add_enum_constant(Variant::BASIS, "EulerOrder", "EULER_ORDER_XYZ", Basis::EULER_ORDER_XYZ);
_VariantCall::add_enum_constant(Variant::BASIS, "EulerOrder", "EULER_ORDER_XZY", Basis::EULER_ORDER_XZY);
_VariantCall::add_enum_constant(Variant::BASIS, "EulerOrder", "EULER_ORDER_YXZ", Basis::EULER_ORDER_YXZ);
_VariantCall::add_enum_constant(Variant::BASIS, "EulerOrder", "EULER_ORDER_YZX", Basis::EULER_ORDER_YZX);
_VariantCall::add_enum_constant(Variant::BASIS, "EulerOrder", "EULER_ORDER_ZXY", Basis::EULER_ORDER_ZXY);
_VariantCall::add_enum_constant(Variant::BASIS, "EulerOrder", "EULER_ORDER_ZYX", Basis::EULER_ORDER_ZYX);
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "IDENTITY", Transform2D()); _VariantCall::add_variant_constant(Variant::TRANSFORM2D, "IDENTITY", Transform2D());
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_X", Transform2D(-1, 0, 0, 1, 0, 0)); _VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_X", Transform2D(-1, 0, 0, 1, 0, 0));
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_Y", Transform2D(1, 0, 0, -1, 0, 0)); _VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_Y", Transform2D(1, 0, 0, -1, 0, 0));

6
core/variant/variant_internal.h
View File

@ -824,9 +824,9 @@ VARIANT_ACCESSOR_NUMBER(Vector4i::Axis)
VARIANT_ACCESSOR_NUMBER(Projection::Planes) VARIANT_ACCESSOR_NUMBER(Projection::Planes)
template <> template <>
struct VariantInternalAccessor<Basis::EulerOrder> { struct VariantInternalAccessor<EulerOrder> {
static _FORCE_INLINE_ Basis::EulerOrder get(const Variant *v) { return Basis::EulerOrder(*VariantInternal::get_int(v)); } static _FORCE_INLINE_ EulerOrder get(const Variant *v) { return EulerOrder(*VariantInternal::get_int(v)); }
static _FORCE_INLINE_ void set(Variant *v, Basis::EulerOrder p_value) { *VariantInternal::get_int(v) = (int64_t)p_value; } static _FORCE_INLINE_ void set(Variant *v, EulerOrder p_value) { *VariantInternal::get_int(v) = (int64_t)p_value; }
}; };
template <> template <>

18
doc/classes/@GlobalScope.xml
View File

@ -1466,6 +1466,24 @@
<constant name="INLINE_ALIGNMENT_TEXT_MASK" value="12" enum="InlineAlignment"> <constant name="INLINE_ALIGNMENT_TEXT_MASK" value="12" enum="InlineAlignment">
A bit mask for [code]INLINE_ALIGNMENT_TO_*[/code] alignment constants. A bit mask for [code]INLINE_ALIGNMENT_TO_*[/code] alignment constants.
</constant> </constant>
<constant name="EULER_ORDER_XYZ" value="0" enum="EulerOrder">
Specifies that Euler angles should be in XYZ order. When composing, the order is X, Y, Z. When decomposing, the order is reversed, first Z, then Y, and X last.
</constant>
<constant name="EULER_ORDER_XZY" value="1" enum="EulerOrder">
Specifies that Euler angles should be in XZY order. When composing, the order is X, Z, Y. When decomposing, the order is reversed, first Y, then Z, and X last.
</constant>
<constant name="EULER_ORDER_YXZ" value="2" enum="EulerOrder">
Specifies that Euler angles should be in YXZ order. When composing, the order is Y, X, Z. When decomposing, the order is reversed, first Z, then X, and Y last.
</constant>
<constant name="EULER_ORDER_YZX" value="3" enum="EulerOrder">
Specifies that Euler angles should be in YZX order. When composing, the order is Y, Z, X. When decomposing, the order is reversed, first X, then Z, and Y last.
</constant>
<constant name="EULER_ORDER_ZXY" value="4" enum="EulerOrder">
Specifies that Euler angles should be in ZXY order. When composing, the order is Z, X, Y. When decomposing, the order is reversed, first Y, then X, and Z last.
</constant>
<constant name="EULER_ORDER_ZYX" value="5" enum="EulerOrder">
Specifies that Euler angles should be in ZYX order. When composing, the order is Z, Y, X. When decomposing, the order is reversed, first X, then Y, and Z last.
</constant>
<constant name="KEY_NONE" value="0" enum="Key"> <constant name="KEY_NONE" value="0" enum="Key">
Enum value which doesn't correspond to any key. This is used to initialize [enum Key] properties with a generic state. Enum value which doesn't correspond to any key. This is used to initialize [enum Key] properties with a generic state.
</constant> </constant>

20
doc/classes/Basis.xml
View File

@ -70,7 +70,7 @@
<param index="0" name="euler" type="Vector3" /> <param index="0" name="euler" type="Vector3" />
<param index="1" name="order" type="int" default="2" /> <param index="1" name="order" type="int" default="2" />
<description> <description>
Constructs a pure rotation Basis matrix from Euler angles in the specified Euler rotation order. By default, use YXZ order (most common). Constructs a pure rotation Basis matrix from Euler angles in the specified Euler rotation order. By default, use YXZ order (most common). See the [enum EulerOrder] enum for possible values.
</description> </description>
</method> </method>
<method name="from_scale" qualifiers="static"> <method name="from_scale" qualifiers="static">
@ -197,24 +197,6 @@
</member> </member>
</members> </members>
<constants> <constants>
<constant name="EULER_ORDER_XYZ" value="0">
Euler angle composing/decomposing order where X component is first, then Y, then Z.
</constant>
<constant name="EULER_ORDER_XZY" value="1">
Euler angle composing/decomposing order where X component is first, then Z, then Y.
</constant>
<constant name="EULER_ORDER_YXZ" value="2">
Euler angle composing/decomposing order where Y component is first, then X, then Z.
</constant>
<constant name="EULER_ORDER_YZX" value="3">
Euler angle composing/decomposing order where Y component is first, then Z, then X.
</constant>
<constant name="EULER_ORDER_ZXY" value="4">
Euler angle composing/decomposing order where Z component is first, then X, then Y.
</constant>
<constant name="EULER_ORDER_ZYX" value="5">
Euler angle composing/decomposing order where Z component is first, then Y, then X.
</constant>
<constant name="IDENTITY" value="Basis(1, 0, 0, 0, 1, 0, 0, 0, 1)"> <constant name="IDENTITY" value="Basis(1, 0, 0, 0, 1, 0, 0, 0, 1)">
The identity basis, with no rotation or scaling applied. The identity basis, with no rotation or scaling applied.
This is identical to calling [code]Basis()[/code] without any parameters. This constant can be used to make your code clearer, and for consistency with C#. This is identical to calling [code]Basis()[/code] without any parameters. This constant can be used to make your code clearer, and for consistency with C#.

43
modules/mono/glue/GodotSharp/GodotSharp/Core/Basis.cs
View File

@ -3,21 +3,6 @@ using System.Runtime.InteropServices;
namespace Godot namespace Godot
{ {
/// <summary>
/// Specifies which order Euler angle rotations should be in.
/// When composing, the order is the same as the letters. When decomposing,
/// the order is reversed (ex: YXZ decomposes Z first, then X, and Y last).
/// </summary>
public enum EulerOrder
{
XYZ,
XZY,
YXZ,
YZX,
ZXY,
ZYX
};
/// <summary> /// <summary>
/// 3×3 matrix used for 3D rotation and scale. /// 3×3 matrix used for 3D rotation and scale.
/// Almost always used as an orthogonal basis for a Transform. /// Almost always used as an orthogonal basis for a Transform.
@ -270,11 +255,11 @@ namespace Godot
/// </summary> /// </summary>
/// <param name="order">The Euler order to use. By default, use YXZ order (most common).</param> /// <param name="order">The Euler order to use. By default, use YXZ order (most common).</param>
/// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns> /// <returns>A <see cref="Vector3"/> representing the basis rotation in Euler angles.</returns>
public Vector3 GetEuler(EulerOrder order = EulerOrder.YXZ) public Vector3 GetEuler(EulerOrder order = EulerOrder.Yxz)
{ {
switch (order) switch (order)
{ {
case EulerOrder.XYZ: case EulerOrder.Xyz:
{ {
// Euler angles in XYZ convention. // Euler angles in XYZ convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
@ -318,7 +303,7 @@ namespace Godot
} }
return euler; return euler;
} }
case EulerOrder.XZY: case EulerOrder.Xzy:
{ {
// Euler angles in XZY convention. // Euler angles in XZY convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
@ -353,7 +338,7 @@ namespace Godot
} }
return euler; return euler;
} }
case EulerOrder.YXZ: case EulerOrder.Yxz:
{ {
// Euler angles in YXZ convention. // Euler angles in YXZ convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
@ -398,7 +383,7 @@ namespace Godot
return euler; return euler;
} }
case EulerOrder.YZX: case EulerOrder.Yzx:
{ {
// Euler angles in YZX convention. // Euler angles in YZX convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
@ -433,7 +418,7 @@ namespace Godot
} }
return euler; return euler;
} }
case EulerOrder.ZXY: case EulerOrder.Zxy:
{ {
// Euler angles in ZXY convention. // Euler angles in ZXY convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
@ -468,7 +453,7 @@ namespace Godot
} }
return euler; return euler;
} }
case EulerOrder.ZYX: case EulerOrder.Zyx:
{ {
// Euler angles in ZYX convention. // Euler angles in ZYX convention.
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
@ -998,7 +983,7 @@ namespace Godot
/// </summary> /// </summary>
/// <param name="euler">The Euler angles to use.</param> /// <param name="euler">The Euler angles to use.</param>
/// <param name="order">The order to compose the Euler angles.</param> /// <param name="order">The order to compose the Euler angles.</param>
public static Basis FromEuler(Vector3 euler, EulerOrder order = EulerOrder.YXZ) public static Basis FromEuler(Vector3 euler, EulerOrder order = EulerOrder.Yxz)
{ {
real_t c, s; real_t c, s;
@ -1016,17 +1001,17 @@ namespace Godot
switch (order) switch (order)
{ {
case EulerOrder.XYZ: case EulerOrder.Xyz:
return xmat * ymat * zmat; return xmat * ymat * zmat;
case EulerOrder.XZY: case EulerOrder.Xzy:
return xmat * zmat * ymat; return xmat * zmat * ymat;
case EulerOrder.YXZ: case EulerOrder.Yxz:
return ymat * xmat * zmat; return ymat * xmat * zmat;
case EulerOrder.YZX: case EulerOrder.Yzx:
return ymat * zmat * xmat; return ymat * zmat * xmat;
case EulerOrder.ZXY: case EulerOrder.Zxy:
return zmat * xmat * ymat; return zmat * xmat * ymat;
case EulerOrder.ZYX: case EulerOrder.Zyx:
return zmat * ymat * xmat; return zmat * ymat * xmat;
default: default:
throw new ArgumentOutOfRangeException(nameof(order)); throw new ArgumentOutOfRangeException(nameof(order));

2
scene/3d/node_3d.cpp
View File

@ -393,7 +393,7 @@ Node3D::RotationEditMode Node3D::get_rotation_edit_mode() const {
} }
void Node3D::set_rotation_order(RotationOrder p_order) { void Node3D::set_rotation_order(RotationOrder p_order) {
Basis::EulerOrder order = Basis::EulerOrder(p_order); EulerOrder order = EulerOrder(p_order);
if (data.euler_rotation_order == order) { if (data.euler_rotation_order == order) {
return; return;

2
scene/3d/node_3d.h
View File

@ -100,7 +100,7 @@ private:
struct Data { struct Data {
mutable Transform3D global_transform; mutable Transform3D global_transform;
mutable Transform3D local_transform; mutable Transform3D local_transform;
mutable Basis::EulerOrder euler_rotation_order = Basis::EULER_ORDER_YXZ; mutable EulerOrder euler_rotation_order = EulerOrder::YXZ;
mutable Vector3 euler_rotation; mutable Vector3 euler_rotation;
mutable Vector3 scale = Vector3(1, 1, 1); mutable Vector3 scale = Vector3(1, 1, 1);
mutable RotationEditMode rotation_edit_mode = ROTATION_EDIT_MODE_EULER; mutable RotationEditMode rotation_edit_mode = ROTATION_EDIT_MODE_EULER;

4
scene/3d/remote_transform_3d.cpp
View File

@ -68,7 +68,7 @@ void RemoteTransform3D::_update_remote() {
Transform3D our_trans = get_global_transform(); Transform3D our_trans = get_global_transform();
if (update_remote_rotation) { if (update_remote_rotation) {
n->set_rotation(our_trans.basis.get_euler_normalized(Basis::EulerOrder(n->get_rotation_order()))); n->set_rotation(our_trans.basis.get_euler_normalized(EulerOrder(n->get_rotation_order())));
} }
if (update_remote_scale) { if (update_remote_scale) {
@ -90,7 +90,7 @@ void RemoteTransform3D::_update_remote() {
Transform3D our_trans = get_transform(); Transform3D our_trans = get_transform();
if (update_remote_rotation) { if (update_remote_rotation) {
n->set_rotation(our_trans.basis.get_euler_normalized(Basis::EulerOrder(n->get_rotation_order()))); n->set_rotation(our_trans.basis.get_euler_normalized(EulerOrder(n->get_rotation_order())));
} }
if (update_remote_scale) { if (update_remote_scale) {

2
servers/physics_3d/joints/godot_generic_6dof_joint_3d.cpp
View File

@ -232,7 +232,7 @@ GodotGeneric6DOFJoint3D::GodotGeneric6DOFJoint3D(GodotBody3D *rbA, GodotBody3D *
void GodotGeneric6DOFJoint3D::calculateAngleInfo() { void GodotGeneric6DOFJoint3D::calculateAngleInfo() {
Basis relative_frame = m_calculatedTransformB.basis.inverse() * m_calculatedTransformA.basis; Basis relative_frame = m_calculatedTransformB.basis.inverse() * m_calculatedTransformA.basis;
m_calculatedAxisAngleDiff = relative_frame.get_euler(Basis::EULER_ORDER_XYZ); m_calculatedAxisAngleDiff = relative_frame.get_euler(EulerOrder::XYZ);
// in euler angle mode we do not actually constrain the angular velocity // in euler angle mode we do not actually constrain the angular velocity
// along the axes axis[0] and axis[2] (although we do use axis[1]) : // along the axes axis[0] and axis[2] (although we do use axis[1]) :

48
tests/core/math/test_basis.h
View File

@ -46,26 +46,26 @@ Vector3 rad2deg(const Vector3 &p_rotation) {
return p_rotation / Math_PI * 180.0; return p_rotation / Math_PI * 180.0;
} }
String get_rot_order_name(Basis::EulerOrder ro) { String get_rot_order_name(EulerOrder ro) {
switch (ro) { switch (ro) {
case Basis::EULER_ORDER_XYZ: case EulerOrder::XYZ:
return "XYZ"; return "XYZ";
case Basis::EULER_ORDER_XZY: case EulerOrder::XZY:
return "XZY"; return "XZY";
case Basis::EULER_ORDER_YZX: case EulerOrder::YZX:
return "YZX"; return "YZX";
case Basis::EULER_ORDER_YXZ: case EulerOrder::YXZ:
return "YXZ"; return "YXZ";
case Basis::EULER_ORDER_ZXY: case EulerOrder::ZXY:
return "ZXY"; return "ZXY";
case Basis::EULER_ORDER_ZYX: case EulerOrder::ZYX:
return "ZYX"; return "ZYX";
default: default:
return "[Not supported]"; return "[Not supported]";
} }
} }
void test_rotation(Vector3 deg_original_euler, Basis::EulerOrder rot_order) { void test_rotation(Vector3 deg_original_euler, EulerOrder rot_order) {
// This test: // This test:
// 1. Converts the rotation vector from deg to rad. // 1. Converts the rotation vector from deg to rad.
// 2. Converts euler to basis. // 2. Converts euler to basis.
@ -98,8 +98,8 @@ void test_rotation(Vector3 deg_original_euler, Basis::EulerOrder rot_order) {
CHECK_MESSAGE((res.get_column(2) - Vector3(0.0, 0.0, 1.0)).length() <= 0.1, vformat("Fail due to Z %s\n", String(res.get_column(2))).utf8().ptr()); CHECK_MESSAGE((res.get_column(2) - Vector3(0.0, 0.0, 1.0)).length() <= 0.1, vformat("Fail due to Z %s\n", String(res.get_column(2))).utf8().ptr());
// Double check `to_rotation` decomposing with XYZ rotation order. // Double check `to_rotation` decomposing with XYZ rotation order.
const Vector3 euler_xyz_from_rotation = to_rotation.get_euler(Basis::EULER_ORDER_XYZ); const Vector3 euler_xyz_from_rotation = to_rotation.get_euler(EulerOrder::XYZ);
Basis rotation_from_xyz_computed_euler = Basis::from_euler(euler_xyz_from_rotation, Basis::EULER_ORDER_XYZ); Basis rotation_from_xyz_computed_euler = Basis::from_euler(euler_xyz_from_rotation, EulerOrder::XYZ);
res = to_rotation.inverse() * rotation_from_xyz_computed_euler; res = to_rotation.inverse() * rotation_from_xyz_computed_euler;
@ -113,13 +113,13 @@ void test_rotation(Vector3 deg_original_euler, Basis::EulerOrder rot_order) {
} }
TEST_CASE("[Basis] Euler conversions") { TEST_CASE("[Basis] Euler conversions") {
Vector<Basis::EulerOrder> euler_order_to_test; Vector<EulerOrder> euler_order_to_test;
euler_order_to_test.push_back(Basis::EULER_ORDER_XYZ); euler_order_to_test.push_back(EulerOrder::XYZ);
euler_order_to_test.push_back(Basis::EULER_ORDER_XZY); euler_order_to_test.push_back(EulerOrder::XZY);
euler_order_to_test.push_back(Basis::EULER_ORDER_YZX); euler_order_to_test.push_back(EulerOrder::YZX);
euler_order_to_test.push_back(Basis::EULER_ORDER_YXZ); euler_order_to_test.push_back(EulerOrder::YXZ);
euler_order_to_test.push_back(Basis::EULER_ORDER_ZXY); euler_order_to_test.push_back(EulerOrder::ZXY);
euler_order_to_test.push_back(Basis::EULER_ORDER_ZYX); euler_order_to_test.push_back(EulerOrder::ZYX);
Vector<Vector3> vectors_to_test; Vector<Vector3> vectors_to_test;
@ -185,13 +185,13 @@ TEST_CASE("[Basis] Euler conversions") {
} }
TEST_CASE("[Stress][Basis] Euler conversions") { TEST_CASE("[Stress][Basis] Euler conversions") {
Vector<Basis::EulerOrder> euler_order_to_test; Vector<EulerOrder> euler_order_to_test;
euler_order_to_test.push_back(Basis::EULER_ORDER_XYZ); euler_order_to_test.push_back(EulerOrder::XYZ);
euler_order_to_test.push_back(Basis::EULER_ORDER_XZY); euler_order_to_test.push_back(EulerOrder::XZY);
euler_order_to_test.push_back(Basis::EULER_ORDER_YZX); euler_order_to_test.push_back(EulerOrder::YZX);
euler_order_to_test.push_back(Basis::EULER_ORDER_YXZ); euler_order_to_test.push_back(EulerOrder::YXZ);
euler_order_to_test.push_back(Basis::EULER_ORDER_ZXY); euler_order_to_test.push_back(EulerOrder::ZXY);
euler_order_to_test.push_back(Basis::EULER_ORDER_ZYX); euler_order_to_test.push_back(EulerOrder::ZYX);
Vector<Vector3> vectors_to_test; Vector<Vector3> vectors_to_test;
// Add 1000 random vectors with weirds numbers. // Add 1000 random vectors with weirds numbers.