mirror of
https://github.com/godotengine/godot
synced 2024-09-05 18:29:41 +00:00
Move EulerOrder enum to math_defs.h and global scope
This commit is contained in:
parent
39cece382d
commit
8556fdd4bc
|
@ -167,6 +167,13 @@ void register_global_constants() {
|
|||
BIND_CORE_ENUM_CONSTANT(INLINE_ALIGNMENT_IMAGE_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, SPECIAL);
|
||||
BIND_CORE_ENUM_CLASS_CONSTANT(Key, KEY, ESCAPE);
|
||||
|
|
|
@ -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 {
|
||||
switch (p_order) {
|
||||
case EULER_ORDER_XYZ: {
|
||||
case EulerOrder::XYZ: {
|
||||
// Euler angles in XYZ convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
@ -488,7 +488,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
|
|||
}
|
||||
return euler;
|
||||
} break;
|
||||
case EULER_ORDER_XZY: {
|
||||
case EulerOrder::XZY: {
|
||||
// Euler angles in XZY convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
@ -517,7 +517,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
|
|||
}
|
||||
return euler;
|
||||
} break;
|
||||
case EULER_ORDER_YXZ: {
|
||||
case EulerOrder::YXZ: {
|
||||
// Euler angles in YXZ convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
@ -555,7 +555,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
|
|||
|
||||
return euler;
|
||||
} break;
|
||||
case EULER_ORDER_YZX: {
|
||||
case EulerOrder::YZX: {
|
||||
// Euler angles in YZX convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
@ -584,7 +584,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
|
|||
}
|
||||
return euler;
|
||||
} break;
|
||||
case EULER_ORDER_ZXY: {
|
||||
case EulerOrder::ZXY: {
|
||||
// Euler angles in ZXY convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
//
|
||||
|
@ -612,7 +612,7 @@ Vector3 Basis::get_euler(EulerOrder p_order) const {
|
|||
}
|
||||
return euler;
|
||||
} break;
|
||||
case EULER_ORDER_ZYX: {
|
||||
case EulerOrder::ZYX: {
|
||||
// Euler angles in ZYX convention.
|
||||
// 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);
|
||||
|
||||
switch (p_order) {
|
||||
case EULER_ORDER_XYZ: {
|
||||
case EulerOrder::XYZ: {
|
||||
*this = xmat * (ymat * zmat);
|
||||
} break;
|
||||
case EULER_ORDER_XZY: {
|
||||
case EulerOrder::XZY: {
|
||||
*this = xmat * zmat * ymat;
|
||||
} break;
|
||||
case EULER_ORDER_YXZ: {
|
||||
case EulerOrder::YXZ: {
|
||||
*this = ymat * xmat * zmat;
|
||||
} break;
|
||||
case EULER_ORDER_YZX: {
|
||||
case EulerOrder::YZX: {
|
||||
*this = ymat * zmat * xmat;
|
||||
} break;
|
||||
case EULER_ORDER_ZXY: {
|
||||
case EulerOrder::ZXY: {
|
||||
*this = zmat * xmat * ymat;
|
||||
} break;
|
||||
case EULER_ORDER_ZYX: {
|
||||
case EulerOrder::ZYX: {
|
||||
*this = zmat * ymat * xmat;
|
||||
} break;
|
||||
default: {
|
||||
|
|
|
@ -56,15 +56,6 @@ struct _NO_DISCARD_ Basis {
|
|||
|
||||
_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 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);
|
||||
Basis rotated_local(const Vector3 &p_axis, real_t p_angle) const;
|
||||
|
||||
void rotate(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ);
|
||||
Basis rotated(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ) const;
|
||||
void rotate(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ);
|
||||
Basis rotated(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ) const;
|
||||
|
||||
void rotate(const Quaternion &p_quaternion);
|
||||
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_local(Vector3 &p_axis, real_t &p_angle) const;
|
||||
Quaternion get_rotation_quaternion() const;
|
||||
|
@ -88,9 +79,9 @@ struct _NO_DISCARD_ Basis {
|
|||
|
||||
Vector3 rotref_posscale_decomposition(Basis &rotref) const;
|
||||
|
||||
Vector3 get_euler(EulerOrder p_order = EULER_ORDER_YXZ) const;
|
||||
void set_euler(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ);
|
||||
static Basis from_euler(const Vector3 &p_euler, EulerOrder p_order = EULER_ORDER_YXZ) {
|
||||
Vector3 get_euler(EulerOrder p_order = EulerOrder::YXZ) const;
|
||||
void set_euler(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ);
|
||||
static Basis from_euler(const Vector3 &p_euler, EulerOrder p_order = EulerOrder::YXZ) {
|
||||
Basis b;
|
||||
b.set_euler(p_euler, p_order);
|
||||
return b;
|
||||
|
@ -119,7 +110,7 @@ struct _NO_DISCARD_ Basis {
|
|||
Vector3 get_scale_local() const;
|
||||
|
||||
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);
|
||||
|
||||
// transposed dot products
|
||||
|
|
|
@ -116,6 +116,15 @@ enum Corner {
|
|||
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,
|
||||
* in contrast to integer numbers. Precision can be controlled with the
|
||||
|
|
|
@ -44,7 +44,7 @@ real_t Quaternion::angle_to(const Quaternion &p_to) const {
|
|||
// This implementation uses XYZ convention (Z is the first rotation).
|
||||
Vector3 Quaternion::get_euler_xyz() const {
|
||||
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
|
||||
|
@ -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.");
|
||||
#endif
|
||||
Basis m(*this);
|
||||
return m.get_euler(Basis::EULER_ORDER_YXZ);
|
||||
return m.get_euler(EulerOrder::YXZ);
|
||||
}
|
||||
|
||||
void Quaternion::operator*=(const Quaternion &p_q) {
|
||||
|
|
|
@ -138,7 +138,7 @@ VARIANT_ENUM_CAST(Vector3::Axis);
|
|||
VARIANT_ENUM_CAST(Vector3i::Axis);
|
||||
VARIANT_ENUM_CAST(Vector4::Axis);
|
||||
VARIANT_ENUM_CAST(Vector4i::Axis);
|
||||
VARIANT_ENUM_CAST(Basis::EulerOrder);
|
||||
VARIANT_ENUM_CAST(EulerOrder);
|
||||
VARIANT_ENUM_CAST(Projection::Planes);
|
||||
|
||||
VARIANT_ENUM_CAST(Error);
|
||||
|
|
|
@ -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_method(Basis, scaled, sarray("scale"), 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, tdoty, 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_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_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 */
|
||||
|
||||
|
@ -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, "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, "FLIP_X", Transform2D(-1, 0, 0, 1, 0, 0));
|
||||
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_Y", Transform2D(1, 0, 0, -1, 0, 0));
|
||||
|
|
|
@ -824,9 +824,9 @@ VARIANT_ACCESSOR_NUMBER(Vector4i::Axis)
|
|||
VARIANT_ACCESSOR_NUMBER(Projection::Planes)
|
||||
|
||||
template <>
|
||||
struct VariantInternalAccessor<Basis::EulerOrder> {
|
||||
static _FORCE_INLINE_ Basis::EulerOrder get(const Variant *v) { return Basis::EulerOrder(*VariantInternal::get_int(v)); }
|
||||
static _FORCE_INLINE_ void set(Variant *v, Basis::EulerOrder p_value) { *VariantInternal::get_int(v) = (int64_t)p_value; }
|
||||
struct VariantInternalAccessor<EulerOrder> {
|
||||
static _FORCE_INLINE_ EulerOrder get(const Variant *v) { return EulerOrder(*VariantInternal::get_int(v)); }
|
||||
static _FORCE_INLINE_ void set(Variant *v, EulerOrder p_value) { *VariantInternal::get_int(v) = (int64_t)p_value; }
|
||||
};
|
||||
|
||||
template <>
|
||||
|
|
|
@ -1465,6 +1465,24 @@
|
|||
<constant name="INLINE_ALIGNMENT_TEXT_MASK" value="12" enum="InlineAlignment">
|
||||
A bit mask for [code]INLINE_ALIGNMENT_TO_*[/code] alignment constants.
|
||||
</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">
|
||||
Enum value which doesn't correspond to any key. This is used to initialize [enum Key] properties with a generic state.
|
||||
</constant>
|
||||
|
|
|
@ -70,7 +70,7 @@
|
|||
<param index="0" name="euler" type="Vector3" />
|
||||
<param index="1" name="order" type="int" default="2" />
|
||||
<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>
|
||||
</method>
|
||||
<method name="from_scale" qualifiers="static">
|
||||
|
@ -197,24 +197,6 @@
|
|||
</member>
|
||||
</members>
|
||||
<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)">
|
||||
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#.
|
||||
|
|
|
@ -3,21 +3,6 @@ using System.Runtime.InteropServices;
|
|||
|
||||
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>
|
||||
/// 3×3 matrix used for 3D rotation and scale.
|
||||
/// Almost always used as an orthogonal basis for a Transform.
|
||||
|
@ -270,11 +255,11 @@ namespace Godot
|
|||
/// </summary>
|
||||
/// <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>
|
||||
public Vector3 GetEuler(EulerOrder order = EulerOrder.YXZ)
|
||||
public Vector3 GetEuler(EulerOrder order = EulerOrder.Yxz)
|
||||
{
|
||||
switch (order)
|
||||
{
|
||||
case EulerOrder.XYZ:
|
||||
case EulerOrder.Xyz:
|
||||
{
|
||||
// Euler angles in XYZ convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
|
@ -318,7 +303,7 @@ namespace Godot
|
|||
}
|
||||
return euler;
|
||||
}
|
||||
case EulerOrder.XZY:
|
||||
case EulerOrder.Xzy:
|
||||
{
|
||||
// Euler angles in XZY convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
|
@ -353,7 +338,7 @@ namespace Godot
|
|||
}
|
||||
return euler;
|
||||
}
|
||||
case EulerOrder.YXZ:
|
||||
case EulerOrder.Yxz:
|
||||
{
|
||||
// Euler angles in YXZ convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
|
@ -398,7 +383,7 @@ namespace Godot
|
|||
|
||||
return euler;
|
||||
}
|
||||
case EulerOrder.YZX:
|
||||
case EulerOrder.Yzx:
|
||||
{
|
||||
// Euler angles in YZX convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
|
@ -433,7 +418,7 @@ namespace Godot
|
|||
}
|
||||
return euler;
|
||||
}
|
||||
case EulerOrder.ZXY:
|
||||
case EulerOrder.Zxy:
|
||||
{
|
||||
// Euler angles in ZXY convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
|
@ -468,7 +453,7 @@ namespace Godot
|
|||
}
|
||||
return euler;
|
||||
}
|
||||
case EulerOrder.ZYX:
|
||||
case EulerOrder.Zyx:
|
||||
{
|
||||
// Euler angles in ZYX convention.
|
||||
// See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
|
||||
|
@ -998,7 +983,7 @@ namespace Godot
|
|||
/// </summary>
|
||||
/// <param name="euler">The Euler angles to use.</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;
|
||||
|
||||
|
@ -1016,17 +1001,17 @@ namespace Godot
|
|||
|
||||
switch (order)
|
||||
{
|
||||
case EulerOrder.XYZ:
|
||||
case EulerOrder.Xyz:
|
||||
return xmat * ymat * zmat;
|
||||
case EulerOrder.XZY:
|
||||
case EulerOrder.Xzy:
|
||||
return xmat * zmat * ymat;
|
||||
case EulerOrder.YXZ:
|
||||
case EulerOrder.Yxz:
|
||||
return ymat * xmat * zmat;
|
||||
case EulerOrder.YZX:
|
||||
case EulerOrder.Yzx:
|
||||
return ymat * zmat * xmat;
|
||||
case EulerOrder.ZXY:
|
||||
case EulerOrder.Zxy:
|
||||
return zmat * xmat * ymat;
|
||||
case EulerOrder.ZYX:
|
||||
case EulerOrder.Zyx:
|
||||
return zmat * ymat * xmat;
|
||||
default:
|
||||
throw new ArgumentOutOfRangeException(nameof(order));
|
||||
|
|
|
@ -393,7 +393,7 @@ Node3D::RotationEditMode Node3D::get_rotation_edit_mode() const {
|
|||
}
|
||||
|
||||
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) {
|
||||
return;
|
||||
|
|
|
@ -100,7 +100,7 @@ private:
|
|||
struct Data {
|
||||
mutable Transform3D global_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 scale = Vector3(1, 1, 1);
|
||||
mutable RotationEditMode rotation_edit_mode = ROTATION_EDIT_MODE_EULER;
|
||||
|
|
|
@ -68,7 +68,7 @@ void RemoteTransform3D::_update_remote() {
|
|||
Transform3D our_trans = get_global_transform();
|
||||
|
||||
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) {
|
||||
|
@ -90,7 +90,7 @@ void RemoteTransform3D::_update_remote() {
|
|||
Transform3D our_trans = get_transform();
|
||||
|
||||
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) {
|
||||
|
|
|
@ -232,7 +232,7 @@ GodotGeneric6DOFJoint3D::GodotGeneric6DOFJoint3D(GodotBody3D *rbA, GodotBody3D *
|
|||
void GodotGeneric6DOFJoint3D::calculateAngleInfo() {
|
||||
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
|
||||
// along the axes axis[0] and axis[2] (although we do use axis[1]) :
|
||||
|
|
|
@ -46,26 +46,26 @@ Vector3 rad2deg(const Vector3 &p_rotation) {
|
|||
return p_rotation / Math_PI * 180.0;
|
||||
}
|
||||
|
||||
String get_rot_order_name(Basis::EulerOrder ro) {
|
||||
String get_rot_order_name(EulerOrder ro) {
|
||||
switch (ro) {
|
||||
case Basis::EULER_ORDER_XYZ:
|
||||
case EulerOrder::XYZ:
|
||||
return "XYZ";
|
||||
case Basis::EULER_ORDER_XZY:
|
||||
case EulerOrder::XZY:
|
||||
return "XZY";
|
||||
case Basis::EULER_ORDER_YZX:
|
||||
case EulerOrder::YZX:
|
||||
return "YZX";
|
||||
case Basis::EULER_ORDER_YXZ:
|
||||
case EulerOrder::YXZ:
|
||||
return "YXZ";
|
||||
case Basis::EULER_ORDER_ZXY:
|
||||
case EulerOrder::ZXY:
|
||||
return "ZXY";
|
||||
case Basis::EULER_ORDER_ZYX:
|
||||
case EulerOrder::ZYX:
|
||||
return "ZYX";
|
||||
default:
|
||||
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:
|
||||
// 1. Converts the rotation vector from deg to rad.
|
||||
// 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());
|
||||
|
||||
// Double check `to_rotation` decomposing with XYZ rotation order.
|
||||
const Vector3 euler_xyz_from_rotation = to_rotation.get_euler(Basis::EULER_ORDER_XYZ);
|
||||
Basis rotation_from_xyz_computed_euler = Basis::from_euler(euler_xyz_from_rotation, 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, EulerOrder::XYZ);
|
||||
|
||||
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") {
|
||||
Vector<Basis::EulerOrder> euler_order_to_test;
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_XYZ);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_XZY);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_YZX);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_YXZ);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_ZXY);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_ZYX);
|
||||
Vector<EulerOrder> euler_order_to_test;
|
||||
euler_order_to_test.push_back(EulerOrder::XYZ);
|
||||
euler_order_to_test.push_back(EulerOrder::XZY);
|
||||
euler_order_to_test.push_back(EulerOrder::YZX);
|
||||
euler_order_to_test.push_back(EulerOrder::YXZ);
|
||||
euler_order_to_test.push_back(EulerOrder::ZXY);
|
||||
euler_order_to_test.push_back(EulerOrder::ZYX);
|
||||
|
||||
Vector<Vector3> vectors_to_test;
|
||||
|
||||
|
@ -185,13 +185,13 @@ TEST_CASE("[Basis] Euler conversions") {
|
|||
}
|
||||
|
||||
TEST_CASE("[Stress][Basis] Euler conversions") {
|
||||
Vector<Basis::EulerOrder> euler_order_to_test;
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_XYZ);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_XZY);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_YZX);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_YXZ);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_ZXY);
|
||||
euler_order_to_test.push_back(Basis::EULER_ORDER_ZYX);
|
||||
Vector<EulerOrder> euler_order_to_test;
|
||||
euler_order_to_test.push_back(EulerOrder::XYZ);
|
||||
euler_order_to_test.push_back(EulerOrder::XZY);
|
||||
euler_order_to_test.push_back(EulerOrder::YZX);
|
||||
euler_order_to_test.push_back(EulerOrder::YXZ);
|
||||
euler_order_to_test.push_back(EulerOrder::ZXY);
|
||||
euler_order_to_test.push_back(EulerOrder::ZYX);
|
||||
|
||||
Vector<Vector3> vectors_to_test;
|
||||
// Add 1000 random vectors with weirds numbers.
|
||||
|
|
Loading…
Reference in a new issue