Fixed include paths, compile errors and some code style.

CHANGELOG.md

@@ -1352,7 +1352,7 @@ Added an icon for UserModule.
 
 ### Changed
 
-- Renamed Quat to Quaternion for consistency with the other engine math classes.
+- Renamed Quaternion to Quaternion for consistency with the other engine math classes.
 - Removed CameraMatrix, and switched to Projection.
 - Now all Variant math types are structs.
 - Ported form godot4: Reformat structure string operators.

doc/translations/ar.po

@@ -50841,7 +50841,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/ca.po

@@ -50680,7 +50680,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/classes.pot

@@ -50557,7 +50557,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/cs.po

@@ -51263,7 +51263,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/de.po

@@ -54672,7 +54672,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/el.po

@@ -50666,7 +50666,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/es.po

@@ -66503,7 +66503,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."
@@ -66513,7 +66513,7 @@ msgstr ""
 "Es similar a Basis, que implementa la representación matricial de las "
 "rotaciones, y puede ser parametrizada usando tanto un par eje-ángulo como "
 "ángulos de Euler. Basis almacena la rotación, la escala y el corte, mientras "
-"que Quat sólo almacena la rotación.\n"
+"que Quaternion sólo almacena la rotación.\n"
 "Debido a su compactación y a la forma en que se almacena en la memoria, "
 "ciertas operaciones (obtener el ángulo del eje y realizar el SLERP, en "
 "particular) son más eficientes y robustas contra los errores de reales."

doc/translations/et.po

@@ -50570,7 +50570,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/fa.po

@@ -51027,7 +51027,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/fi.po

@@ -50751,7 +50751,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/fil.po

@@ -50576,7 +50576,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/fr.po

@@ -65008,7 +65008,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/gl.po

@@ -50565,7 +50565,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/hi.po

@@ -50564,7 +50564,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/hu.po

@@ -50584,7 +50584,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/id.po

@@ -51028,7 +51028,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/is.po

@@ -50564,7 +50564,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/it.po

@@ -51933,7 +51933,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/ja.po

@@ -54148,7 +54148,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/ko.po

@@ -51095,7 +51095,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/lt.po

@@ -50574,7 +50574,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/lv.po

@@ -50582,7 +50582,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/mr.po

@@ -50562,7 +50562,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/nb.po

@@ -50574,7 +50574,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/ne.po

@@ -50562,7 +50562,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/nl.po

@@ -50635,7 +50635,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/pl.po

@@ -51328,7 +51328,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/pt.po

@@ -51765,7 +51765,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/pt_BR.po

@@ -52072,7 +52072,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/ro.po

@@ -50598,7 +50598,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/ru.po

@@ -53663,7 +53663,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/sk.po

@@ -50568,7 +50568,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/sr_Cyrl.po

@@ -50579,7 +50579,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/sv.po

@@ -50566,7 +50566,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/th.po

@@ -50828,7 +50828,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/tl.po

@@ -50684,7 +50684,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/tr.po

@@ -51506,7 +51506,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/uk.po

@@ -50888,7 +50888,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/vi.po

@@ -51166,7 +51166,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

doc/translations/zh_CN.po

@@ -64070,14 +64070,14 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."
 msgstr ""
 "用于表示 3D 旋转的单位四元数。四元数需要经过归一化才能用于旋转。\n"
 "它类似于 Basis，后者实现了旋转的矩阵表示，并且可以使用轴-角对或欧拉角进行参数"
-"化。Basis 可以存储旋转、缩放和错切，而 Quat 只存储旋转。\n"
+"化。Basis 可以存储旋转、缩放和错切，而 Quaternion 只存储旋转。\n"
 "由于它的紧凑性和在内存中的存储方式，某些操作（特别是获得轴角和执行 SLERP）更"
 "加有效，并且对浮点错误有很强的抵抗力。"
 

doc/translations/zh_TW.po

@@ -50808,7 +50808,7 @@ msgid ""
 "normalized to be used for rotation.\n"
 "It is similar to Basis, which implements matrix representation of rotations, "
 "and can be parametrized using both an axis-angle pair or Euler angles. Basis "
-"stores rotation, scale, and shearing, while Quat only stores rotation.\n"
+"stores rotation, scale, and shearing, while Quaternion only stores rotation.\n"
 "Due to its compactness and the way it is stored in memory, certain "
 "operations (obtaining axis-angle and performing SLERP, in particular) are "
 "more efficient and robust against floating-point errors."

