Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-03-03 11:54:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Renamed elements in Transform2D to columns.

Browse Source
This commit is contained in:
Relintai 2022-08-14 15:37:05 +02:00
parent d9a8497546
commit e4cad690a3
40 changed files with 342 additions and 342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
core/io/marshalls.cpp
View File

@ -259,7 +259,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
Transform2D val; Transform2D val;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
val.elements[i][j] = decode_float(&buf[(i * 2 + j) * 4]); val.columns[i][j] = decode_float(&buf[(i * 2 + j) * 4]);
} }
} }
@ -1093,7 +1093,7 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
Transform2D val = p_variant; Transform2D val = p_variant;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
memcpy(&buf[(i * 2 + j) * 4], &val.elements[i][j], sizeof(float)); memcpy(&buf[(i * 2 + j) * 4], &val.columns[i][j], sizeof(float));
} }
} }
} }

24
core/io/resource_format_binary.cpp
View File

@ -228,12 +228,12 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
} break; } break;
case VARIANT_MATRIX32: { case VARIANT_MATRIX32: {
Transform2D v; Transform2D v;
v.elements[0].x = f->get_real(); v.columns[0].x = f->get_real();
v.elements[0].y = f->get_real(); v.columns[0].y = f->get_real();
v.elements[1].x = f->get_real(); v.columns[1].x = f->get_real();
v.elements[1].y = f->get_real(); v.columns[1].y = f->get_real();
v.elements[2].x = f->get_real(); v.columns[2].x = f->get_real();
v.elements[2].y = f->get_real(); v.columns[2].y = f->get_real();
r_v = v; r_v = v;
} break; } break;
@ -1395,12 +1395,12 @@ void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Varia
case Variant::TRANSFORM2D: { case Variant::TRANSFORM2D: {
f->store_32(VARIANT_MATRIX32); f->store_32(VARIANT_MATRIX32);
Transform2D val = p_property; Transform2D val = p_property;
f->store_real(val.elements[0].x); f->store_real(val.columns[0].x);
f->store_real(val.elements[0].y); f->store_real(val.columns[0].y);
f->store_real(val.elements[1].x); f->store_real(val.columns[1].x);
f->store_real(val.elements[1].y); f->store_real(val.columns[1].y);
f->store_real(val.elements[2].x); f->store_real(val.columns[2].x);
f->store_real(val.elements[2].y); f->store_real(val.columns[2].y);
} break; } break;

12
core/math/math_fieldwise.cpp
View File

@ -123,12 +123,12 @@ Variant fieldwise_assign(const Variant &p_target, const Variant &p_source, const
SETUP_TYPE(Transform2D) SETUP_TYPE(Transform2D)
/**/ TRY_TRANSFER_FIELD("xx", elements[0][0]) /**/ TRY_TRANSFER_FIELD("xx", columns[0][0])
else TRY_TRANSFER_FIELD("xy", elements[0][1]) else TRY_TRANSFER_FIELD("xy", columns[0][1])
else TRY_TRANSFER_FIELD("yx", elements[1][0]) else TRY_TRANSFER_FIELD("yx", columns[1][0])
else TRY_TRANSFER_FIELD("yy", elements[1][1]) else TRY_TRANSFER_FIELD("yy", columns[1][1])
else TRY_TRANSFER_FIELD("ox", elements[2][0]) else TRY_TRANSFER_FIELD("ox", columns[2][0])
else TRY_TRANSFER_FIELD("oy", elements[2][1]) else TRY_TRANSFER_FIELD("oy", columns[2][1])
return target; return target;
} }

32
core/math/rect2.cpp
View File

@ -189,33 +189,33 @@ next4:
Vector2(position.x + size.x, position.y + size.y), Vector2(position.x + size.x, position.y + size.y),
}; };
real_t maxa = p_xform.elements[0].dot(xf_points2[0]); real_t maxa = p_xform.columns[0].dot(xf_points2[0]);
real_t mina = maxa; real_t mina = maxa;
real_t dp = p_xform.elements[0].dot(xf_points2[1]); real_t dp = p_xform.columns[0].dot(xf_points2[1]);
maxa = MAX(dp, maxa); maxa = MAX(dp, maxa);
mina = MIN(dp, mina); mina = MIN(dp, mina);
dp = p_xform.elements[0].dot(xf_points2[2]); dp = p_xform.columns[0].dot(xf_points2[2]);
maxa = MAX(dp, maxa); maxa = MAX(dp, maxa);
mina = MIN(dp, mina); mina = MIN(dp, mina);
dp = p_xform.elements[0].dot(xf_points2[3]); dp = p_xform.columns[0].dot(xf_points2[3]);
maxa = MAX(dp, maxa); maxa = MAX(dp, maxa);
mina = MIN(dp, mina); mina = MIN(dp, mina);
real_t maxb = p_xform.elements[0].dot(xf_points[0]); real_t maxb = p_xform.columns[0].dot(xf_points[0]);
real_t minb = maxb; real_t minb = maxb;
dp = p_xform.elements[0].dot(xf_points[1]); dp = p_xform.columns[0].dot(xf_points[1]);
maxb = MAX(dp, maxb); maxb = MAX(dp, maxb);
minb = MIN(dp, minb); minb = MIN(dp, minb);
dp = p_xform.elements[0].dot(xf_points[2]); dp = p_xform.columns[0].dot(xf_points[2]);
maxb = MAX(dp, maxb); maxb = MAX(dp, maxb);
minb = MIN(dp, minb); minb = MIN(dp, minb);
dp = p_xform.elements[0].dot(xf_points[3]); dp = p_xform.columns[0].dot(xf_points[3]);
maxb = MAX(dp, maxb); maxb = MAX(dp, maxb);
minb = MIN(dp, minb); minb = MIN(dp, minb);
@ -226,33 +226,33 @@ next4:
return false; return false;
} }
maxa = p_xform.elements[1].dot(xf_points2[0]); maxa = p_xform.columns[1].dot(xf_points2[0]);
mina = maxa; mina = maxa;
dp = p_xform.elements[1].dot(xf_points2[1]); dp = p_xform.columns[1].dot(xf_points2[1]);
maxa = MAX(dp, maxa); maxa = MAX(dp, maxa);
mina = MIN(dp, mina); mina = MIN(dp, mina);
dp = p_xform.elements[1].dot(xf_points2[2]); dp = p_xform.columns[1].dot(xf_points2[2]);
maxa = MAX(dp, maxa); maxa = MAX(dp, maxa);
mina = MIN(dp, mina); mina = MIN(dp, mina);
dp = p_xform.elements[1].dot(xf_points2[3]); dp = p_xform.columns[1].dot(xf_points2[3]);
maxa = MAX(dp, maxa); maxa = MAX(dp, maxa);
mina = MIN(dp, mina); mina = MIN(dp, mina);
maxb = p_xform.elements[1].dot(xf_points[0]); maxb = p_xform.columns[1].dot(xf_points[0]);
minb = maxb; minb = maxb;
dp = p_xform.elements[1].dot(xf_points[1]); dp = p_xform.columns[1].dot(xf_points[1]);
maxb = MAX(dp, maxb); maxb = MAX(dp, maxb);
minb = MIN(dp, minb); minb = MIN(dp, minb);
dp = p_xform.elements[1].dot(xf_points[2]); dp = p_xform.columns[1].dot(xf_points[2]);
maxb = MAX(dp, maxb); maxb = MAX(dp, maxb);
minb = MIN(dp, minb); minb = MIN(dp, minb);
dp = p_xform.elements[1].dot(xf_points[3]); dp = p_xform.columns[1].dot(xf_points[3]);
maxb = MAX(dp, maxb); maxb = MAX(dp, maxb);
minb = MIN(dp, minb); minb = MIN(dp, minb);

94
core/math/transform_2d.cpp
View File

