Merge pull request #38430 from aaronfranke/transform3d

author: Rémi Verschelde <remi@verschelde.fr> 2021-06-03 23:07:21 +0200
committer: GitHub <noreply@github.com> 2021-06-03 23:07:21 +0200
commit: 5d9cab3aeb3c62df6b7b44e6e68c0ebbb67f7a45 (patch)
tree: 619055aeb386211fb83a7c861ab0f79a34aedb2d /core/math
parent: ea2a0b54554c09999d74212925322e8c7b2437e0 (diff)
parent: 0ac4051c00898b316ae11e7075d3f3a9e3c46be3 (diff)
8 files changed, 89 insertions, 89 deletions
diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index 1066cf5e30..66c18f7b3c 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -315,8 +315,8 @@ Vector2 CameraMatrix::get_far_plane_half_extents() const {
 	return Vector2(res.x, res.y);
 }
 
-bool CameraMatrix::get_endpoints(const Transform &p_transform, Vector3 *p_8points) const {
-	Vector<Plane> planes = get_projection_planes(Transform());
+bool CameraMatrix::get_endpoints(const Transform3D &p_transform, Vector3 *p_8points) const {
+	Vector<Plane> planes = get_projection_planes(Transform3D());
 	const Planes intersections[8][3] = {
 		{ PLANE_FAR, PLANE_LEFT, PLANE_TOP },
 		{ PLANE_FAR, PLANE_LEFT, PLANE_BOTTOM },
@@ -338,7 +338,7 @@ bool CameraMatrix::get_endpoints(const Transform &p_transform, Vector3 *p_8point
 	return true;
 }
 
-Vector<Plane> CameraMatrix::get_projection_planes(const Transform &p_transform) const {
+Vector<Plane> CameraMatrix::get_projection_planes(const Transform3D &p_transform) const {
 	/** Fast Plane Extraction from combined modelview/projection matrices.
 	 * References:
 	 * https://web.archive.org/web/20011221205252/http://www.markmorley.com/opengl/frustumculling.html
@@ -707,8 +707,8 @@ void CameraMatrix::scale_translate_to_fit(const AABB &p_aabb) {
 	matrix[3][3] = 1;
 }
 
-CameraMatrix::operator Transform() const {
-	Transform tr;
+CameraMatrix::operator Transform3D() const {
+	Transform3D tr;
 	const real_t *m = &matrix[0][0];
 
 	tr.basis.elements[0][0] = m[0];
@@ -730,8 +730,8 @@ CameraMatrix::operator Transform() const {
 	return tr;
 }
 
-CameraMatrix::CameraMatrix(const Transform &p_transform) {
-	const Transform &tr = p_transform;
+CameraMatrix::CameraMatrix(const Transform3D &p_transform) {
+	const Transform3D &tr = p_transform;
 	real_t *m = &matrix[0][0];
 
 	m[0] = tr.basis.elements[0][0];
diff --git a/core/math/camera_matrix.h b/core/math/camera_matrix.h
index 3f327d3bc4..786d46055a 100644
--- a/core/math/camera_matrix.h
+++ b/core/math/camera_matrix.h
@@ -32,7 +32,7 @@
 #define CAMERA_MATRIX_H
 
 #include "core/math/rect2.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 
 struct CameraMatrix {
 	enum Planes {
@@ -71,9 +71,9 @@ struct CameraMatrix {
 	real_t get_fov() const;
 	bool is_orthogonal() const;
 
-	Vector<Plane> get_projection_planes(const Transform &p_transform) const;
+	Vector<Plane> get_projection_planes(const Transform3D &p_transform) const;
 
-	bool get_endpoints(const Transform &p_transform, Vector3 *p_8points) const;
+	bool get_endpoints(const Transform3D &p_transform, Vector3 *p_8points) const;
 	Vector2 get_viewport_half_extents() const;
 	Vector2 get_far_plane_half_extents() const;
 
@@ -90,7 +90,7 @@ struct CameraMatrix {
 	void scale_translate_to_fit(const AABB &p_aabb);
 	void make_scale(const Vector3 &p_scale);
 	int get_pixels_per_meter(int p_for_pixel_width) const;
-	operator Transform() const;
+	operator Transform3D() const;
 
 	void flip_y();
 
@@ -112,7 +112,7 @@ struct CameraMatrix {
 	float get_lod_multiplier() const;
 
 	CameraMatrix();
-	CameraMatrix(const Transform &p_transform);
+	CameraMatrix(const Transform3D &p_transform);
 	~CameraMatrix();
 };
 
diff --git a/core/math/face3.cpp b/core/math/face3.cpp
index 20c316c322..9af3f868d2 100644
--- a/core/math/face3.cpp
+++ b/core/math/face3.cpp
@@ -230,7 +230,7 @@ bool Face3::intersects_aabb(const AABB &p_aabb) const {
 
 			real_t minA, maxA, minB, maxB;
 			p_aabb.project_range_in_plane(Plane(axis, 0), minA, maxA);
-			project_range(axis, Transform(), minB, maxB);
+			project_range(axis, Transform3D(), minB, maxB);
 
 			if (maxA < minB || maxB < minA) {
 				return false;
@@ -244,7 +244,7 @@ Face3::operator String() const {
 	return String() + vertex[0] + ", " + vertex[1] + ", " + vertex[2];
 }
 
-void Face3::project_range(const Vector3 &p_normal, const Transform &p_transform, real_t &r_min, real_t &r_max) const {
+void Face3::project_range(const Vector3 &p_normal, const Transform3D &p_transform, real_t &r_min, real_t &r_max) const {
 	for (int i = 0; i < 3; i++) {
 		Vector3 v = p_transform.xform(vertex[i]);
 		real_t d = p_normal.dot(v);
@@ -259,7 +259,7 @@ void Face3::project_range(const Vector3 &p_normal, const Transform &p_transform,
 	}
 }
 
-void Face3::get_support(const Vector3 &p_normal, const Transform &p_transform, Vector3 *p_vertices, int *p_count, int p_max) const {
+void Face3::get_support(const Vector3 &p_normal, const Transform3D &p_transform, Vector3 *p_vertices, int *p_count, int p_max) const {
 #define _FACE_IS_VALID_SUPPORT_THRESHOLD 0.98
 #define _EDGE_IS_VALID_SUPPORT_THRESHOLD 0.05
 
diff --git a/core/math/face3.h b/core/math/face3.h
index 2e86b0a904..5091b338ef 100644
--- a/core/math/face3.h
+++ b/core/math/face3.h
@@ -33,7 +33,7 @@
 
 #include "core/math/aabb.h"
 #include "core/math/plane.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector3.h"
 
 class Face3 {
@@ -74,8 +74,8 @@ public:
 
 	ClockDirection get_clock_dir() const; ///< todo, test if this is returning the proper clockwisity
 
-	void get_support(const Vector3 &p_normal, const Transform &p_transform, Vector3 *p_vertices, int *p_count, int p_max) const;
-	void project_range(const Vector3 &p_normal, const Transform &p_transform, real_t &r_min, real_t &r_max) const;
+	void get_support(const Vector3 &p_normal, const Transform3D &p_transform, Vector3 *p_vertices, int *p_count, int p_max) const;
+	void project_range(const Vector3 &p_normal, const Transform3D &p_transform, real_t &r_min, real_t &r_max) const;
 
 	AABB get_aabb() const {
 		AABB aabb(vertex[0], Vector3());
diff --git a/core/math/math_fieldwise.cpp b/core/math/math_fieldwise.cpp
index 0985a727f2..f2baef1a59 100644
--- a/core/math/math_fieldwise.cpp
+++ b/core/math/math_fieldwise.cpp
@@ -141,8 +141,8 @@ Variant fieldwise_assign(const Variant &p_target, const Variant &p_source, const
 			return target;
 		}
 
-		case Variant::TRANSFORM: {
-			SETUP_TYPE(Transform)
+		case Variant::TRANSFORM3D: {
+			SETUP_TYPE(Transform3D)
 
 			/**/ TRY_TRANSFER_FIELD("xx", basis.elements[0][0])
 			else TRY_TRANSFER_FIELD("xy", basis.elements[0][1])
diff --git a/core/math/transform.cpp b/core/math/transform_3d.cpp
index d4d7ff6d28..2611d6accf 100644
--- a/core/math/transform.cpp
+++ b/core/math/transform_3d.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  transform.cpp                                                        */
+/*  transform_3d.cpp                                                     */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,54 +28,54 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "transform.h"
+#include "transform_3d.h"
 
 #include "core/math/math_funcs.h"
 #include "core/string/print_string.h"
 
-void Transform::affine_invert() {
+void Transform3D::affine_invert() {
 	basis.invert();
 	origin = basis.xform(-origin);
 }
 
-Transform Transform::affine_inverse() const {
-	Transform ret = *this;
+Transform3D Transform3D::affine_inverse() const {
+	Transform3D ret = *this;
 	ret.affine_invert();
 	return ret;
 }
 
-void Transform::invert() {
+void Transform3D::invert() {
 	basis.transpose();
 	origin = basis.xform(-origin);
 }
 
-Transform Transform::inverse() const {
+Transform3D Transform3D::inverse() const {
 	// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
-	// Transform::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
-	Transform ret = *this;
+	// Transform3D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
+	Transform3D ret = *this;
 	ret.invert();
 	return ret;
 }
 
-void Transform::rotate(const Vector3 &p_axis, real_t p_phi) {
+void Transform3D::rotate(const Vector3 &p_axis, real_t p_phi) {
 	*this = rotated(p_axis, p_phi);
 }
 
-Transform Transform::rotated(const Vector3 &p_axis, real_t p_phi) const {
-	return Transform(Basis(p_axis, p_phi), Vector3()) * (*this);
+Transform3D Transform3D::rotated(const Vector3 &p_axis, real_t p_phi) const {
+	return Transform3D(Basis(p_axis, p_phi), Vector3()) * (*this);
 }
 
-void Transform::rotate_basis(const Vector3 &p_axis, real_t p_phi) {
+void Transform3D::rotate_basis(const Vector3 &p_axis, real_t p_phi) {
 	basis.rotate(p_axis, p_phi);
 }
 
-Transform Transform::looking_at(const Vector3 &p_target, const Vector3 &p_up) const {
-	Transform t = *this;
+Transform3D Transform3D::looking_at(const Vector3 &p_target, const Vector3 &p_up) const {
+	Transform3D t = *this;
 	t.set_look_at(origin, p_target, p_up);
 	return t;
 }
 
-void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up) {
+void Transform3D::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up) {
 #ifdef MATH_CHECKS
 	ERR_FAIL_COND(p_eye == p_target);
 	ERR_FAIL_COND(p_up.length() == 0);
@@ -108,7 +108,7 @@ void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const
 	origin = p_eye;
 }
 
-Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c) const {
+Transform3D Transform3D::interpolate_with(const Transform3D &p_transform, real_t p_c) const {
 	/* not sure if very "efficient" but good enough? */
 
 	Vector3 src_scale = basis.get_scale();
@@ -119,94 +119,94 @@ Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c)
 	Quat dst_rot = p_transform.basis.get_rotation_quat();
 	Vector3 dst_loc = p_transform.origin;
 
-	Transform interp;
+	Transform3D interp;
 	interp.basis.set_quat_scale(src_rot.slerp(dst_rot, p_c).normalized(), src_scale.lerp(dst_scale, p_c));
 	interp.origin = src_loc.lerp(dst_loc, p_c);
 
 	return interp;
 }
 
-void Transform::scale(const Vector3 &p_scale) {
+void Transform3D::scale(const Vector3 &p_scale) {
 	basis.scale(p_scale);
 	origin *= p_scale;
 }
 
-Transform Transform::scaled(const Vector3 &p_scale) const {
-	Transform t = *this;
+Transform3D Transform3D::scaled(const Vector3 &p_scale) const {
+	Transform3D t = *this;
 	t.scale(p_scale);
 	return t;
 }
 
-void Transform::scale_basis(const Vector3 &p_scale) {
+void Transform3D::scale_basis(const Vector3 &p_scale) {
 	basis.scale(p_scale);
 }
 
-void Transform::translate(real_t p_tx, real_t p_ty, real_t p_tz) {
+void Transform3D::translate(real_t p_tx, real_t p_ty, real_t p_tz) {
 	translate(Vector3(p_tx, p_ty, p_tz));
 }
 
-void Transform::translate(const Vector3 &p_translation) {
+void Transform3D::translate(const Vector3 &p_translation) {
 	for (int i = 0; i < 3; i++) {
 		origin[i] += basis[i].dot(p_translation);
 	}
 }
 
-Transform Transform::translated(const Vector3 &p_translation) const {
-	Transform t = *this;
+Transform3D Transform3D::translated(const Vector3 &p_translation) const {
+	Transform3D t = *this;
 	t.translate(p_translation);
 	return t;
 }
 
-void Transform::orthonormalize() {
+void Transform3D::orthonormalize() {
 	basis.orthonormalize();
 }
 
-Transform Transform::orthonormalized() const {
-	Transform _copy = *this;
+Transform3D Transform3D::orthonormalized() const {
+	Transform3D _copy = *this;
 	_copy.orthonormalize();
 	return _copy;
 }
 
-bool Transform::is_equal_approx(const Transform &p_transform) const {
+bool Transform3D::is_equal_approx(const Transform3D &p_transform) const {
 	return basis.is_equal_approx(p_transform.basis) && origin.is_equal_approx(p_transform.origin);
 }
 
-bool Transform::operator==(const Transform &p_transform) const {
+bool Transform3D::operator==(const Transform3D &p_transform) const {
 	return (basis == p_transform.basis && origin == p_transform.origin);
 }
 
-bool Transform::operator!=(const Transform &p_transform) const {
+bool Transform3D::operator!=(const Transform3D &p_transform) const {
 	return (basis != p_transform.basis || origin != p_transform.origin);
 }
 
-void Transform::operator*=(const Transform &p_transform) {
+void Transform3D::operator*=(const Transform3D &p_transform) {
 	origin = xform(p_transform.origin);
 	basis *= p_transform.basis;
 }
 
-Transform Transform::operator*(const Transform &p_transform) const {
-	Transform t = *this;
+Transform3D Transform3D::operator*(const Transform3D &p_transform) const {
+	Transform3D t = *this;
 	t *= p_transform;
 	return t;
 }
 
-Transform::operator String() const {
+Transform3D::operator String() const {
 	return basis.operator String() + " - " + origin.operator String();
 }
 
-Transform::Transform(const Basis &p_basis, const Vector3 &p_origin) :
+Transform3D::Transform3D(const Basis &p_basis, const Vector3 &p_origin) :
 		basis(p_basis),
 		origin(p_origin) {
 }
 
-Transform::Transform(const Vector3 &p_x, const Vector3 &p_y, const Vector3 &p_z, const Vector3 &p_origin) :
+Transform3D::Transform3D(const Vector3 &p_x, const Vector3 &p_y, const Vector3 &p_z, const Vector3 &p_origin) :
 		origin(p_origin) {
 	basis.set_axis(0, p_x);
 	basis.set_axis(1, p_y);
 	basis.set_axis(2, p_z);
 }
 
-Transform::Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz) {
+Transform3D::Transform3D(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz) {
 	basis = Basis(xx, xy, xz, yx, yy, yz, zx, zy, zz);
 	origin = Vector3(ox, oy, oz);
 }
diff --git a/core/math/transform.h b/core/math/transform_3d.h
index 1c05dbe554..078a2ca11a 100644
--- a/core/math/transform.h
+++ b/core/math/transform_3d.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  transform.h                                                          */
+/*  transform_3d.h                                                       */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -35,31 +35,31 @@
 #include "core/math/basis.h"
 #include "core/math/plane.h"
 
-class Transform {
+class Transform3D {
 public:
 	Basis basis;
 	Vector3 origin;
 
 	void invert();
-	Transform inverse() const;
+	Transform3D inverse() const;
 
 	void affine_invert();
-	Transform affine_inverse() const;
+	Transform3D affine_inverse() const;
 
-	Transform rotated(const Vector3 &p_axis, real_t p_phi) const;
+	Transform3D rotated(const Vector3 &p_axis, real_t p_phi) const;
 
 	void rotate(const Vector3 &p_axis, real_t p_phi);
 	void rotate_basis(const Vector3 &p_axis, real_t p_phi);
 
 	void set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up = Vector3(0, 1, 0));
-	Transform looking_at(const Vector3 &p_target, const Vector3 &p_up = Vector3(0, 1, 0)) const;
+	Transform3D looking_at(const Vector3 &p_target, const Vector3 &p_up = Vector3(0, 1, 0)) const;
 
 	void scale(const Vector3 &p_scale);
-	Transform scaled(const Vector3 &p_scale) const;
+	Transform3D scaled(const Vector3 &p_scale) const;
 	void scale_basis(const Vector3 &p_scale);
 	void translate(real_t p_tx, real_t p_ty, real_t p_tz);
 	void translate(const Vector3 &p_translation);
-	Transform translated(const Vector3 &p_translation) const;
+	Transform3D translated(const Vector3 &p_translation) const;
 
 	const Basis &get_basis() const { return basis; }
 	void set_basis(const Basis &p_basis) { basis = p_basis; }
@@ -68,11 +68,11 @@ public:
 	void set_origin(const Vector3 &p_origin) { origin = p_origin; }
 
 	void orthonormalize();
-	Transform orthonormalized() const;
-	bool is_equal_approx(const Transform &p_transform) const;
+	Transform3D orthonormalized() const;
+	bool is_equal_approx(const Transform3D &p_transform) const;
 
-	bool operator==(const Transform &p_transform) const;
-	bool operator!=(const Transform &p_transform) const;
+	bool operator==(const Transform3D &p_transform) const;
+	bool operator!=(const Transform3D &p_transform) const;
 
 	_FORCE_INLINE_ Vector3 xform(const Vector3 &p_vector) const;
 	_FORCE_INLINE_ Vector3 xform_inv(const Vector3 &p_vector) const;
@@ -86,14 +86,14 @@ public:
 	_FORCE_INLINE_ Vector<Vector3> xform(const Vector<Vector3> &p_array) const;
 	_FORCE_INLINE_ Vector<Vector3> xform_inv(const Vector<Vector3> &p_array) const;
 
-	void operator*=(const Transform &p_transform);
-	Transform operator*(const Transform &p_transform) const;
+	void operator*=(const Transform3D &p_transform);
+	Transform3D operator*(const Transform3D &p_transform) const;
 
-	Transform interpolate_with(const Transform &p_transform, real_t p_c) const;
+	Transform3D interpolate_with(const Transform3D &p_transform, real_t p_c) const;
 
-	_FORCE_INLINE_ Transform inverse_xform(const Transform &t) const {
+	_FORCE_INLINE_ Transform3D inverse_xform(const Transform3D &t) const {
 		Vector3 v = t.origin - origin;
-		return Transform(basis.transpose_xform(t.basis),
+		return Transform3D(basis.transpose_xform(t.basis),
 				basis.xform(v));
 	}
 
@@ -106,20 +106,20 @@ public:
 
 	operator String() const;
 
-	Transform() {}
-	Transform(const Basis &p_basis, const Vector3 &p_origin = Vector3());
-	Transform(const Vector3 &p_x, const Vector3 &p_y, const Vector3 &p_z, const Vector3 &p_origin);
-	Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz);
+	Transform3D() {}
+	Transform3D(const Basis &p_basis, const Vector3 &p_origin = Vector3());
+	Transform3D(const Vector3 &p_x, const Vector3 &p_y, const Vector3 &p_z, const Vector3 &p_origin);
+	Transform3D(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t ox, real_t oy, real_t oz);
 };
 
-_FORCE_INLINE_ Vector3 Transform::xform(const Vector3 &p_vector) const {
+_FORCE_INLINE_ Vector3 Transform3D::xform(const Vector3 &p_vector) const {
 	return Vector3(
 			basis[0].dot(p_vector) + origin.x,
 			basis[1].dot(p_vector) + origin.y,
 			basis[2].dot(p_vector) + origin.z);
 }
 
-_FORCE_INLINE_ Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
+_FORCE_INLINE_ Vector3 Transform3D::xform_inv(const Vector3 &p_vector) const {
 	Vector3 v = p_vector - origin;
 
 	return Vector3(
@@ -128,7 +128,7 @@ _FORCE_INLINE_ Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
 			(basis.elements[0][2] * v.x) + (basis.elements[1][2] * v.y) + (basis.elements[2][2] * v.z));
 }
 
-_FORCE_INLINE_ Plane Transform::xform(const Plane &p_plane) const {
+_FORCE_INLINE_ Plane Transform3D::xform(const Plane &p_plane) const {
 	Vector3 point = p_plane.normal * p_plane.d;
 	Vector3 point_dir = point + p_plane.normal;
 	point = xform(point);
@@ -141,7 +141,7 @@ _FORCE_INLINE_ Plane Transform::xform(const Plane &p_plane) const {
 	return Plane(normal, d);
 }
 
-_FORCE_INLINE_ Plane Transform::xform_inv(const Plane &p_plane) const {
+_FORCE_INLINE_ Plane Transform3D::xform_inv(const Plane &p_plane) const {
 	Vector3 point = p_plane.normal * p_plane.d;
 	Vector3 point_dir = point + p_plane.normal;
 	point = xform_inv(point);
@@ -154,7 +154,7 @@ _FORCE_INLINE_ Plane Transform::xform_inv(const Plane &p_plane) const {
 	return Plane(normal, d);
 }
 
-_FORCE_INLINE_ AABB Transform::xform(const AABB &p_aabb) const {
+_FORCE_INLINE_ AABB Transform3D::xform(const AABB &p_aabb) const {
 	/* http://dev.theomader.com/transform-bounding-boxes/ */
 	Vector3 min = p_aabb.position;
 	Vector3 max = p_aabb.position + p_aabb.size;
@@ -179,7 +179,7 @@ _FORCE_INLINE_ AABB Transform::xform(const AABB &p_aabb) const {
 	return r_aabb;
 }
 
-_FORCE_INLINE_ AABB Transform::xform_inv(const AABB &p_aabb) const {
+_FORCE_INLINE_ AABB Transform3D::xform_inv(const AABB &p_aabb) const {
 	/* define vertices */
 	Vector3 vertices[8] = {
 		Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z + p_aabb.size.z),
@@ -203,7 +203,7 @@ _FORCE_INLINE_ AABB Transform::xform_inv(const AABB &p_aabb) const {
 	return ret;
 }
 
-Vector<Vector3> Transform::xform(const Vector<Vector3> &p_array) const {
+Vector<Vector3> Transform3D::xform(const Vector<Vector3> &p_array) const {
 	Vector<Vector3> array;
 	array.resize(p_array.size());
 
@@ -216,7 +216,7 @@ Vector<Vector3> Transform::xform(const Vector<Vector3> &p_array) const {
 	return array;
 }
 
-Vector<Vector3> Transform::xform_inv(const Vector<Vector3> &p_array) const {
+Vector<Vector3> Transform3D::xform_inv(const Vector<Vector3> &p_array) const {
 	Vector<Vector3> array;
 	array.resize(p_array.size());
 
diff --git a/core/math/triangle_mesh.cpp b/core/math/triangle_mesh.cpp
index 23c0c686a2..903d5951a8 100644
--- a/core/math/triangle_mesh.cpp
+++ b/core/math/triangle_mesh.cpp
@@ -600,7 +600,7 @@ bool TriangleMesh::inside_convex_shape(const Plane *p_planes, int p_plane_count,
 	const Vector3 *vertexptr = vertices.ptr();
 	const BVH *bvhptr = bvh.ptr();
 
-	Transform scale(Basis().scaled(p_scale));
+	Transform3D scale(Basis().scaled(p_scale));
 
 	int pos = bvh.size() - 1;
author	Rémi Verschelde <remi@verschelde.fr>	2021-06-03 23:07:21 +0200
committer	GitHub <noreply@github.com>	2021-06-03 23:07:21 +0200
commit	5d9cab3aeb3c62df6b7b44e6e68c0ebbb67f7a45 (patch)
tree	619055aeb386211fb83a7c861ab0f79a34aedb2d /core/math
parent	ea2a0b54554c09999d74212925322e8c7b2437e0 (diff)
parent	0ac4051c00898b316ae11e7075d3f3a9e3c46be3 (diff)