modules/network_synchronizer/bit_array.cpp

@@ -35,7 +35,7 @@
 #include "bit_array.h"
 
 #include "core/math/math_funcs.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 
 BitArray::BitArray(uint32_t p_initial_size_in_bit) {
 	resize_in_bits(p_initial_size_in_bit);

modules/network_synchronizer/bit_array.h

@@ -1,3 +1,6 @@
+#ifndef BITARRAY_H
+#define BITARRAY_H
+
 /*************************************************************************/
 /*  bit_array.h                                                          */
 /*************************************************************************/
@@ -32,10 +35,7 @@
 	@author AndreaCatania
 */
 
-#include "core/vector.h"
-
-#ifndef BITARRAY_H
-#define BITARRAY_H
+#include "core/containers/vector.h"
 
 class BitArray {
 	Vector<uint8_t> bytes;

modules/network_synchronizer/data_buffer.h

@@ -1,3 +1,6 @@
+#ifndef INPUT_BUFFER_H
+#define INPUT_BUFFER_H
+
 /*************************************************************************/
 /*  data_buffer.h                                                        */
 /*************************************************************************/
@@ -32,13 +35,10 @@
 	@author AndreaCatania
 */
 
-#include "core/class_db.h"
+#include "core/object/class_db.h"
 
 #include "bit_array.h"
 
-#ifndef INPUT_BUFFER_H
-#define INPUT_BUFFER_H
-
 class DataBuffer : public Object {
 	GDCLASS(DataBuffer, Object);
 

modules/network_synchronizer/godot_backward_utility_cpp.h

@@ -5,7 +5,7 @@
 	@author AndreaCatania
 */
 
-#include "core/engine.h"
+#include "core/config/engine.h"
 #include "scene/main/viewport.h"
 #define FLOAT REAL
 #define STRING_NAME STRING

modules/network_synchronizer/input_network_encoder.h

@@ -1,8 +1,9 @@
-#pragma once
+#ifndef INPUT_NETWORK_ENCODER_H
+#define INPUT_NETWORK_ENCODER_H
 
-#include "core/local_vector.h"
-#include "core/resource.h"
-#include "core/variant.h"
+#include "core/containers/local_vector.h"
+#include "core/object/resource.h"
+#include "core/variant/variant.h"
 #include "data_buffer.h"
 
 struct NetworkedInputInfo {
@@ -49,3 +50,5 @@ public:
 	bool script_are_different(Object *p_buffer_A, Object *p_buffer_B) const;
 	uint32_t script_count_size(Object *p_buffer) const;
 };
+
+#endif

modules/network_synchronizer/net_action.cpp

@@ -1,6 +1,6 @@
 #include "net_action.h"
 
-#include "core/error_macros.h"
+#include "core/error/error_macros.h"
 #include "core/os/os.h"
 #include "scene/main/node.h"
 #include "scene_synchronizer.h"

modules/network_synchronizer/net_action.h

@@ -1,3 +1,6 @@
+#ifndef NET_ACTIONS_H
+#define NET_ACTIONS_H
+
 /*************************************************************************/
 /*  net_actions.h**                                                      */
 /*************************************************************************/
@@ -28,10 +31,7 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef NET_ACTIONS_H
-#define NET_ACTIONS_H
-
-#include "core/reference.h"
+#include "core/object/reference.h"
 #include "net_action_processor.h"
 #include "net_utilities.h"
 

modules/network_synchronizer/net_action_info.h

@@ -1,6 +1,7 @@
-#pragma once
+#ifndef NET_ACTION_INFO_H
+#define NET_ACTION_INFO_H
 
-#include "core/string_name.h"
+#include "core/string/string_name.h"
 #include "input_network_encoder.h"
 #include "net_action_processor.h"
 
@@ -21,4 +22,6 @@ struct NetActionInfo {
 
 	bool operator==(const NetActionInfo &p_other) const;
 	bool operator<(const NetActionInfo &p_other) const;
-};
+};
+
+#endif

modules/network_synchronizer/net_action_processor.h

@@ -1,7 +1,8 @@
-#pragma once
+#ifndef NET_ACTION_PROCESSOR_H
+#define NET_ACTION_PROCESSOR_H
 
-#include "core/array.h"
-#include "core/ustring.h"
+#include "core/variant/array.h"
+#include "core/string/ustring.h"
 
 namespace NetUtility {
 struct NodeData;
@@ -38,3 +39,5 @@ struct TokenizedNetActionProcessor {
 	TokenizedNetActionProcessor(uint32_t p_at, NetActionProcessor p_p) :
 			action_token(p_at), processor(p_p) {}
 };
+
+#endif

modules/network_synchronizer/net_utilities.h

@@ -1,3 +1,6 @@
+#ifndef NET_UTILITIES_H
+#define NET_UTILITIES_H
+
 /*************************************************************************/
 /*  net_utilities.h                                                      */
 /*************************************************************************/
@@ -32,13 +35,10 @@
 	@author AndreaCatania
 */
 
-#ifndef NET_UTILITIES_H
-#define NET_UTILITIES_H
-
-#include "core/local_vector.h"
+#include "core/containers/local_vector.h"
 #include "core/math/math_funcs.h"
-#include "core/project_settings.h"
-#include "core/variant.h"
+#include "core/config/project_settings.h"
+#include "core/variant/variant.h"
 #include "net_action_info.h"
 #include "net_action_processor.h"
 

modules/network_synchronizer/networked_controller.cpp

@@ -34,7 +34,7 @@
 
 #include "networked_controller.h"
 
-#include "core/engine.h"
+#include "core/config/engine.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
 #include "scene_synchronizer.h"
@@ -634,7 +634,7 @@ void NetworkedController::_notification(int p_what) {
 			// This can't happen, since only the doll are processed here.
 			CRASH_COND(is_doll_controller() == false);
 #endif
-			const double physics_ticks_per_second = Engine::get_singleton()->get_iterations_per_second();
+			const double physics_ticks_per_second = Engine::get_singleton()->get_physics_ticks_per_second();
 			const double delta = 1.0 / physics_ticks_per_second;
 			static_cast<DollController *>(controller)->process(delta);
 
@@ -1044,7 +1044,7 @@ bool ServerController::fetch_next_input(real_t p_delta) {
 void ServerController::set_frame_input(const FrameSnapshot &p_frame_snapshot) {
 	// If `previous_frame_received_timestamp` is bigger, the controller was disabled, so nothing to do.
 	if (previous_frame_received_timestamp < p_frame_snapshot.received_timestamp) {
-		const double physics_ticks_per_second = Engine::get_singleton()->get_iterations_per_second();
+		const double physics_ticks_per_second = Engine::get_singleton()->get_physics_ticks_per_second();
 		const uint32_t frame_delta_ms = (1.0 / physics_ticks_per_second) * 1000.0;
 
 		const uint32_t receival_time = p_frame_snapshot.received_timestamp - previous_frame_received_timestamp;
@@ -1673,7 +1673,7 @@ void DollController::receive_epoch(const Vector<uint8_t> &p_data) {
 			net_poorness);
 
 	const real_t epochs_span = target_virtual_delay - current_virtual_delay;
-	const real_t frame_time = 1.0 / real_t(Engine::get_singleton()->get_iterations_per_second());
+	const real_t frame_time = 1.0 / real_t(Engine::get_singleton()->get_physics_ticks_per_second());
 	interpolation_time_window =
 			next_sync_time +
 			(current_virtual_delay * frame_time) +

modules/network_synchronizer/networked_controller.h

@@ -1,3 +1,6 @@
+#ifndef NETWORKED_CONTROLLER_H
+#define NETWORKED_CONTROLLER_H
+
 /*************************************************************************/
 /*  networked_controller.h                                               */
 /*************************************************************************/
@@ -38,9 +41,6 @@
 #include "net_utilities.h"
 #include <deque>
 
-#ifndef NETWORKED_CONTROLLER_H
-#define NETWORKED_CONTROLLER_H
-
 #include "godot_backward_utility_header.h"
 
 class SceneSynchronizer;

modules/network_synchronizer/register_types.cpp

@@ -34,7 +34,7 @@
 
 #include "register_types.h"
 
-#include "core/engine.h"
+#include "core/config/engine.h"
 #include "data_buffer.h"
 #include "input_network_encoder.h"
 #include "networked_controller.h"

modules/network_synchronizer/scene_diff.h

@@ -1,3 +1,6 @@
+#ifndef SCENE_DIFF_H
+#define SCENE_DIFF_H
+
 /*************************************************************************/
 /*  scene_diff.h                                                         */
 /*************************************************************************/
@@ -32,10 +35,7 @@
 	@author AndreaCatania
 */
 
-#ifndef SCENE_DIFF_H
-#define SCENE_DIFF_H
-
-#include "core/class_db.h"
+#include "core/object/class_db.h"
 #include "net_utilities.h"
 
 class SceneSynchronizer;

modules/network_synchronizer/scene_synchronizer.cpp

@@ -34,7 +34,7 @@
 
 #include "scene_synchronizer.h"
 
-#include "core/method_bind_ext.gen.inc"
+#include "core/object/method_bind_ext.gen.inc"
 #include "core/os/os.h"
 #include "input_network_encoder.h"
 #include "networked_controller.h"
@@ -1548,9 +1548,9 @@ bool SceneSynchronizer::compare(const Variant &p_first, const Variant &p_second,
 		case Variant::TRANSFORM2D: {
 			const Transform2D a(p_first);
 			const Transform2D b(p_second);
-			if (compare(a.elements[0], b.elements[0], p_tolerance)) {
-				if (compare(a.elements[1], b.elements[1], p_tolerance)) {
-					if (compare(a.elements[2], b.elements[2], p_tolerance)) {
+			if (compare(a.columns[0], b.columns[0], p_tolerance)) {
+				if (compare(a.columns[1], b.columns[1], p_tolerance)) {
+					if (compare(a.columns[2], b.columns[2], p_tolerance)) {
 						return true;
 					}
 				}
@@ -1560,10 +1560,10 @@ bool SceneSynchronizer::compare(const Variant &p_first, const Variant &p_second,
 		case Variant::VECTOR3:
 			return compare(Vector3(p_first), Vector3(p_second), p_tolerance);
 
-		case Variant::QUAT: {
-			const Quat a = p_first;
-			const Quat b = p_second;
-			const Quat r(a - b); // Element wise subtraction.
+		case Variant::QUATERNION: {
+			const Quaternion a = p_first;
+			const Quaternion b = p_second;
+			const Quaternion r(a - b); // Element wise subtraction.
 			return (r.x * r.x + r.y * r.y + r.z * r.z + r.w * r.w) <= (p_tolerance * p_tolerance);
 		}
 		case Variant::PLANE: {
@@ -1589,9 +1589,9 @@ bool SceneSynchronizer::compare(const Variant &p_first, const Variant &p_second,
 		case Variant::BASIS: {
 			const Basis a = p_first;
 			const Basis b = p_second;
-			if (compare(a.elements[0], b.elements[0], p_tolerance)) {
-				if (compare(a.elements[1], b.elements[1], p_tolerance)) {
-					if (compare(a.elements[2], b.elements[2], p_tolerance)) {
+			if (compare(a.rows[0], b.rows[0], p_tolerance)) {
+				if (compare(a.rows[1], b.rows[1], p_tolerance)) {
+					if (compare(a.rows[2], b.rows[2], p_tolerance)) {
 						return true;
 					}
 				}
@@ -1602,9 +1602,9 @@ bool SceneSynchronizer::compare(const Variant &p_first, const Variant &p_second,
 			const Transform a = p_first;
 			const Transform b = p_second;
 			if (compare(a.origin, b.origin, p_tolerance)) {
-				if (compare(a.basis.elements[0], b.basis.elements[0], p_tolerance)) {
-					if (compare(a.basis.elements[1], b.basis.elements[1], p_tolerance)) {
-						if (compare(a.basis.elements[2], b.basis.elements[2], p_tolerance)) {
+				if (compare(a.basis.rows[0], b.basis.rows[0], p_tolerance)) {
+					if (compare(a.basis.rows[1], b.basis.rows[1], p_tolerance)) {
+						if (compare(a.basis.rows[2], b.basis.rows[2], p_tolerance)) {
 							return true;
 						}
 					}
@@ -1886,7 +1886,7 @@ void NoNetSynchronizer::process() {
 
 	SceneSynchronizerDebugger::singleton()->scene_sync_process_start(scene_synchronizer);
 
-	const double physics_ticks_per_second = Engine::get_singleton()->get_iterations_per_second();
+	const double physics_ticks_per_second = Engine::get_singleton()->get_physics_ticks_per_second();
 	const double delta = 1.0 / physics_ticks_per_second;
 
 	// Process the scene
@@ -1969,7 +1969,7 @@ void ServerSynchronizer::process() {
 
 	scene_synchronizer->update_peers();
 
-	const double physics_ticks_per_second = Engine::get_singleton()->get_iterations_per_second();
+	const double physics_ticks_per_second = Engine::get_singleton()->get_physics_ticks_per_second();
 	const double delta = 1.0 / physics_ticks_per_second;
 
 	SceneSynchronizerDebugger::singleton()->scene_sync_process_start(scene_synchronizer);
@@ -2620,7 +2620,7 @@ void ClientSynchronizer::process() {
 		return;
 	}
 
-	const double physics_ticks_per_second = Engine::get_singleton()->get_iterations_per_second();
+	const double physics_ticks_per_second = Engine::get_singleton()->get_physics_ticks_per_second();
 	const double delta = 1.0 / physics_ticks_per_second;
 
 #ifdef DEBUG_ENABLED
@@ -2722,7 +2722,7 @@ void ClientSynchronizer::process() {
 
 	// Now trigger the END_SYNC event.
 	scene_synchronizer->change_events_begin(NetEventFlag::END_SYNC);
-	for (const Set<EndSyncEvent>::Element *e = sync_end_events.front();
+	for (const RBSet<EndSyncEvent>::Element *e = sync_end_events.front();
 			e != nullptr;
 			e = e->next()) {
 		// Check if the values between the variables before the sync and the

modules/network_synchronizer/scene_synchronizer.h

@@ -1,3 +1,6 @@
+#ifndef SCENE_SYNCHRONIZER_H
+#define SCENE_SYNCHRONIZER_H
+
 /*************************************************************************/
 /*  scene_synchronizer.h                                                 */
 /*************************************************************************/
@@ -34,15 +37,12 @@
 
 #include "scene/main/node.h"
 
-#include "core/local_vector.h"
-#include "core/oa_hash_map.h"
+#include "core/containers/local_vector.h"
+#include "core/containers/oa_hash_map.h"
 #include "net_action.h"
 #include "net_utilities.h"
 #include <deque>
 
-#ifndef SCENE_SYNCHRONIZER_H
-#define SCENE_SYNCHRONIZER_H
-
 #include "godot_backward_utility_header.h"
 
 class Synchronizer;
@@ -432,8 +432,8 @@ class ServerSynchronizer : public Synchronizer {
 
 	struct Change {
 		bool not_known_before = false;
-		Set<StringName> uknown_vars;
-		Set<StringName> vars;
+		RBSet<StringName> uknown_vars;
+		RBSet<StringName> vars;
 	};
 
 	enum SnapshotGenerationMode {
@@ -515,7 +515,7 @@ class ClientSynchronizer : public Synchronizer {
 		}
 	};
 
-	Set<EndSyncEvent> sync_end_events;
+	RBSet<EndSyncEvent> sync_end_events;
 
 	uint32_t locally_triggered_actions_count = 0;
 	uint32_t actions_input_id = 0;

modules/network_synchronizer/scene_synchronizer_debugger.cpp

@@ -410,7 +410,7 @@ String type_to_string(Variant::Type p_type) {
 			return "TRANSFORM2D";
 		case Variant::PLANE:
 			return "PLANE";
-		case Variant::QUAT:
+		case Variant::QUATERNION:
 			return "QUAT";
 		case Variant::AABB:
 			return "AABB";
@@ -422,7 +422,7 @@ String type_to_string(Variant::Type p_type) {
 			return "COLOR";
 		case Variant::NODE_PATH:
 			return "NODE_PATH";
-		case Variant::_RID:
+		case Variant::RID:
 			return "_RID";
 		case Variant::OBJECT:
 			return "OBJECT";

modules/network_synchronizer/scene_synchronizer_debugger.h

@@ -1,3 +1,6 @@
+#ifndef SCENE_SYNCHRONIZER_DEBUGGER_H
+#define SCENE_SYNCHRONIZER_DEBUGGER_H
+
 /*************************************************************************/
 /*  scene_synchronizer_debugger.h                                        */
 /*************************************************************************/
@@ -28,13 +31,11 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#pragma once
-
 #include "scene/main/node.h"
 
 #ifdef DEBUG_ENABLED
 
-#include "core/oa_hash_map.h"
+#include "core/containers/oa_hash_map.h"
 
 #endif
 
@@ -169,3 +170,5 @@ public:
 private:
 	void dump_tracked_objects(const SceneSynchronizer *p_scene_sync, Dictionary &p_dump);
 };
+
+#endif

platform/uwp/os_uwp.h

@@ -36,7 +36,7 @@
 #include "core/math/transform_2d.h"
 #include "core/os/input.h"
 #include "core/os/os.h"
-#include "core/ustring.h"
+#include "core/string/ustring.h"
 #include "drivers/xaudio2/audio_driver_xaudio2.h"
 #include "joypad_uwp.h"
 #include "main/input_default.h"