@ -33,8 +33,8 @@
void Transform2D::invert() { void Transform2D::invert() {
// FIXME: this function assumes the basis is a rotation matrix, with no scaling. // FIXME: this function assumes the basis is a rotation matrix, with no scaling.
// Transform2D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that. // Transform2D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
SWAP(elements[0][1], elements[1][0]); SWAP(columns[0][1], columns[1][0]);
elements[2] = basis_xform(-elements[2]); columns[2] = basis_xform(-columns[2]);
} }
Transform2D Transform2D::inverse() const { Transform2D Transform2D::inverse() const {
@ -50,11 +50,11 @@ void Transform2D::affine_invert() {
#endif #endif
real_t idet = 1 / det; real_t idet = 1 / det;
SWAP(elements[0][0], elements[1][1]); SWAP(columns[0][0], columns[1][1]);
elements[0] *= Vector2(idet, -idet); columns[0] *= Vector2(idet, -idet);
elements[1] *= Vector2(-idet, idet); columns[1] *= Vector2(-idet, idet);
elements[2] = basis_xform(-elements[2]); columns[2] = basis_xform(-columns[2]);
} }
Transform2D Transform2D::affine_inverse() const { Transform2D Transform2D::affine_inverse() const {
@ -68,71 +68,71 @@ void Transform2D::rotate(real_t p_phi) {
} }
real_t Transform2D::get_rotation() const { real_t Transform2D::get_rotation() const {
return Math::atan2(elements[0].y, elements[0].x); return Math::atan2(columns[0].y, columns[0].x);
} }
void Transform2D::set_rotation(real_t p_rot) { void Transform2D::set_rotation(real_t p_rot) {
Size2 scale = get_scale(); Size2 scale = get_scale();
real_t cr = Math::cos(p_rot); real_t cr = Math::cos(p_rot);
real_t sr = Math::sin(p_rot); real_t sr = Math::sin(p_rot);
elements[0][0] = cr; columns[0][0] = cr;
elements[0][1] = sr; columns[0][1] = sr;
elements[1][0] = -sr; columns[1][0] = -sr;
elements[1][1] = cr; columns[1][1] = cr;
set_scale(scale); set_scale(scale);
} }
Transform2D::Transform2D(real_t p_rot, const Vector2 &p_pos) { Transform2D::Transform2D(real_t p_rot, const Vector2 &p_pos) {
real_t cr = Math::cos(p_rot); real_t cr = Math::cos(p_rot);
real_t sr = Math::sin(p_rot); real_t sr = Math::sin(p_rot);
elements[0][0] = cr; columns[0][0] = cr;
elements[0][1] = sr; columns[0][1] = sr;
elements[1][0] = -sr; columns[1][0] = -sr;
elements[1][1] = cr; columns[1][1] = cr;
elements[2] = p_pos; columns[2] = p_pos;
} }
Size2 Transform2D::get_scale() const { Size2 Transform2D::get_scale() const {
real_t det_sign = SGN(basis_determinant()); real_t det_sign = SGN(basis_determinant());
return Size2(elements[0].length(), det_sign * elements[1].length()); return Size2(columns[0].length(), det_sign * columns[1].length());
} }
void Transform2D::set_scale(const Size2 &p_scale) { void Transform2D::set_scale(const Size2 &p_scale) {
elements[0].normalize(); columns[0].normalize();
elements[1].normalize(); columns[1].normalize();
elements[0] *= p_scale.x; columns[0] *= p_scale.x;
elements[1] *= p_scale.y; columns[1] *= p_scale.y;
} }
void Transform2D::scale(const Size2 &p_scale) { void Transform2D::scale(const Size2 &p_scale) {
scale_basis(p_scale); scale_basis(p_scale);
elements[2] *= p_scale; columns[2] *= p_scale;
} }
void Transform2D::scale_basis(const Size2 &p_scale) { void Transform2D::scale_basis(const Size2 &p_scale) {
elements[0][0] *= p_scale.x; columns[0][0] *= p_scale.x;
elements[0][1] *= p_scale.y; columns[0][1] *= p_scale.y;
elements[1][0] *= p_scale.x; columns[1][0] *= p_scale.x;
elements[1][1] *= p_scale.y; columns[1][1] *= p_scale.y;
} }
void Transform2D::translate_local(real_t p_tx, real_t p_ty) { void Transform2D::translate_local(real_t p_tx, real_t p_ty) {
translate_local(Vector2(p_tx, p_ty)); translate_local(Vector2(p_tx, p_ty));
} }
void Transform2D::translate_local(const Vector2 &p_translation) { void Transform2D::translate_local(const Vector2 &p_translation) {
elements[2] += basis_xform(p_translation); columns[2] += basis_xform(p_translation);
} }
void Transform2D::orthonormalize() { void Transform2D::orthonormalize() {
// Gram-Schmidt Process // Gram-Schmidt Process
Vector2 x = elements[0]; Vector2 x = columns[0];
Vector2 y = elements[1]; Vector2 y = columns[1];
x.normalize(); x.normalize();
y = (y - x * (x.dot(y))); y = (y - x * (x.dot(y)));
y.normalize(); y.normalize();
elements[0] = x; columns[0] = x;
elements[1] = y; columns[1] = y;
} }
Transform2D Transform2D::orthonormalized() const { Transform2D Transform2D::orthonormalized() const {
@ -142,12 +142,12 @@ Transform2D Transform2D::orthonormalized() const {
} }
bool Transform2D::is_equal_approx(const Transform2D &p_transform) const { bool Transform2D::is_equal_approx(const Transform2D &p_transform) const {
return elements[0].is_equal_approx(p_transform.elements[0]) && elements[1].is_equal_approx(p_transform.elements[1]) && elements[2].is_equal_approx(p_transform.elements[2]); return columns[0].is_equal_approx(p_transform.columns[0]) && columns[1].is_equal_approx(p_transform.columns[1]) && columns[2].is_equal_approx(p_transform.columns[2]);
} }
bool Transform2D::operator==(const Transform2D &p_transform) const { bool Transform2D::operator==(const Transform2D &p_transform) const {
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
if (elements[i] != p_transform.elements[i]) { if (columns[i] != p_transform.columns[i]) {
return false; return false;
} }
} }
@ -157,7 +157,7 @@ bool Transform2D::operator==(const Transform2D &p_transform) const {
bool Transform2D::operator!=(const Transform2D &p_transform) const { bool Transform2D::operator!=(const Transform2D &p_transform) const {
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
if (elements[i] != p_transform.elements[i]) { if (columns[i] != p_transform.columns[i]) {
return true; return true;
} }
} }
@ -166,19 +166,19 @@ bool Transform2D::operator!=(const Transform2D &p_transform) const {
} }
void Transform2D::operator*=(const Transform2D &p_transform) { void Transform2D::operator*=(const Transform2D &p_transform) {
elements[2] = xform(p_transform.elements[2]); columns[2] = xform(p_transform.columns[2]);
real_t x0, x1, y0, y1; real_t x0, x1, y0, y1;
x0 = tdotx(p_transform.elements[0]); x0 = tdotx(p_transform.columns[0]);
x1 = tdoty(p_transform.elements[0]); x1 = tdoty(p_transform.columns[0]);
y0 = tdotx(p_transform.elements[1]); y0 = tdotx(p_transform.columns[1]);
y1 = tdoty(p_transform.elements[1]); y1 = tdoty(p_transform.columns[1]);
elements[0][0] = x0; columns[0][0] = x0;
elements[0][1] = x1; columns[0][1] = x1;
elements[1][0] = y0; columns[1][0] = y0;
elements[1][1] = y1; columns[1][1] = y1;
} }
Transform2D Transform2D::operator*(const Transform2D &p_transform) const { Transform2D Transform2D::operator*(const Transform2D &p_transform) const {
@ -201,13 +201,13 @@ Transform2D Transform2D::basis_scaled(const Size2 &p_scale) const {
Transform2D Transform2D::untranslated() const { Transform2D Transform2D::untranslated() const {
Transform2D copy = *this; Transform2D copy = *this;
copy.elements[2] = Vector2(); copy.columns[2] = Vector2();
return copy; return copy;
} }
Transform2D Transform2D::translated_local(const Vector2 &p_offset) const { Transform2D Transform2D::translated_local(const Vector2 &p_offset) const {
// Equivalent to right multiplication // Equivalent to right multiplication
return Transform2D(elements[0], elements[1], elements[2] + basis_xform(p_offset)); return Transform2D(columns[0], columns[1], columns[2] + basis_xform(p_offset));
} }
Transform2D Transform2D::rotated(real_t p_phi) const { Transform2D Transform2D::rotated(real_t p_phi) const {
@ -217,7 +217,7 @@ Transform2D Transform2D::rotated(real_t p_phi) const {
} }
real_t Transform2D::basis_determinant() const { real_t Transform2D::basis_determinant() const {
return elements[0].x * elements[1].y - elements[0].y * elements[1].x; return columns[0].x * columns[1].y - columns[0].y * columns[1].x;
} }
Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t p_c) const { Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t p_c) const {
@ -256,5 +256,5 @@ Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t
} }
Transform2D::operator String() const { Transform2D::operator String() const {
return String(String() + elements[0] + ", " + elements[1] + ", " + elements[2]); return String(String() + columns[0] + ", " + columns[1] + ", " + columns[2]);
} }

86
core/math/transform_2d.h
View File

@ -35,32 +35,32 @@
#include "core/pool_vector.h" #include "core/pool_vector.h"
struct _NO_DISCARD_CLASS_ Transform2D { struct _NO_DISCARD_CLASS_ Transform2D {
// Warning #1: basis of Transform2D is stored differently from Basis. In terms of elements array, the basis matrix looks like "on paper": // Warning #1: basis of Transform2D is stored differently from Basis. In terms of columns array, the basis matrix looks like "on paper":
// M = (elements[0][0] elements[1][0]) // M = (columns[0][0] columns[1][0])
// (elements[0][1] elements[1][1]) // (columns[0][1] columns[1][1])
// This is such that the columns, which can be interpreted as basis vectors of the coordinate system "painted" on the object, can be accessed as elements[i]. // This is such that the columns, which can be interpreted as basis vectors of the coordinate system "painted" on the object, can be accessed as columns[i].
// Note that this is the opposite of the indices in mathematical texts, meaning: $M_{12}$ in a math book corresponds to elements[1][0] here. // Note that this is the opposite of the indices in mathematical texts, meaning: $M_{12}$ in a math book corresponds to columns[1][0] here.
// This requires additional care when working with explicit indices. // This requires additional care when working with explicit indices.
// See https://en.wikipedia.org/wiki/Row-_and_column-major_order for further reading. // See https://en.wikipedia.org/wiki/Row-_and_column-major_order for further reading.
// Warning #2: 2D be aware that unlike 3D code, 2D code uses a left-handed coordinate system: Y-axis points down, // Warning #2: 2D be aware that unlike 3D code, 2D code uses a left-handed coordinate system: Y-axis points down,
// and angle is measure from +X to +Y in a clockwise-fashion. // and angle is measure from +X to +Y in a clockwise-fashion.
Vector2 elements[3]; Vector2 columns[3];
_FORCE_INLINE_ real_t tdotx(const Vector2 &v) const { return elements[0][0] * v.x + elements[1][0] * v.y; } _FORCE_INLINE_ real_t tdotx(const Vector2 &v) const { return columns[0][0] * v.x + columns[1][0] * v.y; }
_FORCE_INLINE_ real_t tdoty(const Vector2 &v) const { return elements[0][1] * v.x + elements[1][1] * v.y; } _FORCE_INLINE_ real_t tdoty(const Vector2 &v) const { return columns[0][1] * v.x + columns[1][1] * v.y; }
const Vector2 &operator[](int p_idx) const { return elements[p_idx]; } const Vector2 &operator[](int p_idx) const { return columns[p_idx]; }
Vector2 &operator[](int p_idx) { return elements[p_idx]; } Vector2 &operator[](int p_idx) { return columns[p_idx]; }
_FORCE_INLINE_ Vector2 get_axis(int p_axis) const { _FORCE_INLINE_ Vector2 get_axis(int p_axis) const {
ERR_FAIL_INDEX_V(p_axis, 3, Vector2()); ERR_FAIL_INDEX_V(p_axis, 3, Vector2());
return elements[p_axis]; return columns[p_axis];
} }
_FORCE_INLINE_ void set_axis(int p_axis, const Vector2 &p_vec) { _FORCE_INLINE_ void set_axis(int p_axis, const Vector2 &p_vec) {
ERR_FAIL_INDEX(p_axis, 3); ERR_FAIL_INDEX(p_axis, 3);
elements[p_axis] = p_vec; columns[p_axis] = p_vec;
} }
void invert(); void invert();
@ -84,8 +84,8 @@ struct _NO_DISCARD_CLASS_ Transform2D {
Size2 get_scale() const; Size2 get_scale() const;
void set_scale(const Size2 &p_scale); void set_scale(const Size2 &p_scale);
_FORCE_INLINE_ const Vector2 &get_origin() const { return elements[2]; } _FORCE_INLINE_ const Vector2 &get_origin() const { return columns[2]; }
_FORCE_INLINE_ void set_origin(const Vector2 &p_origin) { elements[2] = p_origin; } _FORCE_INLINE_ void set_origin(const Vector2 &p_origin) { columns[2] = p_origin; }
Transform2D scaled(const Size2 &p_scale) const; Transform2D scaled(const Size2 &p_scale) const;
Transform2D basis_scaled(const Size2 &p_scale) const; Transform2D basis_scaled(const Size2 &p_scale) const;
@ -127,24 +127,24 @@ struct _NO_DISCARD_CLASS_ Transform2D {
operator String() const; operator String() const;
Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) { Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy) {
elements[0][0] = xx; columns[0][0] = xx;
elements[0][1] = xy; columns[0][1] = xy;
elements[1][0] = yx; columns[1][0] = yx;
elements[1][1] = yy; columns[1][1] = yy;
elements[2][0] = ox; columns[2][0] = ox;
elements[2][1] = oy; columns[2][1] = oy;
} }
Transform2D(const Vector2 &p_x, const Vector2 &p_y, const Vector2 &p_origin) { Transform2D(const Vector2 &p_x, const Vector2 &p_y, const Vector2 &p_origin) {
elements[0] = p_x; columns[0] = p_x;
elements[1] = p_y; columns[1] = p_y;
elements[2] = p_origin; columns[2] = p_origin;
} }
Transform2D(real_t p_rot, const Vector2 &p_pos); Transform2D(real_t p_rot, const Vector2 &p_pos);
Transform2D() { Transform2D() {
elements[0][0] = 1.0; columns[0][0] = 1.0;
elements[1][1] = 1.0; columns[1][1] = 1.0;
} }
}; };
@ -156,26 +156,26 @@ Vector2 Transform2D::basis_xform(const Vector2 &p_vec) const {
Vector2 Transform2D::basis_xform_inv(const Vector2 &p_vec) const { Vector2 Transform2D::basis_xform_inv(const Vector2 &p_vec) const {
return Vector2( return Vector2(
elements[0].dot(p_vec), columns[0].dot(p_vec),
elements[1].dot(p_vec)); columns[1].dot(p_vec));
} }
Vector2 Transform2D::xform(const Vector2 &p_vec) const { Vector2 Transform2D::xform(const Vector2 &p_vec) const {
return Vector2( return Vector2(
tdotx(p_vec), tdotx(p_vec),
tdoty(p_vec)) + tdoty(p_vec)) +
elements[2]; columns[2];
} }
Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const { Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
Vector2 v = p_vec - elements[2]; Vector2 v = p_vec - columns[2];
return Vector2( return Vector2(
elements[0].dot(v), columns[0].dot(v),
elements[1].dot(v)); columns[1].dot(v));
} }
Rect2 Transform2D::xform(const Rect2 &p_rect) const { Rect2 Transform2D::xform(const Rect2 &p_rect) const {
Vector2 x = elements[0] * p_rect.size.x; Vector2 x = columns[0] * p_rect.size.x;
Vector2 y = elements[1] * p_rect.size.y; Vector2 y = columns[1] * p_rect.size.y;
Vector2 pos = xform(p_rect.position); Vector2 pos = xform(p_rect.position);
Rect2 new_rect; Rect2 new_rect;
@ -187,10 +187,10 @@ Rect2 Transform2D::xform(const Rect2 &p_rect) const {
} }
void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) { void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
elements[0][0] = Math::cos(p_rot) * p_scale.x; columns[0][0] = Math::cos(p_rot) * p_scale.x;
elements[1][1] = Math::cos(p_rot) * p_scale.y; columns[1][1] = Math::cos(p_rot) * p_scale.y;
elements[1][0] = -Math::sin(p_rot) * p_scale.y; columns[1][0] = -Math::sin(p_rot) * p_scale.y;
elements[0][1] = Math::sin(p_rot) * p_scale.x; columns[0][1] = Math::sin(p_rot) * p_scale.x;
} }
Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const { Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const {
@ -218,22 +218,22 @@ Vector2i Transform2D::basis_xform(const Vector2i &p_vec) const {
Vector2i Transform2D::basis_xform_inv(const Vector2i &p_vec) const { Vector2i Transform2D::basis_xform_inv(const Vector2i &p_vec) const {
return Vector2i( return Vector2i(
elements[0].dot(p_vec), columns[0].dot(p_vec),
elements[1].dot(p_vec)); columns[1].dot(p_vec));
} }
Vector2i Transform2D::xform(const Vector2i &p_vec) const { Vector2i Transform2D::xform(const Vector2i &p_vec) const {
return Vector2i( return Vector2i(
tdotx(p_vec), tdotx(p_vec),
tdoty(p_vec)) + tdoty(p_vec)) +
elements[2]; columns[2];
} }
Vector2i Transform2D::xform_inv(const Vector2i &p_vec) const { Vector2i Transform2D::xform_inv(const Vector2i &p_vec) const {
Vector2i v = p_vec - elements[2]; Vector2i v = p_vec - columns[2];
return Vector2i( return Vector2i(
elements[0].dot(v), columns[0].dot(v),
elements[1].dot(v)); columns[1].dot(v));
} }
PoolVector<Vector2> Transform2D::xform(const PoolVector<Vector2> &p_array) const { PoolVector<Vector2> Transform2D::xform(const PoolVector<Vector2> &p_array) const {

30
core/variant.cpp
View File

@ -1651,7 +1651,7 @@ String Variant::stringify(List<const void *> &stack) const {
return "(" + operator Rect2i() + ")"; return "(" + operator Rect2i() + ")";
case TRANSFORM2D: { case TRANSFORM2D: {
Transform2D mat32 = operator Transform2D(); Transform2D mat32 = operator Transform2D();
return "(" + Variant(mat32.elements[0]).operator String() + ", " + Variant(mat32.elements[1]).operator String() + ", " + Variant(mat32.elements[2]).operator String() + ")"; return "(" + Variant(mat32.columns[0]).operator String() + ", " + Variant(mat32.columns[1]).operator String() + ", " + Variant(mat32.columns[2]).operator String() + ")";
} break; } break;
case VECTOR3: case VECTOR3:
return "(" + operator Vector3() + ")"; return "(" + operator Vector3() + ")";
@ -1912,12 +1912,12 @@ Variant::operator Transform() const {
} else if (type == TRANSFORM2D) { } else if (type == TRANSFORM2D) {
const Transform2D &t = *_data._transform2d; const Transform2D &t = *_data._transform2d;
Transform m; Transform m;
m.basis.rows[0][0] = t.elements[0][0]; m.basis.rows[0][0] = t.columns[0][0];
m.basis.rows[1][0] = t.elements[0][1]; m.basis.rows[1][0] = t.columns[0][1];
m.basis.rows[0][1] = t.elements[1][0]; m.basis.rows[0][1] = t.columns[1][0];
m.basis.rows[1][1] = t.elements[1][1]; m.basis.rows[1][1] = t.columns[1][1];
m.origin[0] = t.elements[2][0]; m.origin[0] = t.columns[2][0];
m.origin[1] = t.elements[2][1]; m.origin[1] = t.columns[2][1];
return m; return m;
} else { } else {
return Transform(); return Transform();
@ -1930,12 +1930,12 @@ Variant::operator Transform2D() const {
} else if (type == TRANSFORM) { } else if (type == TRANSFORM) {
const Transform &t = *_data._transform; const Transform &t = *_data._transform;
Transform2D m; Transform2D m;
m.elements[0][0] = t.basis.rows[0][0]; m.columns[0][0] = t.basis.rows[0][0];
m.elements[0][1] = t.basis.rows[1][0]; m.columns[0][1] = t.basis.rows[1][0];
m.elements[1][0] = t.basis.rows[0][1]; m.columns[1][0] = t.basis.rows[0][1];
m.elements[1][1] = t.basis.rows[1][1]; m.columns[1][1] = t.basis.rows[1][1];
m.elements[2][0] = t.origin[0]; m.columns[2][0] = t.origin[0];
m.elements[2][1] = t.origin[1]; m.columns[2][1] = t.origin[1];
return m; return m;
} else { } else {
return Transform2D(); return Transform2D();
@ -2992,7 +2992,7 @@ uint32_t Variant::hash() const {
uint32_t hash = 5831; uint32_t hash = 5831;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
hash = hash_djb2_one_float(_data._transform2d->elements[i][j], hash); hash = hash_djb2_one_float(_data._transform2d->columns[i][j], hash);
} }
} }
@ -3332,7 +3332,7 @@ bool Variant::hash_compare(const Variant &p_variant) const {
Transform2D *r = p_variant._data._transform2d; Transform2D *r = p_variant._data._transform2d;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
if (!(hash_compare_vector2(l->elements[i], r->elements[i]))) { if (!(hash_compare_vector2(l->columns[i], r->columns[i]))) {
return false; return false;
} }
} }

46
core/variant_op.cpp
View File

@ -1497,25 +1497,25 @@ void Variant::set_named(const StringName &p_index, const Variant &p_value, bool
if (p_value.type == Variant::VECTOR2) { if (p_value.type == Variant::VECTOR2) {
Transform2D *v = _data._transform2d; Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) { if (p_index == CoreStringNames::singleton->x) {
v->elements[0] = *reinterpret_cast<const Vector2 *>(p_value._data._mem); v->columns[0] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true; valid = true;
} else if (p_index == CoreStringNames::singleton->y) { } else if (p_index == CoreStringNames::singleton->y) {
v->elements[1] = *reinterpret_cast<const Vector2 *>(p_value._data._mem); v->columns[1] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true; valid = true;
} else if (p_index == CoreStringNames::singleton->origin) { } else if (p_index == CoreStringNames::singleton->origin) {
v->elements[2] = *reinterpret_cast<const Vector2 *>(p_value._data._mem); v->columns[2] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
valid = true; valid = true;
} }
} else if (p_value.type == Variant::VECTOR2I) { } else if (p_value.type == Variant::VECTOR2I) {
Transform2D *v = _data._transform2d; Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) { if (p_index == CoreStringNames::singleton->x) {
v->elements[0] = *reinterpret_cast<const Vector2i *>(p_value._data._mem); v->columns[0] = *reinterpret_cast<const Vector2i *>(p_value._data._mem);
valid = true; valid = true;
} else if (p_index == CoreStringNames::singleton->y) { } else if (p_index == CoreStringNames::singleton->y) {
v->elements[1] = *reinterpret_cast<const Vector2i *>(p_value._data._mem); v->columns[1] = *reinterpret_cast<const Vector2i *>(p_value._data._mem);
valid = true; valid = true;
} else if (p_index == CoreStringNames::singleton->origin) { } else if (p_index == CoreStringNames::singleton->origin) {
v->elements[2] = *reinterpret_cast<const Vector2i *>(p_value._data._mem); v->columns[2] = *reinterpret_cast<const Vector2i *>(p_value._data._mem);
valid = true; valid = true;
} }
} }
@ -1869,11 +1869,11 @@ Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
case TRANSFORM2D: { case TRANSFORM2D: {
const Transform2D *v = _data._transform2d; const Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) { if (p_index == CoreStringNames::singleton->x) {
return v->elements[0]; return v->columns[0];
} else if (p_index == CoreStringNames::singleton->y) { } else if (p_index == CoreStringNames::singleton->y) {
return v->elements[1]; return v->columns[1];
} else if (p_index == CoreStringNames::singleton->origin) { } else if (p_index == CoreStringNames::singleton->origin) {
return v->elements[2]; return v->columns[2];
} }
} break; } break;
@ -2299,7 +2299,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
Transform2D *v = _data._transform2d; Transform2D *v = _data._transform2d;
valid = true; valid = true;
v->elements[index] = p_value; v->columns[index] = p_value;
return; return;
} }
} else if (p_index.get_type() == Variant::STRING) { } else if (p_index.get_type() == Variant::STRING) {
@ -2308,15 +2308,15 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
Transform2D *v = _data._transform2d; Transform2D *v = _data._transform2d;
if (*str == "x") { if (*str == "x") {
valid = true; valid = true;
v->elements[0] = p_value; v->columns[0] = p_value;
return; return;
} else if (*str == "y") { } else if (*str == "y") {
valid = true; valid = true;
v->elements[1] = p_value; v->columns[1] = p_value;
return; return;
} else if (*str == "origin") { } else if (*str == "origin") {
valid = true; valid = true;
v->elements[2] = p_value; v->columns[2] = p_value;
return; return;
} }
} else if (p_index.get_type() == Variant::STRING_NAME) { } else if (p_index.get_type() == Variant::STRING_NAME) {
@ -2325,15 +2325,15 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
Transform2D *v = _data._transform2d; Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) { if (p_index == CoreStringNames::singleton->x) {
valid = true; valid = true;
v->elements[0] = p_value; v->columns[0] = p_value;
return; return;
} else if (p_index == CoreStringNames::singleton->y) { } else if (p_index == CoreStringNames::singleton->y) {
valid = true; valid = true;
v->elements[1] = p_value; v->columns[1] = p_value;
return; return;
} else if (p_index == CoreStringNames::singleton->origin) { } else if (p_index == CoreStringNames::singleton->origin) {
valid = true; valid = true;
v->elements[2] = p_value; v->columns[2] = p_value;
return; return;
} }
} }
@ -3170,7 +3170,7 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
const Transform2D *v = _data._transform2d; const Transform2D *v = _data._transform2d;
valid = true; valid = true;
return v->elements[index]; return v->columns[index];
} }
} else if (p_index.get_type() == Variant::STRING) { } else if (p_index.get_type() == Variant::STRING) {
//scalar name //scalar name
@ -3178,13 +3178,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
const Transform2D *v = _data._transform2d; const Transform2D *v = _data._transform2d;
if (*str == "x") { if (*str == "x") {
valid = true; valid = true;
return v->elements[0]; return v->columns[0];
} else if (*str == "y") { } else if (*str == "y") {
valid = true; valid = true;
return v->elements[1]; return v->columns[1];
} else if (*str == "origin") { } else if (*str == "origin") {
valid = true; valid = true;
return v->elements[2]; return v->columns[2];
} }
} else if (p_index.get_type() == Variant::STRING_NAME) { } else if (p_index.get_type() == Variant::STRING_NAME) {
//scalar name //scalar name
@ -3192,13 +3192,13 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
const Transform2D *v = _data._transform2d; const Transform2D *v = _data._transform2d;
if (p_index == CoreStringNames::singleton->x) { if (p_index == CoreStringNames::singleton->x) {
valid = true; valid = true;
return v->elements[0]; return v->columns[0];
} else if (p_index == CoreStringNames::singleton->y) { } else if (p_index == CoreStringNames::singleton->y) {
valid = true; valid = true;
return v->elements[1]; return v->columns[1];
} else if (p_index == CoreStringNames::singleton->origin) { } else if (p_index == CoreStringNames::singleton->origin) {
valid = true; valid = true;
return v->elements[2]; return v->columns[2];
} }
} }

