:github_url: hide .. DO NOT EDIT THIS FILE!!! .. Generated automatically from Godot engine sources. .. Generator: https://github.com/godotengine/godot/tree/4.1/doc/tools/make_rst.py. .. XML source: https://github.com/godotengine/godot/tree/4.1/doc/classes/Quaternion.xml. .. _class_Quaternion: Quaternion ========== A unit quaternion used for representing 3D rotations. .. rst-class:: classref-introduction-group Description ----------- The **Quaternion** built-in :ref:`Variant` type is a 4D data structure that represents rotation in the form of a `Hamilton convention quaternion `__. Compared to the :ref:`Basis` type which can store both rotation and scale, quaternions can *only* store rotation. A **Quaternion** is composed by 4 floating-point components: :ref:`w`, :ref:`x`, :ref:`y`, and :ref:`z`. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as :ref:`get_angle`, :ref:`get_axis`, and :ref:`slerp` are faster than their :ref:`Basis` counterparts. For a great introduction to quaternions, see `this video by 3Blue1Brown `__. You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include :ref:`slerp` and :ref:`spherical_cubic_interpolate`, as well as the ``*`` operator. \ **Note:** Quaternions must be normalized before being used for rotation (see :ref:`normalized`). \ **Note:** Similarly to :ref:`Vector2` and :ref:`Vector3`, the components of a quaternion use 32-bit precision by default, unlike :ref:`float` which is always 64-bit. If double precision is needed, compile the engine with the option ``precision=double``. .. rst-class:: classref-introduction-group Tutorials --------- - `3Blue1Brown's video on Quaternions `__ - `Online Quaternion Visualization `__ - `Using 3D transforms <../tutorials/3d/using_transforms.html#interpolating-with-quaternions>`__ - `Third Person Shooter Demo `__ - `Advanced Quaternion Visualization `__ .. rst-class:: classref-reftable-group Properties ---------- .. table:: :widths: auto +---------------------------+---------------------------------------+---------+ | :ref:`float` | :ref:`w` | ``1.0`` | +---------------------------+---------------------------------------+---------+ | :ref:`float` | :ref:`x` | ``0.0`` | +---------------------------+---------------------------------------+---------+ | :ref:`float` | :ref:`y` | ``0.0`` | +---------------------------+---------------------------------------+---------+ | :ref:`float` | :ref:`z` | ``0.0`` | +---------------------------+---------------------------------------+---------+ .. rst-class:: classref-reftable-group Constructors ------------ .. table:: :widths: auto +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`Quaternion` **(** **)** | +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`Quaternion` **(** :ref:`Quaternion` from **)** | +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`Quaternion` **(** :ref:`Vector3` arc_from, :ref:`Vector3` arc_to **)** | +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`Quaternion` **(** :ref:`Vector3` axis, :ref:`float` angle **)** | +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`Quaternion` **(** :ref:`Basis` from **)** | +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`Quaternion` **(** :ref:`float` x, :ref:`float` y, :ref:`float` z, :ref:`float` w **)** | +-------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Methods ------- .. table:: :widths: auto +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`angle_to` **(** :ref:`Quaternion` to **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`dot` **(** :ref:`Quaternion` with **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`exp` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`from_euler` **(** :ref:`Vector3` euler **)** |static| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`get_angle` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector3` | :ref:`get_axis` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector3` | :ref:`get_euler` **(** :ref:`int` order=2 **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`inverse` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_equal_approx` **(** :ref:`Quaternion` to **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_finite` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_normalized` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`length` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`length_squared` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`log` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`normalized` **(** **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`slerp` **(** :ref:`Quaternion` to, :ref:`float` weight **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`slerpni` **(** :ref:`Quaternion` to, :ref:`float` weight **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`spherical_cubic_interpolate` **(** :ref:`Quaternion` b, :ref:`Quaternion` pre_a, :ref:`Quaternion` post_b, :ref:`float` weight **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`spherical_cubic_interpolate_in_time` **(** :ref:`Quaternion` b, :ref:`Quaternion` pre_a, :ref:`Quaternion` post_b, :ref:`float` weight, :ref:`float` b_t, :ref:`float` pre_a_t, :ref:`float` post_b_t **)** |const| | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Operators --------- .. table:: :widths: auto +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=` **(** :ref:`Quaternion` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator *` **(** :ref:`Quaternion` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Vector3` | :ref:`operator *` **(** :ref:`Vector3` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator *` **(** :ref:`float` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator *` **(** :ref:`int` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator +` **(** :ref:`Quaternion` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator -` **(** :ref:`Quaternion` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator /` **(** :ref:`float` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator /` **(** :ref:`int` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==` **(** :ref:`Quaternion` right **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`operator []` **(** :ref:`int` index **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator unary+` **(** **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ | :ref:`Quaternion` | :ref:`operator unary-` **(** **)** | +-------------------------------------+--------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Constants --------- .. _class_Quaternion_constant_IDENTITY: .. rst-class:: classref-constant **IDENTITY** = ``Quaternion(0, 0, 0, 1)`` The identity quaternion, representing no rotation. This has the same rotation as :ref:`Basis.IDENTITY`. If a :ref:`Vector3` is rotated (multiplied) by this quaternion, it does not change. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Property Descriptions --------------------- .. _class_Quaternion_property_w: .. rst-class:: classref-property :ref:`float` **w** = ``1.0`` W component of the quaternion. This is the "real" part. \ **Note:** Quaternion components should usually not be manipulated directly. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_property_x: .. rst-class:: classref-property :ref:`float` **x** = ``0.0`` X component of the quaternion. This is the value along the "imaginary" ``i`` axis. \ **Note:** Quaternion components should usually not be manipulated directly. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_property_y: .. rst-class:: classref-property :ref:`float` **y** = ``0.0`` Y component of the quaternion. This is the value along the "imaginary" ``j`` axis. \ **Note:** Quaternion components should usually not be manipulated directly. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_property_z: .. rst-class:: classref-property :ref:`float` **z** = ``0.0`` Z component of the quaternion. This is the value along the "imaginary" ``k`` axis. \ **Note:** Quaternion components should usually not be manipulated directly. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Constructor Descriptions ------------------------ .. _class_Quaternion_constructor_Quaternion: .. rst-class:: classref-constructor :ref:`Quaternion` **Quaternion** **(** **)** Constructs a **Quaternion** identical to the :ref:`IDENTITY`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Quaternion` **Quaternion** **(** :ref:`Quaternion` from **)** Constructs a **Quaternion** as a copy of the given **Quaternion**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Quaternion` **Quaternion** **(** :ref:`Vector3` arc_from, :ref:`Vector3` arc_to **)** Constructs a **Quaternion** representing the shortest arc between ``arc_from`` and ``arc_to``. These can be imagined as two points intersecting a sphere's surface, with a radius of ``1.0``. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Quaternion` **Quaternion** **(** :ref:`Vector3` axis, :ref:`float` angle **)** Constructs a **Quaternion** representing rotation around the ``axis`` by the given ``angle``, in radians. The axis must be a normalized vector. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Quaternion` **Quaternion** **(** :ref:`Basis` from **)** Constructs a **Quaternion** from the given rotation :ref:`Basis`. This constructor is faster than :ref:`Basis.get_rotation_quaternion`, but the given basis must be *orthonormalized* (see :ref:`Basis.orthonormalized`). Otherwise, the constructor fails and returns :ref:`IDENTITY`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Quaternion` **Quaternion** **(** :ref:`float` x, :ref:`float` y, :ref:`float` z, :ref:`float` w **)** Constructs a **Quaternion** defined by the given values. \ **Note:** Only normalized quaternions represent rotation; if these values are not normalized, the new **Quaternion** will not be a valid rotation. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Method Descriptions ------------------- .. _class_Quaternion_method_angle_to: .. rst-class:: classref-method :ref:`float` **angle_to** **(** :ref:`Quaternion` to **)** |const| Returns the angle between this quaternion and ``to``. This is the magnitude of the angle you would need to rotate by to get from one to the other. \ **Note:** The magnitude of the floating-point error for this method is abnormally high, so methods such as ``is_zero_approx`` will not work reliably. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_dot: .. rst-class:: classref-method :ref:`float` **dot** **(** :ref:`Quaternion` with **)** |const| Returns the dot product between this quaternion and ``with``. This is equivalent to ``(quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)``. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_exp: .. rst-class:: classref-method :ref:`Quaternion` **exp** **(** **)** |const| .. container:: contribute There is currently no description for this method. Please help us by :ref:`contributing one `! .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_from_euler: .. rst-class:: classref-method :ref:`Quaternion` **from_euler** **(** :ref:`Vector3` euler **)** |static| Constructs a new **Quaternion** from the given :ref:`Vector3` of `Euler angles `__, in radians. This method always uses the YXZ convention (:ref:`@GlobalScope.EULER_ORDER_YXZ`). .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_get_angle: .. rst-class:: classref-method :ref:`float` **get_angle** **(** **)** |const| .. container:: contribute There is currently no description for this method. Please help us by :ref:`contributing one `! .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_get_axis: .. rst-class:: classref-method :ref:`Vector3` **get_axis** **(** **)** |const| .. container:: contribute There is currently no description for this method. Please help us by :ref:`contributing one `! .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_get_euler: .. rst-class:: classref-method :ref:`Vector3` **get_euler** **(** :ref:`int` order=2 **)** |const| Returns this quaternion's rotation as a :ref:`Vector3` of `Euler angles `__, in radians. The order of each consecutive rotation can be changed with ``order`` (see :ref:`EulerOrder` constants). By default, the YXZ convention is used (:ref:`@GlobalScope.EULER_ORDER_YXZ`): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method :ref:`from_euler`, this order is reversed. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_inverse: .. rst-class:: classref-method :ref:`Quaternion` **inverse** **(** **)** |const| Returns the inverse version of this quaternion, inverting the sign of every component except :ref:`w`. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_is_equal_approx: .. rst-class:: classref-method :ref:`bool` **is_equal_approx** **(** :ref:`Quaternion` to **)** |const| Returns ``true`` if this quaternion and ``to`` are approximately equal, by running :ref:`@GlobalScope.is_equal_approx` on each component. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_is_finite: .. rst-class:: classref-method :ref:`bool` **is_finite** **(** **)** |const| Returns ``true`` if this quaternion is finite, by calling :ref:`@GlobalScope.is_finite` on each component. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_is_normalized: .. rst-class:: classref-method :ref:`bool` **is_normalized** **(** **)** |const| Returns ``true`` if this quaternion is normalized. See also :ref:`normalized`. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_length: .. rst-class:: classref-method :ref:`float` **length** **(** **)** |const| Returns this quaternion's length, also called magnitude. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_length_squared: .. rst-class:: classref-method :ref:`float` **length_squared** **(** **)** |const| Returns this quaternion's length, squared. \ **Note:** This method is faster than :ref:`length`, so prefer it if you only need to compare quaternion lengths. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_log: .. rst-class:: classref-method :ref:`Quaternion` **log** **(** **)** |const| Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part (:ref:`x`, :ref:`y`, and :ref:`z`). The returned quaternion's real part (:ref:`w`) is always ``0.0``. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_normalized: .. rst-class:: classref-method :ref:`Quaternion` **normalized** **(** **)** |const| Returns a copy of this quaternion, normalized so that its length is ``1.0``. See also :ref:`is_normalized`. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_slerp: .. rst-class:: classref-method :ref:`Quaternion` **slerp** **(** :ref:`Quaternion` to, :ref:`float` weight **)** |const| Performs a spherical-linear interpolation with the ``to`` quaternion, given a ``weight`` and returns the result. Both this quaternion and ``to`` must be normalized. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_slerpni: .. rst-class:: classref-method :ref:`Quaternion` **slerpni** **(** :ref:`Quaternion` to, :ref:`float` weight **)** |const| Performs a spherical-linear interpolation with the ``to`` quaternion, given a ``weight`` and returns the result. Unlike :ref:`slerp`, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and ``to`` must be normalized. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_spherical_cubic_interpolate: .. rst-class:: classref-method :ref:`Quaternion` **spherical_cubic_interpolate** **(** :ref:`Quaternion` b, :ref:`Quaternion` pre_a, :ref:`Quaternion` post_b, :ref:`float` weight **)** |const| Performs a spherical cubic interpolation between quaternions ``pre_a``, this vector, ``b``, and ``post_b``, by the given amount ``weight``. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_method_spherical_cubic_interpolate_in_time: .. rst-class:: classref-method :ref:`Quaternion` **spherical_cubic_interpolate_in_time** **(** :ref:`Quaternion` b, :ref:`Quaternion` pre_a, :ref:`Quaternion` post_b, :ref:`float` weight, :ref:`float` b_t, :ref:`float` pre_a_t, :ref:`float` post_b_t **)** |const| Performs a spherical cubic interpolation between quaternions ``pre_a``, this vector, ``b``, and ``post_b``, by the given amount ``weight``. It can perform smoother interpolation than ``spherical_cubic_interpolate()`` by the time values. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Operator Descriptions --------------------- .. _class_Quaternion_operator_neq_Quaternion: .. rst-class:: classref-operator :ref:`bool` **operator !=** **(** :ref:`Quaternion` right **)** Returns ``true`` if the components of both quaternions are not exactly equal. \ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx` instead, which is more reliable. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_mul_Quaternion: .. rst-class:: classref-operator :ref:`Quaternion` **operator *** **(** :ref:`Quaternion` right **)** Composes (multiplies) two quaternions. This rotates the ``right`` quaternion (the child) by this quaternion (the parent). .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_mul_Vector3: .. rst-class:: classref-operator :ref:`Vector3` **operator *** **(** :ref:`Vector3` right **)** Rotates (multiplies) the ``right`` vector by this quaternion, returning a :ref:`Vector3`. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_mul_float: .. rst-class:: classref-operator :ref:`Quaternion` **operator *** **(** :ref:`float` right **)** Multiplies each component of the **Quaternion** by the right :ref:`float` value. This operation is not meaningful on its own, but it can be used as a part of a larger expression. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_mul_int: .. rst-class:: classref-operator :ref:`Quaternion` **operator *** **(** :ref:`int` right **)** Multiplies each component of the **Quaternion** by the right :ref:`int` value. This operation is not meaningful on its own, but it can be used as a part of a larger expression. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_sum_Quaternion: .. rst-class:: classref-operator :ref:`Quaternion` **operator +** **(** :ref:`Quaternion` right **)** Adds each component of the left **Quaternion** to the right **Quaternion**. This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_dif_Quaternion: .. rst-class:: classref-operator :ref:`Quaternion` **operator -** **(** :ref:`Quaternion` right **)** Subtracts each component of the left **Quaternion** by the right **Quaternion**. This operation is not meaningful on its own, but it can be used as a part of a larger expression. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_div_float: .. rst-class:: classref-operator :ref:`Quaternion` **operator /** **(** :ref:`float` right **)** Divides each component of the **Quaternion** by the right :ref:`float` value. This operation is not meaningful on its own, but it can be used as a part of a larger expression. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_div_int: .. rst-class:: classref-operator :ref:`Quaternion` **operator /** **(** :ref:`int` right **)** Divides each component of the **Quaternion** by the right :ref:`int` value. This operation is not meaningful on its own, but it can be used as a part of a larger expression. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_eq_Quaternion: .. rst-class:: classref-operator :ref:`bool` **operator ==** **(** :ref:`Quaternion` right **)** Returns ``true`` if the components of both quaternions are exactly equal. \ **Note:** Due to floating-point precision errors, consider using :ref:`is_equal_approx` instead, which is more reliable. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_idx_int: .. rst-class:: classref-operator :ref:`float` **operator []** **(** :ref:`int` index **)** Accesses each component of this quaternion by their index. Index ``0`` is the same as :ref:`x`, index ``1`` is the same as :ref:`y`, index ``2`` is the same as :ref:`z`, and index ``3`` is the same as :ref:`w`. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_unplus: .. rst-class:: classref-operator :ref:`Quaternion` **operator unary+** **(** **)** Returns the same value as if the ``+`` was not there. Unary ``+`` does nothing, but sometimes it can make your code more readable. .. rst-class:: classref-item-separator ---- .. _class_Quaternion_operator_unminus: .. rst-class:: classref-operator :ref:`Quaternion` **operator unary-** **(** **)** Returns the negative value of the **Quaternion**. This is the same as multiplying all components by ``-1``. This operation results in a quaternion that represents the same rotation. .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)` .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)` .. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)` .. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)` .. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)` .. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)` .. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)`