2
core/variant_parser.cpp
View File

@ -1715,7 +1715,7 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
if (i != 0 || j != 0) { if (i != 0 || j != 0) {
s += ", "; s += ", ";
} }
s += rtos_fix(m3.elements[i][j]); s += rtos_fix(m3.columns[i][j]);
} }
} }

24
drivers/gles2/rasterizer_storage_gles2.cpp
View File

@ -3125,14 +3125,14 @@ void RasterizerStorageGLES2::_multimesh_instance_set_transform_2d(RID p_multimes
int stride = multimesh->color_floats + multimesh->xform_floats + multimesh->custom_data_floats; int stride = multimesh->color_floats + multimesh->xform_floats + multimesh->custom_data_floats;
float *dataptr = &multimesh->data.write[stride * p_index]; float *dataptr = &multimesh->data.write[stride * p_index];
dataptr[0] = p_transform.elements[0][0]; dataptr[0] = p_transform.columns[0][0];
dataptr[1] = p_transform.elements[1][0]; dataptr[1] = p_transform.columns[1][0];
dataptr[2] = 0; dataptr[2] = 0;
dataptr[3] = p_transform.elements[2][0]; dataptr[3] = p_transform.columns[2][0];
dataptr[4] = p_transform.elements[0][1]; dataptr[4] = p_transform.columns[0][1];
dataptr[5] = p_transform.elements[1][1]; dataptr[5] = p_transform.columns[1][1];
dataptr[6] = 0; dataptr[6] = 0;
dataptr[7] = p_transform.elements[2][1]; dataptr[7] = p_transform.columns[2][1];
multimesh->dirty_data = true; multimesh->dirty_data = true;
multimesh->dirty_aabb = true; multimesh->dirty_aabb = true;
@ -3251,12 +3251,12 @@ Transform2D RasterizerStorageGLES2::_multimesh_instance_get_transform_2d(RID p_m
Transform2D xform; Transform2D xform;
xform.elements[0][0] = dataptr[0]; xform.columns[0][0] = dataptr[0];
xform.elements[1][0] = dataptr[1]; xform.columns[1][0] = dataptr[1];
xform.elements[2][0] = dataptr[3]; xform.columns[2][0] = dataptr[3];
xform.elements[0][1] = dataptr[4]; xform.columns[0][1] = dataptr[4];
xform.elements[1][1] = dataptr[5]; xform.columns[1][1] = dataptr[5];
xform.elements[2][1] = dataptr[7]; xform.columns[2][1] = dataptr[7];
return xform; return xform;
} }

20
drivers/gles2/shader_gles2.cpp
View File

@ -785,10 +785,10 @@ void ShaderGLES2::use_material(void *p_material) {
Transform2D tr = V->get(); Transform2D tr = V->get();
GLfloat matrix[4] = { GLfloat matrix[4] = {
/* build a 16x16 matrix */ /* build a 16x16 matrix */
tr.elements[0][0], tr.columns[0][0],
tr.elements[0][1], tr.columns[0][1],
tr.elements[1][0], tr.columns[1][0],
tr.elements[1][1], tr.columns[1][1],
}; };
glUniformMatrix2fv(location, 1, GL_FALSE, matrix); glUniformMatrix2fv(location, 1, GL_FALSE, matrix);
@ -838,20 +838,20 @@ void ShaderGLES2::use_material(void *p_material) {
} else { } else {
Transform2D tr = V->get(); Transform2D tr = V->get();
GLfloat matrix[16] = { /* build a 16x16 matrix */ GLfloat matrix[16] = { /* build a 16x16 matrix */
tr.elements[0][0], tr.columns[0][0],
tr.elements[0][1], tr.columns[0][1],
0, 0,
0, 0,
tr.elements[1][0], tr.columns[1][0],
tr.elements[1][1], tr.columns[1][1],
0, 0,
0, 0,
0, 0,
0, 0,
1, 1,
0, 0,
tr.elements[2][0], tr.columns[2][0],
tr.elements[2][1], tr.columns[2][1],
0, 0,
1 1
}; };

6
drivers/gles_common/batch_diagnose.inc
View File

@ -128,9 +128,9 @@ String get_command_type_string(const RasterizerCanvas::Item::Command &p_command)
const Transform2D &mat = transform->xform; const Transform2D &mat = transform->xform;
sz += " "; sz += " ";
sz += String(Variant(mat.elements[2])); sz += String(Variant(mat.columns[2]));
sz += String(Variant(mat.elements[0])); sz += String(Variant(mat.columns[0]));
sz += String(Variant(mat.elements[1])); sz += String(Variant(mat.columns[1]));
sz += " "; sz += " ";
} break; } break;
case RasterizerCanvas::Item::Command::TYPE_CLIP_IGNORE: { case RasterizerCanvas::Item::Command::TYPE_CLIP_IGNORE: {

24
drivers/gles_common/rasterizer_canvas_batcher.h
View File

@ -633,10 +633,10 @@ protected:
void _software_transform_vertex(Vector2 &r_v, const Transform2D &p_tr) const; void _software_transform_vertex(Vector2 &r_v, const Transform2D &p_tr) const;
TransformMode _find_transform_mode(const Transform2D &p_tr) const { TransformMode _find_transform_mode(const Transform2D &p_tr) const {
// decided whether to do translate only for software transform // decided whether to do translate only for software transform
if ((p_tr.elements[0].x == 1.0f) && if ((p_tr.columns[0].x == 1.0f) &&
(p_tr.elements[0].y == 0.0f) && (p_tr.columns[0].y == 0.0f) &&
(p_tr.elements[1].x == 0.0f) && (p_tr.columns[1].x == 0.0f) &&
(p_tr.elements[1].y == 1.0f)) { (p_tr.columns[1].y == 1.0f)) {
return TM_TRANSLATE; return TM_TRANSLATE;
} }
@ -1649,9 +1649,9 @@ bool C_PREAMBLE::_prefill_polygon(RasterizerCanvas::Item::CommandPolygon *p_poly
// we store the transform as an attribute in the fvf rather than a uniform // we store the transform as an attribute in the fvf rather than a uniform
const Transform2D &tr = r_fill_state.transform_combined; const Transform2D &tr = r_fill_state.transform_combined;
pBT[0].translate.set(tr.elements[2]); pBT[0].translate.set(tr.columns[2]);
pBT[0].basis[0].set(tr.elements[0][0], tr.elements[0][1]); pBT[0].basis[0].set(tr.columns[0][0], tr.columns[0][1]);
pBT[0].basis[1].set(tr.elements[1][0], tr.elements[1][1]); pBT[0].basis[1].set(tr.columns[1][0], tr.columns[1][1]);
} }
//////////////////////////////////// ////////////////////////////////////
@ -2168,10 +2168,10 @@ bool C_PREAMBLE::_prefill_rect(RasterizerCanvas::Item::CommandRect *rect, FillSt
const Transform2D &tr = r_fill_state.transform_combined; const Transform2D &tr = r_fill_state.transform_combined;
pBT[0].translate.set(tr.elements[2]); pBT[0].translate.set(tr.columns[2]);
pBT[0].basis[0].set(tr.elements[0][0], tr.elements[0][1]); pBT[0].basis[0].set(tr.columns[0][0], tr.columns[0][1]);
pBT[0].basis[1].set(tr.elements[1][0], tr.elements[1][1]); pBT[0].basis[1].set(tr.columns[1][0], tr.columns[1][1]);
pBT[1] = pBT[0]; pBT[1] = pBT[0];
pBT[2] = pBT[0]; pBT[2] = pBT[0];
@ -2193,11 +2193,11 @@ bool C_PREAMBLE::_prefill_rect(RasterizerCanvas::Item::CommandRect *rect, FillSt
// apply to an x axis // apply to an x axis
// the x axis and y axis can be taken directly from the transform (no need to xform identity vectors) // the x axis and y axis can be taken directly from the transform (no need to xform identity vectors)
Vector2 x_axis(tr.elements[0][0], tr.elements[0][1]); Vector2 x_axis(tr.columns[0][0], tr.columns[0][1]);
// have to do a y axis to check for scaling flips // have to do a y axis to check for scaling flips
// this is hassle and extra slowness. We could only allow flips via the flags. // this is hassle and extra slowness. We could only allow flips via the flags.
Vector2 y_axis(tr.elements[1][0], tr.elements[1][1]); Vector2 y_axis(tr.columns[1][0], tr.columns[1][1]);
// has the x / y axis flipped due to scaling? // has the x / y axis flipped due to scaling?
float cross = x_axis.cross(y_axis); float cross = x_axis.cross(y_axis);

6
editor/plugins/animation_state_machine_editor.cpp
View File

@ -542,9 +542,9 @@ void AnimationNodeStateMachineEditor::_connection_draw(const Vector2 &p_from, co
Ref<Texture> icon = icons[p_mode + (p_auto_advance ? 3 : 0)]; Ref<Texture> icon = icons[p_mode + (p_auto_advance ? 3 : 0)];
Transform2D xf; Transform2D xf;
xf.elements[0] = (p_to - p_from).normalized(); xf.columns[0] = (p_to - p_from).normalized();
xf.elements[1] = xf.elements[0].tangent(); xf.columns[1] = xf.columns[0].tangent();
xf.elements[2] = (p_from + p_to) * 0.5 - xf.elements[1] * icon->get_height() * 0.5 - xf.elements[0] * icon->get_height() * 0.5; xf.columns[2] = (p_from + p_to) * 0.5 - xf.columns[1] * icon->get_height() * 0.5 - xf.columns[0] * icon->get_height() * 0.5;
state_machine_draw->draw_set_transform_matrix(xf); state_machine_draw->draw_set_transform_matrix(xf);
state_machine_draw->draw_texture(icon, Vector2(), icon_color); state_machine_draw->draw_texture(icon, Vector2(), icon_color);

2
editor/plugins/canvas_item_editor_plugin.cpp
View File

@ -3975,7 +3975,7 @@ void CanvasItemEditor::_draw_viewport() {
// Update the transform // Update the transform
transform = Transform2D(); transform = Transform2D();
transform.scale_basis(Size2(zoom, zoom)); transform.scale_basis(Size2(zoom, zoom));
transform.elements[2] = -view_offset * zoom; transform.columns[2] = -view_offset * zoom;
editor->get_scene_root()->set_global_canvas_transform(transform); editor->get_scene_root()->set_global_canvas_transform(transform);
// hide/show buttons depending on the selection // hide/show buttons depending on the selection

4
editor/plugins/canvas_item_editor_plugin.h
View File

@ -611,13 +611,13 @@ protected:
struct compare_items_x { struct compare_items_x {
bool operator()(const CanvasItem *a, const CanvasItem *b) const { bool operator()(const CanvasItem *a, const CanvasItem *b) const {
return a->get_global_transform().elements[2].x < b->get_global_transform().elements[2].x; return a->get_global_transform().columns[2].x < b->get_global_transform().columns[2].x;
} }
}; };
struct compare_items_y { struct compare_items_y {
bool operator()(const CanvasItem *a, const CanvasItem *b) const { bool operator()(const CanvasItem *a, const CanvasItem *b) const {
return a->get_global_transform().elements[2].y < b->get_global_transform().elements[2].y; return a->get_global_transform().columns[2].y < b->get_global_transform().columns[2].y;
} }
}; };

4
editor/plugins/polygon_2d_editor_plugin.cpp
View File

@ -478,7 +478,7 @@ void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) {
} }
Transform2D mtx; Transform2D mtx;
mtx.elements[2] = -uv_draw_ofs; mtx.columns[2] = -uv_draw_ofs;
mtx.scale_basis(Vector2(uv_draw_zoom, uv_draw_zoom)); mtx.scale_basis(Vector2(uv_draw_zoom, uv_draw_zoom));
Ref<InputEventMouseButton> mb = p_input; Ref<InputEventMouseButton> mb = p_input;
@ -986,7 +986,7 @@ void Polygon2DEditor::_uv_draw() {
String warning; String warning;
Transform2D mtx; Transform2D mtx;
mtx.elements[2] = -uv_draw_ofs; mtx.columns[2] = -uv_draw_ofs;
mtx.scale_basis(Vector2(uv_draw_zoom, uv_draw_zoom)); mtx.scale_basis(Vector2(uv_draw_zoom, uv_draw_zoom));
VS::get_singleton()->canvas_item_add_set_transform(uv_edit_draw->get_canvas_item(), mtx); VS::get_singleton()->canvas_item_add_set_transform(uv_edit_draw->get_canvas_item(), mtx);

4
editor/plugins/texture_region_editor_plugin.cpp
View File

@ -108,7 +108,7 @@ void TextureRegionEditor::_region_draw() {
} }
Transform2D mtx; Transform2D mtx;
mtx.elements[2] = -draw_ofs * draw_zoom; mtx.columns[2] = -draw_ofs * draw_zoom;
mtx.scale_basis(Vector2(draw_zoom, draw_zoom)); mtx.scale_basis(Vector2(draw_zoom, draw_zoom));
VS::get_singleton()->canvas_item_add_set_transform(edit_draw->get_canvas_item(), mtx); VS::get_singleton()->canvas_item_add_set_transform(edit_draw->get_canvas_item(), mtx);
@ -294,7 +294,7 @@ void TextureRegionEditor::_region_draw() {
void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) { void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) {
Transform2D mtx; Transform2D mtx;
mtx.elements[2] = -draw_ofs * draw_zoom; mtx.columns[2] = -draw_ofs * draw_zoom;
mtx.scale_basis(Vector2(draw_zoom, draw_zoom)); mtx.scale_basis(Vector2(draw_zoom, draw_zoom));
const real_t handle_radius = 8 * EDSCALE; const real_t handle_radius = 8 * EDSCALE;

4
editor/property_editor.cpp
View File

@ -807,7 +807,7 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
Transform2D t = v; Transform2D t = v;
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
value_editor[i]->set_text(String::num(t.elements[i / 2][i % 2])); value_editor[i]->set_text(String::num(t.columns[i / 2][i % 2]));
} }
} break; } break;
@ -1581,7 +1581,7 @@ void CustomPropertyEditor::_modified(String p_string) {
case Variant::TRANSFORM2D: { case Variant::TRANSFORM2D: {
Transform2D m; Transform2D m;
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
m.elements[i / 2][i % 2] = _parse_real_expression(value_editor[i]->get_text()); m.columns[i / 2][i % 2] = _parse_real_expression(value_editor[i]->get_text());
} }
v = m; v = m;

2
editor/script_editor_debugger.cpp
View File

@ -1375,7 +1375,7 @@ void ScriptEditorDebugger::_notification(int p_what) {
Transform2D transform; Transform2D transform;
transform.scale_basis(Size2(zoom, zoom)); transform.scale_basis(Size2(zoom, zoom));
transform.elements[2] = -offset * zoom; transform.columns[2] = -offset * zoom;
Array msg; Array msg;
msg.push_back("override_camera_2D:transform"); msg.push_back("override_camera_2D:transform");

12
gles_builders.py
View File

@ -329,20 +329,20 @@ def build_legacygl_header(filename, include, class_suffix, output_attribs, gles2
const Transform2D &tr = p_transform; const Transform2D &tr = p_transform;
GLfloat matrix[16]={ /* build a 16x16 matrix */ GLfloat matrix[16]={ /* build a 16x16 matrix */
tr.elements[0][0], tr.columns[0][0],
tr.elements[0][1], tr.columns[0][1],
0, 0,
0, 0,
tr.elements[1][0], tr.columns[1][0],
tr.elements[1][1], tr.columns[1][1],
0, 0,
0, 0,
0, 0,
0, 0,
1, 1,
0, 0,
tr.elements[2][0], tr.columns[2][0],
tr.elements[2][1], tr.columns[2][1],
0, 0,
1 1
}; };

2
main/tests/test_physics_2d.cpp
View File

@ -336,7 +336,7 @@ public:
Transform2D smaller; Transform2D smaller;
//smaller.scale(Vector2(0.6,0.6)); //smaller.scale(Vector2(0.6,0.6));
//smaller.elements[2]=Vector2(100,0); //smaller.columns[2]=Vector2(100,0);
//view_xform = smaller; //view_xform = smaller;
vs->viewport_set_canvas_transform(vp, canvas, view_xform); vs->viewport_set_canvas_transform(vp, canvas, view_xform);

6
modules/network_synchronizer/scene_synchronizer.cpp
View File

@ -1328,9 +1328,9 @@ bool SceneSynchronizer::compare(const Variant &p_first, const Variant &p_second,
case Variant::TRANSFORM2D: { case Variant::TRANSFORM2D: {
const Transform2D a(p_first); const Transform2D a(p_first);
const Transform2D b(p_second); const Transform2D b(p_second);
if (compare(a.elements[0], b.elements[0], p_tolerance)) { if (compare(a.columns[0], b.columns[0], p_tolerance)) {
if (compare(a.elements[1], b.elements[1], p_tolerance)) { if (compare(a.columns[1], b.columns[1], p_tolerance)) {
if (compare(a.elements[2], b.elements[2], p_tolerance)) { if (compare(a.columns[2], b.columns[2], p_tolerance)) {
return true; return true;
} }
} }

14
modules/rtile_map/tile_map.cpp
View File

@ -271,15 +271,15 @@ void RTileMap::_fix_cell_transform(Transform2D &xform, const Cell &p_cell, const
} }
if (p_cell.transpose) { if (p_cell.transpose) {
SWAP(xform.elements[0].x, xform.elements[0].y); SWAP(xform.columns[0].x, xform.columns[0].y);
SWAP(xform.elements[1].x, xform.elements[1].y); SWAP(xform.columns[1].x, xform.columns[1].y);
SWAP(offset.x, offset.y); SWAP(offset.x, offset.y);
SWAP(s.x, s.y); SWAP(s.x, s.y);
} }
if (p_cell.flip_h) { if (p_cell.flip_h) {
xform.elements[0].x = -xform.elements[0].x; xform.columns[0].x = -xform.columns[0].x;
xform.elements[1].x = -xform.elements[1].x; xform.columns[1].x = -xform.columns[1].x;
if (compatibility_mode && !centered_textures) { if (compatibility_mode && !centered_textures) {
if (tile_origin == TILE_ORIGIN_TOP_LEFT || tile_origin == TILE_ORIGIN_BOTTOM_LEFT) { if (tile_origin == TILE_ORIGIN_TOP_LEFT || tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
offset.x = s.x - offset.x; offset.x = s.x - offset.x;
@ -292,8 +292,8 @@ void RTileMap::_fix_cell_transform(Transform2D &xform, const Cell &p_cell, const
} }
if (p_cell.flip_v) { if (p_cell.flip_v) {
xform.elements[0].y = -xform.elements[0].y; xform.columns[0].y = -xform.columns[0].y;
xform.elements[1].y = -xform.elements[1].y; xform.columns[1].y = -xform.columns[1].y;
if (compatibility_mode && !centered_textures) { if (compatibility_mode && !centered_textures) {
if (tile_origin == TILE_ORIGIN_TOP_LEFT) { if (tile_origin == TILE_ORIGIN_TOP_LEFT) {
offset.y = s.y - offset.y; offset.y = s.y - offset.y;
@ -310,7 +310,7 @@ void RTileMap::_fix_cell_transform(Transform2D &xform, const Cell &p_cell, const
if (centered_textures) { if (centered_textures) {
offset += cell_size / 2 - s / 2; offset += cell_size / 2 - s / 2;
} }
xform.elements[2] += offset; xform.columns[2] += offset;
} }
void RTileMap::_add_shape(int &shape_idx, const Quadrant &p_q, const Ref<Shape2D> &p_shape, const RTileSet::ShapeData &p_shape_data, const Transform2D &p_xform, const Vector2 &p_metadata) { void RTileMap::_add_shape(int &shape_idx, const Quadrant &p_q, const Ref<Shape2D> &p_shape, const RTileSet::ShapeData &p_shape_data, const Transform2D &p_xform, const Vector2 &p_metadata) {

36
scene/2d/cpu_particles_2d.cpp
View File

@ -915,13 +915,13 @@ void CPUParticles2D::_particles_process(float p_delta) {
if (flags[FLAG_ALIGN_Y_TO_VELOCITY]) { if (flags[FLAG_ALIGN_Y_TO_VELOCITY]) {
if (p.velocity.length() > 0.0) { if (p.velocity.length() > 0.0) {
p.transform.elements[1] = p.velocity.normalized(); p.transform.columns[1] = p.velocity.normalized();
p.transform.elements[0] = p.transform.elements[1].tangent(); p.transform.columns[0] = p.transform.columns[1].tangent();
} }
} else { } else {
p.transform.elements[0] = Vector2(Math::cos(p.rotation), -Math::sin(p.rotation)); p.transform.columns[0] = Vector2(Math::cos(p.rotation), -Math::sin(p.rotation));
p.transform.elements[1] = Vector2(Math::sin(p.rotation), Math::cos(p.rotation)); p.transform.columns[1] = Vector2(Math::sin(p.rotation), Math::cos(p.rotation));
} }
//scale by scale //scale by scale
@ -930,8 +930,8 @@ void CPUParticles2D::_particles_process(float p_delta) {
base_scale = 0.000001; base_scale = 0.000001;
} }
p.transform.elements[0] *= base_scale; p.transform.columns[0] *= base_scale;
p.transform.elements[1] *= base_scale; p.transform.columns[1] *= base_scale;
p.transform[2] += p.velocity * local_delta; p.transform[2] += p.velocity * local_delta;
} }
@ -974,14 +974,14 @@ void CPUParticles2D::_update_particle_data_buffer() {
} }
if (r[idx].active) { if (r[idx].active) {
ptr[0] = t.elements[0][0]; ptr[0] = t.columns[0][0];
ptr[1] = t.elements[1][0]; ptr[1] = t.columns[1][0];
ptr[2] = 0; ptr[2] = 0;
ptr[3] = t.elements[2][0]; ptr[3] = t.columns[2][0];
ptr[4] = t.elements[0][1]; ptr[4] = t.columns[0][1];
ptr[5] = t.elements[1][1]; ptr[5] = t.columns[1][1];
ptr[6] = 0; ptr[6] = 0;
ptr[7] = t.elements[2][1]; ptr[7] = t.columns[2][1];
Color c = r[idx].color; Color c = r[idx].color;
uint8_t *data8 = (uint8_t *)&ptr[8]; uint8_t *data8 = (uint8_t *)&ptr[8];
@ -1087,14 +1087,14 @@ void CPUParticles2D::_notification(int p_what) {
Transform2D t = inv_emission_transform * r[i].transform; Transform2D t = inv_emission_transform * r[i].transform;
if (r[i].active) { if (r[i].active) {
ptr[0] = t.elements[0][0]; ptr[0] = t.columns[0][0];
ptr[1] = t.elements[1][0]; ptr[1] = t.columns[1][0];
ptr[2] = 0; ptr[2] = 0;
ptr[3] = t.elements[2][0]; ptr[3] = t.columns[2][0];
ptr[4] = t.elements[0][1]; ptr[4] = t.columns[0][1];
ptr[5] = t.elements[1][1]; ptr[5] = t.columns[1][1];
ptr[6] = 0; ptr[6] = 0;
ptr[7] = t.elements[2][1]; ptr[7] = t.columns[2][1];
} else { } else {
memset(ptr, 0, sizeof(float) * 8); memset(ptr, 0, sizeof(float) * 8);

4
scene/2d/node_2d.cpp
View File

@ -126,7 +126,7 @@ void Node2D::_edit_set_rect(const Rect2 &p_edit_rect) {
#endif #endif
void Node2D::_update_xform_values() { void Node2D::_update_xform_values() {
pos = _mat.elements[2]; pos = _mat.columns[2];
angle = _mat.get_rotation(); angle = _mat.get_rotation();
_scale = _mat.get_scale(); _scale = _mat.get_scale();
_xform_dirty = false; _xform_dirty = false;
@ -134,7 +134,7 @@ void Node2D::_update_xform_values() {
void Node2D::_update_transform() { void Node2D::_update_transform() {
_mat.set_rotation_and_scale(angle, _scale); _mat.set_rotation_and_scale(angle, _scale);
_mat.elements[2] = pos; _mat.columns[2] = pos;
VisualServer::get_singleton()->canvas_item_set_transform(get_canvas_item(), _mat); VisualServer::get_singleton()->canvas_item_set_transform(get_canvas_item(), _mat);

14
scene/2d/physics_body_2d.cpp
View File

@ -813,7 +813,7 @@ String RigidBody2D::get_configuration_warning() const {
String warning = CollisionObject2D::get_configuration_warning(); String warning = CollisionObject2D::get_configuration_warning();
if ((get_mode() == MODE_RIGID || get_mode() == MODE_CHARACTER) && (ABS(t.elements[0].length() - 1.0) > 0.05 || ABS(t.elements[1].length() - 1.0) > 0.05)) { if ((get_mode() == MODE_RIGID || get_mode() == MODE_CHARACTER) && (ABS(t.columns[0].length() - 1.0) > 0.05 || ABS(t.columns[1].length() - 1.0) > 0.05)) {
if (warning != String()) { if (warning != String()) {
warning += "\n\n"; warning += "\n\n";
} }
@ -1028,7 +1028,7 @@ bool KinematicBody2D::separate_raycast_shapes(bool p_infinite_inertia, Collision
} }
} }
gt.elements[2] += recover; gt.columns[2] += recover;
set_global_transform(gt); set_global_transform(gt);
if (deepest != -1) { if (deepest != -1) {
@ -1111,7 +1111,7 @@ bool KinematicBody2D::move_and_collide(const Vector2 &p_motion, bool p_infinite_
} }
if (!p_test_only) { if (!p_test_only) {
gt.elements[2] += result.motion; gt.columns[2] += result.motion;
set_global_transform(gt); set_global_transform(gt);
} }
@ -1136,7 +1136,7 @@ Vector2 KinematicBody2D::_move_and_slide_internal(const Vector2 &p_linear_veloci
Physics2DDirectBodyState *bs = Physics2DServer::get_singleton()->body_get_direct_state(on_floor_body); Physics2DDirectBodyState *bs = Physics2DServer::get_singleton()->body_get_direct_state(on_floor_body);
if (bs) { if (bs) {
Transform2D gt = get_global_transform(); Transform2D gt = get_global_transform();
Vector2 local_position = gt.elements[2] - bs->get_transform().elements[2]; Vector2 local_position = gt.columns[2] - bs->get_transform().columns[2];
current_floor_velocity = bs->get_velocity_at_local_position(local_position); current_floor_velocity = bs->get_velocity_at_local_position(local_position);
} else { } else {
// Body is removed or destroyed, invalidate floor. // Body is removed or destroyed, invalidate floor.
@ -1198,9 +1198,9 @@ Vector2 KinematicBody2D::_move_and_slide_internal(const Vector2 &p_linear_veloci
if ((body_velocity_normal + up_direction).length() < 0.01) { if ((body_velocity_normal + up_direction).length() < 0.01) {
Transform2D gt = get_global_transform(); Transform2D gt = get_global_transform();
if (collision.travel.length() > margin) { if (collision.travel.length() > margin) {
gt.elements[2] -= collision.travel.slide(up_direction); gt.columns[2] -= collision.travel.slide(up_direction);
} else { } else {
gt.elements[2] -= collision.travel; gt.columns[2] -= collision.travel;
} }
set_global_transform(gt); set_global_transform(gt);
return Vector2(); return Vector2();
@ -1251,7 +1251,7 @@ Vector2 KinematicBody2D::_move_and_slide_internal(const Vector2 &p_linear_veloci
} }
if (apply) { if (apply) {
gt.elements[2] += col.travel; gt.columns[2] += col.travel;
set_global_transform(gt); set_global_transform(gt);
} }
} }

26
scene/animation/scene_tree_tween.cpp
View File

@ -355,7 +355,7 @@ Variant SceneTreeTween::interpolate_variant(Variant p_initial_val, Variant p_del
ERR_FAIL_INDEX_V(p_trans, Tween::TRANS_COUNT, Variant()); ERR_FAIL_INDEX_V(p_trans, Tween::TRANS_COUNT, Variant());
ERR_FAIL_INDEX_V(p_ease, Tween::EASE_COUNT, Variant()); ERR_FAIL_INDEX_V(p_ease, Tween::EASE_COUNT, Variant());
// Helper macro to run equation on sub-elements of the value (e.g. x and y of Vector2). // Helper macro to run equation on sub-columns of the value (e.g. x and y of Vector2).
#define APPLY_EQUATION(element) \ #define APPLY_EQUATION(element) \
r.element = Tween::run_equation(p_trans, p_ease, p_time, i.element, d.element, p_duration); r.element = Tween::run_equation(p_trans, p_ease, p_time, i.element, d.element, p_duration);
@ -410,12 +410,12 @@ Variant SceneTreeTween::interpolate_variant(Variant p_initial_val, Variant p_del
Transform2D d = p_delta_val; Transform2D d = p_delta_val;
Transform2D r; Transform2D r;
APPLY_EQUATION(elements[0][0]); APPLY_EQUATION(columns[0][0]);
APPLY_EQUATION(elements[0][1]); APPLY_EQUATION(columns[0][1]);
APPLY_EQUATION(elements[1][0]); APPLY_EQUATION(columns[1][0]);
APPLY_EQUATION(elements[1][1]); APPLY_EQUATION(columns[1][1]);
APPLY_EQUATION(elements[2][0]); APPLY_EQUATION(columns[2][0]);
APPLY_EQUATION(elements[2][1]); APPLY_EQUATION(columns[2][1]);
return r; return r;
} }
@ -518,12 +518,12 @@ Variant SceneTreeTween::calculate_delta_value(Variant p_intial_val, Variant p_fi
case Variant::TRANSFORM2D: { case Variant::TRANSFORM2D: {
Transform2D i = p_intial_val; Transform2D i = p_intial_val;
Transform2D f = p_final_val; Transform2D f = p_final_val;
return Transform2D(f.elements[0][0] - i.elements[0][0], return Transform2D(f.columns[0][0] - i.columns[0][0],
f.elements[0][1] - i.elements[0][1], f.columns[0][1] - i.columns[0][1],
f.elements[1][0] - i.elements[1][0], f.columns[1][0] - i.columns[1][0],
f.elements[1][1] - i.elements[1][1], f.columns[1][1] - i.columns[1][1],
f.elements[2][0] - i.elements[2][0], f.columns[2][0] - i.columns[2][0],
f.elements[2][1] - i.elements[2][1]); f.columns[2][1] - i.columns[2][1]);
} }
case Variant::AABB: { case Variant::AABB: {

24
scene/animation/tween.cpp
View File

@ -538,12 +538,12 @@ Variant Tween::_run_equation(InterpolateData &p_data) {
// Execute the equation on the transforms and mutate the r transform // Execute the equation on the transforms and mutate the r transform
// This uses the custom APPLY_EQUATION macro defined above // This uses the custom APPLY_EQUATION macro defined above
APPLY_EQUATION(elements[0][0]); APPLY_EQUATION(columns[0][0]);
APPLY_EQUATION(elements[0][1]); APPLY_EQUATION(columns[0][1]);
APPLY_EQUATION(elements[1][0]); APPLY_EQUATION(columns[1][0]);
APPLY_EQUATION(elements[1][1]); APPLY_EQUATION(columns[1][1]);
APPLY_EQUATION(elements[2][0]); APPLY_EQUATION(columns[2][0]);
APPLY_EQUATION(elements[2][1]); APPLY_EQUATION(columns[2][1]);
result = r; result = r;
} break; } break;
@ -1249,12 +1249,12 @@ bool Tween::_calc_delta_val(const Variant &p_initial_val, const Variant &p_final
Transform2D i = initial_val; Transform2D i = initial_val;
Transform2D f = final_val; Transform2D f = final_val;
Transform2D d = Transform2D(); Transform2D d = Transform2D();
d[0][0] = f.elements[0][0] - i.elements[0][0]; d[0][0] = f.columns[0][0] - i.columns[0][0];
d[0][1] = f.elements[0][1] - i.elements[0][1]; d[0][1] = f.columns[0][1] - i.columns[0][1];
d[1][0] = f.elements[1][0] - i.elements[1][0]; d[1][0] = f.columns[1][0] - i.columns[1][0];
d[1][1] = f.elements[1][1] - i.elements[1][1]; d[1][1] = f.columns[1][1] - i.columns[1][1];
d[2][0] = f.elements[2][0] - i.elements[2][0]; d[2][0] = f.columns[2][0] - i.columns[2][0];
d[2][1] = f.elements[2][1] - i.elements[2][1]; d[2][1] = f.columns[2][1] - i.columns[2][1];
delta_val = d; delta_val = d;
} break; } break;

2
scene/main/canvas_layer.cpp
View File

@ -92,7 +92,7 @@ void CanvasLayer::_update_xform() {
} }
void CanvasLayer::_update_locrotscale() { void CanvasLayer::_update_locrotscale() {
ofs = transform.elements[2]; ofs = transform.columns[2];
rot = transform.get_rotation(); rot = transform.get_rotation();
scale = transform.get_scale(); scale = transform.get_scale();
locrotscale_dirty = false; locrotscale_dirty = false;

4
scene/main/viewport.cpp
View File

@ -208,7 +208,7 @@ void Viewport::_update_stretch_transform() {
stretch_transform = Transform2D(); stretch_transform = Transform2D();
Size2 scale = size / (size_override_size + size_override_margin * 2); Size2 scale = size / (size_override_size + size_override_margin * 2);
stretch_transform.scale(scale); stretch_transform.scale(scale);
stretch_transform.elements[2] = size_override_margin * scale; stretch_transform.columns[2] = size_override_margin * scale;
} else { } else {
stretch_transform = Transform2D(); stretch_transform = Transform2D();
@ -1375,7 +1375,7 @@ Transform2D Viewport::_get_input_pre_xform() const {
Transform2D pre_xf; Transform2D pre_xf;
if (to_screen_rect != Rect2()) { if (to_screen_rect != Rect2()) {
pre_xf.elements[2] = -to_screen_rect.position; pre_xf.columns[2] = -to_screen_rect.position;
pre_xf.scale(size / to_screen_rect.size); pre_xf.scale(size / to_screen_rect.size);
} }

12
scene/resources/multimesh.cpp
View File

@ -98,9 +98,9 @@ void MultiMesh::_set_transform_2d_array(const PoolVector<Vector2> &p_array) {
for (int i = 0; i < len / 3; i++) { for (int i = 0; i < len / 3; i++) {
Transform2D t; Transform2D t;
t.elements[0] = r[i * 3 + 0]; t.columns[0] = r[i * 3 + 0];
t.elements[1] = r[i * 3 + 1]; t.columns[1] = r[i * 3 + 1];
t.elements[2] = r[i * 3 + 2]; t.columns[2] = r[i * 3 + 2];
set_instance_transform_2d(i, t); set_instance_transform_2d(i, t);
} }
@ -122,9 +122,9 @@ PoolVector<Vector2> MultiMesh::_get_transform_2d_array() const {
for (int i = 0; i < instance_count; i++) { for (int i = 0; i < instance_count; i++) {
Transform2D t = get_instance_transform_2d(i); Transform2D t = get_instance_transform_2d(i);
w[i * 3 + 0] = t.elements[0]; w[i * 3 + 0] = t.columns[0];
w[i * 3 + 1] = t.elements[1]; w[i * 3 + 1] = t.columns[1];
w[i * 3 + 2] = t.elements[2]; w[i * 3 + 2] = t.columns[2];
} }
return xforms; return xforms;

12
scene/resources/texture.cpp
View File

@ -1153,8 +1153,8 @@ void MeshTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_mo
Transform2D xform; Transform2D xform;
xform.set_origin(p_pos); xform.set_origin(p_pos);
if (p_transpose) { if (p_transpose) {
SWAP(xform.elements[0][1], xform.elements[1][0]); SWAP(xform.columns[0][1], xform.columns[1][0]);
SWAP(xform.elements[0][0], xform.elements[1][1]); SWAP(xform.columns[0][0], xform.columns[1][1]);
} }
RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID(); RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
VisualServer::get_singleton()->canvas_item_add_mesh(p_canvas_item, mesh->get_rid(), xform, p_modulate, base_texture->get_rid(), normal_rid); VisualServer::get_singleton()->canvas_item_add_mesh(p_canvas_item, mesh->get_rid(), xform, p_modulate, base_texture->get_rid(), normal_rid);
@ -1175,8 +1175,8 @@ void MeshTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile,
xform.set_scale(p_rect.size / size); xform.set_scale(p_rect.size / size);
if (p_transpose) { if (p_transpose) {
SWAP(xform.elements[0][1], xform.elements[1][0]); SWAP(xform.columns[0][1], xform.columns[1][0]);
SWAP(xform.elements[0][0], xform.elements[1][1]); SWAP(xform.columns[0][0], xform.columns[1][1]);
} }
RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID(); RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
VisualServer::get_singleton()->canvas_item_add_mesh(p_canvas_item, mesh->get_rid(), xform, p_modulate, base_texture->get_rid(), normal_rid); VisualServer::get_singleton()->canvas_item_add_mesh(p_canvas_item, mesh->get_rid(), xform, p_modulate, base_texture->get_rid(), normal_rid);
@ -1197,8 +1197,8 @@ void MeshTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const
xform.set_scale(p_rect.size / size); xform.set_scale(p_rect.size / size);
if (p_transpose) { if (p_transpose) {
SWAP(xform.elements[0][1], xform.elements[1][0]); SWAP(xform.columns[0][1], xform.columns[1][0]);
SWAP(xform.elements[0][0], xform.elements[1][1]); SWAP(xform.columns[0][0], xform.columns[1][1]);
} }
RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID(); RID normal_rid = p_normal_map.is_valid() ? p_normal_map->get_rid() : RID();
VisualServer::get_singleton()->canvas_item_add_mesh(p_canvas_item, mesh->get_rid(), xform, p_modulate, base_texture->get_rid(), normal_rid); VisualServer::get_singleton()->canvas_item_add_mesh(p_canvas_item, mesh->get_rid(), xform, p_modulate, base_texture->get_rid(), normal_rid);

2
servers/physics_2d/body_pair_2d_sw.cpp
View File

@ -246,7 +246,7 @@ bool BodyPair2DSW::setup(real_t p_step) {
Transform2D xform_A = xform_Au * A->get_shape_transform(shape_A); Transform2D xform_A = xform_Au * A->get_shape_transform(shape_A);
Transform2D xform_Bu = B->get_transform(); Transform2D xform_Bu = B->get_transform();
xform_Bu.elements[2] -= A->get_transform().get_origin(); xform_Bu.columns[2] -= A->get_transform().get_origin();
Transform2D xform_B = xform_Bu * B->get_shape_transform(shape_B); Transform2D xform_B = xform_Bu * B->get_shape_transform(shape_B);
Shape2DSW *shape_A_ptr = A->get_shape(shape_A); Shape2DSW *shape_A_ptr = A->get_shape(shape_A);

66
servers/physics_2d/collision_solver_2d_sat.cpp
View File

@ -485,11 +485,11 @@ static void _collision_segment_rectangle(const Shape2DSW *p_a, const Transform2D
return; return;
} }
if (!separator.test_axis(p_transform_b.elements[0].normalized())) { if (!separator.test_axis(p_transform_b.columns[0].normalized())) {
return; return;
} }
if (!separator.test_axis(p_transform_b.elements[1].normalized())) { if (!separator.test_axis(p_transform_b.columns[1].normalized())) {
return; return;
} }
@ -556,20 +556,20 @@ static void _collision_segment_capsule(const Shape2DSW *p_a, const Transform2D &
return; return;
} }
if (!separator.test_axis(p_transform_b.elements[0].normalized())) { if (!separator.test_axis(p_transform_b.columns[0].normalized())) {
return; return;
} }
if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5))) { if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * 0.5))) {
return; return;
} }
if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5))) { if (TEST_POINT(p_transform_a.xform(segment_A->get_a()), (p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * -0.5))) {
return; return;
} }
if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5))) { if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * 0.5))) {
return; return;
} }
if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5))) { if (TEST_POINT(p_transform_a.xform(segment_A->get_b()), (p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * -0.5))) {
return; return;
} }
@ -652,8 +652,8 @@ static void _collision_circle_rectangle(const Shape2DSW *p_a, const Transform2D
return; return;
} }
const Vector2 &sphere = p_transform_a.elements[2]; const Vector2 &sphere = p_transform_a.columns[2];
const Vector2 *axis = &p_transform_b.elements[0]; const Vector2 *axis = &p_transform_b.columns[0];
//const Vector2& half_extents = rectangle_B->get_half_extents(); //const Vector2& half_extents = rectangle_B->get_half_extents();
if (!separator.test_axis(axis[0].normalized())) { if (!separator.test_axis(axis[0].normalized())) {
@ -711,15 +711,15 @@ static void _collision_circle_capsule(const Shape2DSW *p_a, const Transform2D &p
} }
//capsule axis //capsule axis
if (!separator.test_axis(p_transform_b.elements[0].normalized())) { if (!separator.test_axis(p_transform_b.columns[0].normalized())) {
return; return;
} }
//capsule endpoints //capsule endpoints
if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * 0.5))) { if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * 0.5))) {
return; return;
} }
if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * -0.5))) { if (TEST_POINT(p_transform_a.get_origin(), (p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * -0.5))) {
return; return;
} }
@ -773,20 +773,20 @@ static void _collision_rectangle_rectangle(const Shape2DSW *p_a, const Transform
} }
//box faces A //box faces A
if (!separator.test_axis(p_transform_a.elements[0].normalized())) { if (!separator.test_axis(p_transform_a.columns[0].normalized())) {
return; return;
} }
if (!separator.test_axis(p_transform_a.elements[1].normalized())) { if (!separator.test_axis(p_transform_a.columns[1].normalized())) {
return; return;
} }
//box faces B //box faces B
if (!separator.test_axis(p_transform_b.elements[0].normalized())) { if (!separator.test_axis(p_transform_b.columns[0].normalized())) {
return; return;
} }
if (!separator.test_axis(p_transform_b.elements[1].normalized())) { if (!separator.test_axis(p_transform_b.columns[1].normalized())) {
return; return;
} }
@ -800,10 +800,10 @@ static void _collision_rectangle_rectangle(const Shape2DSW *p_a, const Transform
if (castA || castB) { if (castA || castB) {
Transform2D aofs = p_transform_a; Transform2D aofs = p_transform_a;
aofs.elements[2] += p_motion_a; aofs.columns[2] += p_motion_a;
Transform2D bofs = p_transform_b; Transform2D bofs = p_transform_b;
bofs.elements[2] += p_motion_b; bofs.columns[2] += p_motion_b;
Transform2D aofsinv = aofs.affine_inverse(); Transform2D aofsinv = aofs.affine_inverse();
Transform2D bofsinv = bofs.affine_inverse(); Transform2D bofsinv = bofs.affine_inverse();
@ -847,16 +847,16 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
} }
//box faces //box faces
if (!separator.test_axis(p_transform_a.elements[0].normalized())) { if (!separator.test_axis(p_transform_a.columns[0].normalized())) {
return; return;
} }
if (!separator.test_axis(p_transform_a.elements[1].normalized())) { if (!separator.test_axis(p_transform_a.columns[1].normalized())) {
return; return;
} }
//capsule axis //capsule axis
if (!separator.test_axis(p_transform_b.elements[0].normalized())) { if (!separator.test_axis(p_transform_b.columns[0].normalized())) {
return; return;
} }
@ -866,7 +866,7 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
{ {
Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) { if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
return; return;
@ -874,7 +874,7 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
} }
if (castA) { if (castA) {
Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
capsule_endpoint -= p_motion_a; capsule_endpoint -= p_motion_a;
if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) { if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
@ -883,7 +883,7 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
} }
if (castB) { if (castB) {
Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
capsule_endpoint += p_motion_b; capsule_endpoint += p_motion_b;
if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) { if (!separator.test_axis(rectangle_A->get_circle_axis(p_transform_a, boxinv, capsule_endpoint))) {
@ -892,7 +892,7 @@ static void _collision_rectangle_capsule(const Shape2DSW *p_a, const Transform2D
} }
if (castA && castB) { if (castA && castB) {
Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint = p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * (i == 0 ? 0.5 : -0.5);
capsule_endpoint -= p_motion_a; capsule_endpoint -= p_motion_a;
capsule_endpoint += p_motion_b; capsule_endpoint += p_motion_b;
@ -921,11 +921,11 @@ static void _collision_rectangle_convex_polygon(const Shape2DSW *p_a, const Tran
} }
//box faces //box faces
if (!separator.test_axis(p_transform_a.elements[0].normalized())) { if (!separator.test_axis(p_transform_a.columns[0].normalized())) {
return; return;
} }
if (!separator.test_axis(p_transform_a.elements[1].normalized())) { if (!separator.test_axis(p_transform_a.columns[1].normalized())) {
return; return;
} }
@ -984,21 +984,21 @@ static void _collision_capsule_capsule(const Shape2DSW *p_a, const Transform2D &
//capsule axis //capsule axis
if (!separator.test_axis(p_transform_b.elements[0].normalized())) { if (!separator.test_axis(p_transform_b.columns[0].normalized())) {
return; return;
} }
if (!separator.test_axis(p_transform_a.elements[0].normalized())) { if (!separator.test_axis(p_transform_a.columns[0].normalized())) {
return; return;
} }
//capsule endpoints //capsule endpoints
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
Vector2 capsule_endpoint_A = p_transform_a.get_origin() + p_transform_a.elements[1] * capsule_A->get_height() * (i == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint_A = p_transform_a.get_origin() + p_transform_a.columns[1] * capsule_A->get_height() * (i == 0 ? 0.5 : -0.5);
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
Vector2 capsule_endpoint_B = p_transform_b.get_origin() + p_transform_b.elements[1] * capsule_B->get_height() * (j == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint_B = p_transform_b.get_origin() + p_transform_b.columns[1] * capsule_B->get_height() * (j == 0 ? 0.5 : -0.5);
if (TEST_POINT(capsule_endpoint_A, capsule_endpoint_B)) { if (TEST_POINT(capsule_endpoint_A, capsule_endpoint_B)) {
return; return;
@ -1026,7 +1026,7 @@ static void _collision_capsule_convex_polygon(const Shape2DSW *p_a, const Transf
//capsule axis //capsule axis
if (!separator.test_axis(p_transform_a.elements[0].normalized())) { if (!separator.test_axis(p_transform_a.columns[0].normalized())) {
return; return;
} }
@ -1035,7 +1035,7 @@ static void _collision_capsule_convex_polygon(const Shape2DSW *p_a, const Transf
Vector2 cpoint = p_transform_b.xform(convex_B->get_point(i)); Vector2 cpoint = p_transform_b.xform(convex_B->get_point(i));
for (int j = 0; j < 2; j++) { for (int j = 0; j < 2; j++) {
Vector2 capsule_endpoint_A = p_transform_a.get_origin() + p_transform_a.elements[1] * capsule_A->get_height() * (j == 0 ? 0.5 : -0.5); Vector2 capsule_endpoint_A = p_transform_a.get_origin() + p_transform_a.columns[1] * capsule_A->get_height() * (j == 0 ? 0.5 : -0.5);
if (TEST_POINT(capsule_endpoint_A, cpoint)) { if (TEST_POINT(capsule_endpoint_A, cpoint)) {
return; return;

4
servers/physics_2d/collision_solver_2d_sw.cpp
View File

@ -169,13 +169,13 @@ bool CollisionSolver2DSW::solve_concave(const Shape2DSW *p_shape_A, const Transf
cinfo.aabb_tests = 0; cinfo.aabb_tests = 0;
Transform2D rel_transform = p_transform_A; Transform2D rel_transform = p_transform_A;
rel_transform.elements[2] -= p_transform_B.get_origin(); rel_transform.columns[2] -= p_transform_B.get_origin();
//quickly compute a local Rect2 //quickly compute a local Rect2
Rect2 local_aabb; Rect2 local_aabb;
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
Vector2 axis(p_transform_B.elements[i]); Vector2 axis(p_transform_B.columns[i]);
real_t axis_scale = 1.0 / axis.length(); real_t axis_scale = 1.0 / axis.length();
axis *= axis_scale; axis *= axis_scale;

2
servers/physics_2d/shape_2d_sw.h
View File

@ -144,7 +144,7 @@ public:
real_t mina, maxa; \ real_t mina, maxa; \
real_t minb, maxb; \ real_t minb, maxb; \
Transform2D ofsb = p_transform; \ Transform2D ofsb = p_transform; \
ofsb.elements[2] += p_cast; \ ofsb.columns[2] += p_cast; \
project_range(p_normal, p_transform, mina, maxa); \ project_range(p_normal, p_transform, mina, maxa); \
project_range(p_normal, ofsb, minb, maxb); \ project_range(p_normal, ofsb, minb, maxb); \
r_min = MIN(mina, minb); \ r_min = MIN(mina, minb); \

8
servers/physics_2d/space_2d_sw.cpp
View File

@ -709,14 +709,14 @@ int Space2DSW::test_body_ray_separation(Body2DSW *p_body, const Transform2D &p_t
break; break;
} }
body_transform.elements[2] += recover_motion; body_transform.columns[2] += recover_motion;
body_aabb.position += recover_motion; body_aabb.position += recover_motion;
recover_attempts--; recover_attempts--;
} while (recover_attempts); } while (recover_attempts);
} }
r_recover_motion = body_transform.elements[2] - p_transform.elements[2]; r_recover_motion = body_transform.columns[2] - p_transform.columns[2];
return rays_found; return rays_found;
} }
@ -909,7 +909,7 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
break; break;
} }
body_transform.elements[2] += recover_motion; body_transform.columns[2] += recover_motion;
body_aabb.position += recover_motion; body_aabb.position += recover_motion;
recover_attempts--; recover_attempts--;
@ -1077,7 +1077,7 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
//it collided, let's get the rest info in unsafe advance //it collided, let's get the rest info in unsafe advance
Transform2D ugt = body_transform; Transform2D ugt = body_transform;
ugt.elements[2] += p_motion * unsafe; ugt.columns[2] += p_motion * unsafe;
_RestCallbackData2D rcd; _RestCallbackData2D rcd;
rcd.best_len = 0; rcd.best_len = 0;

2
servers/visual/visual_server_canvas.cpp
View File

@ -60,7 +60,7 @@ void _collect_ysort_children(VisualServerCanvas::Item *p_canvas_item, Transform2
r_items[r_index] = child_items[i]; r_items[r_index] = child_items[i];
child_items[i]->ysort_modulate = p_modulate; child_items[i]->ysort_modulate = p_modulate;
child_items[i]->ysort_xform = p_transform; child_items[i]->ysort_xform = p_transform;
child_items[i]->ysort_pos = p_transform.xform(child_items[i]->xform.elements[2]); child_items[i]->ysort_pos = p_transform.xform(child_items[i]->xform.columns[2]);
child_items[i]->material_owner = child_items[i]->use_parent_material ? p_material_owner : nullptr; child_items[i]->material_owner = child_items[i]->use_parent_material ? p_material_owner : nullptr;
child_items[i]->ysort_index = r_index; child_items[i]->ysort_index = r_index;
} }

2
servers/visual/visual_server_viewport.cpp
View File

@ -134,7 +134,7 @@ void VisualServerViewport::_draw_viewport(Viewport *p_viewport) {
cl->texture_cache = nullptr; cl->texture_cache = nullptr;
Transform2D scale; Transform2D scale;
scale.scale(cl->rect_cache.size); scale.scale(cl->rect_cache.size);
scale.elements[2] = cl->rect_cache.position; scale.columns[2] = cl->rect_cache.position;
cl->light_shader_xform = (cl->xform_cache * scale).affine_inverse(); cl->light_shader_xform = (cl->xform_cache * scale).affine_inverse();
cl->light_shader_pos = cl->xform_cache[2]; cl->light_shader_pos = cl->xform_cache[2];
if (cl->shadow_buffer.is_valid()) { if (cl->shadow_buffer.is_valid()) {