Merge pull request #9038 from AlexHolly/rect2-rename-pos

renamed all Rect2.pos to Rect2.position

core/helper/math_fieldwise.cpp

@@ -63,8 +63,8 @@ Variant fieldwise_assign(const Variant &p_target, const Variant &p_source, const
 
 			SETUP_TYPE(Rect2)
 
-			/**/ TRY_TRANSFER_FIELD("x", pos.x)
-			else TRY_TRANSFER_FIELD("y", pos.y)
+			/**/ TRY_TRANSFER_FIELD("x", position.x)
+			else TRY_TRANSFER_FIELD("y", position.y)
 			else TRY_TRANSFER_FIELD("w", size.x)
 			else TRY_TRANSFER_FIELD("h", size.y)
 

core/image.cpp

@@ -1612,11 +1612,11 @@ void Image::blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Po
 	ERR_FAIL_COND(srcdsize == 0);
 	ERR_FAIL_COND(format != p_src->format);
 
-	Rect2i local_src_rect = Rect2i(0, 0, width, height).clip(Rect2i(p_dest + p_src_rect.pos, p_src_rect.size));
+	Rect2i local_src_rect = Rect2i(0, 0, width, height).clip(Rect2i(p_dest + p_src_rect.position, p_src_rect.size));
 
 	if (local_src_rect.size.x <= 0 || local_src_rect.size.y <= 0)
 		return;
-	Rect2i src_rect(p_src_rect.pos + (local_src_rect.pos - p_dest), local_src_rect.size);
+	Rect2i src_rect(p_src_rect.position + (local_src_rect.position - p_dest), local_src_rect.size);
 
 	PoolVector<uint8_t>::Write wp = data.write();
 	uint8_t *dst_data_ptr = wp.ptr();
@@ -1630,11 +1630,11 @@ void Image::blit_rect(const Ref<Image> &p_src, const Rect2 &p_src_rect, const Po
 
 		for (int j = 0; j < src_rect.size.x; j++) {
 
-			int src_x = src_rect.pos.x + j;
-			int src_y = src_rect.pos.y + i;
+			int src_x = src_rect.position.x + j;
+			int src_y = src_rect.position.y + i;
 
-			int dst_x = local_src_rect.pos.x + j;
-			int dst_y = local_src_rect.pos.y + i;
+			int dst_x = local_src_rect.position.x + j;
+			int dst_y = local_src_rect.position.y + i;
 
 			const uint8_t *src = &src_data_ptr[(src_y * p_src->width + src_x) * pixel_size];
 			uint8_t *dst = &dst_data_ptr[(dst_y * width + dst_x) * pixel_size];

core/io/marshalls.cpp

@@ -139,8 +139,8 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 
 			ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA);
 			Rect2 val;
-			val.pos.x = decode_float(&buf[0]);
-			val.pos.y = decode_float(&buf[4]);
+			val.position.x = decode_float(&buf[0]);
+			val.position.y = decode_float(&buf[4]);
 			val.size.x = decode_float(&buf[8]);
 			val.size.y = decode_float(&buf[12]);
 			r_variant = val;
@@ -861,8 +861,8 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len) {
 
 			if (buf) {
 				Rect2 r2 = p_variant;
-				encode_float(r2.pos.x, &buf[0]);
-				encode_float(r2.pos.y, &buf[4]);
+				encode_float(r2.position.x, &buf[0]);
+				encode_float(r2.position.y, &buf[4]);
 				encode_float(r2.size.x, &buf[8]);
 				encode_float(r2.size.y, &buf[12]);
 			}

core/io/resource_format_binary.cpp

@@ -155,8 +155,8 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
 		case VARIANT_RECT2: {
 
 			Rect2 v;
-			v.pos.x = f->get_real();
-			v.pos.y = f->get_real();
+			v.position.x = f->get_real();
+			v.position.y = f->get_real();
 			v.size.x = f->get_real();
 			v.size.y = f->get_real();
 			r_v = v;
@@ -1288,8 +1288,8 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property,
 
 			f->store_32(VARIANT_RECT2);
 			Rect2 val = p_property;
-			f->store_real(val.pos.x);
-			f->store_real(val.pos.y);
+			f->store_real(val.position.x);
+			f->store_real(val.position.y);
 			f->store_real(val.size.x);
 			f->store_real(val.size.y);
 

core/math/camera_matrix.cpp

@@ -507,8 +507,8 @@ void CameraMatrix::set_light_atlas_rect(const Rect2 &p_rect) {
 	m[9] = 0.0,
 	m[10] = 1.0,
 	m[11] = 0.0,
-	m[12] = p_rect.pos.x,
-	m[13] = p_rect.pos.y,
+	m[12] = p_rect.position.x,
+	m[13] = p_rect.position.y,
 	m[14] = 0.0,
 	m[15] = 1.0;
 }

core/math/math_2d.cpp

@@ -308,7 +308,7 @@ bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2
 	for (int i = 0; i < 2; i++) {
 		real_t seg_from = p_from[i];
 		real_t seg_to = p_to[i];
-		real_t box_begin = pos[i];
+		real_t box_begin = position[i];
 		real_t box_end = box_begin + size[i];
 		real_t cmin, cmax;
 		real_t csign;

core/math/math_2d.h

@@ -207,24 +207,24 @@ struct Transform2D;
 
 struct Rect2 {
 
-	Point2 pos;
+	Point2 position;
 	Size2 size;
 
-	const Vector2 &get_pos() const { return pos; }
-	void set_pos(const Vector2 &p_pos) { pos = p_pos; }
+	const Vector2 &get_position() const { return position; }
+	void set_position(const Vector2 &p_pos) { position = p_pos; }
 	const Vector2 &get_size() const { return size; }
 	void set_size(const Vector2 &p_size) { size = p_size; }
 
 	real_t get_area() const { return size.width * size.height; }
 
 	inline bool intersects(const Rect2 &p_rect) const {
-		if (pos.x >= (p_rect.pos.x + p_rect.size.width))
+		if (position.x >= (p_rect.position.x + p_rect.size.width))
 			return false;
-		if ((pos.x + size.width) <= p_rect.pos.x)
+		if ((position.x + size.width) <= p_rect.position.x)
 			return false;
-		if (pos.y >= (p_rect.pos.y + p_rect.size.height))
+		if (position.y >= (p_rect.position.y + p_rect.size.height))
 			return false;
-		if ((pos.y + size.height) <= p_rect.pos.y)
+		if ((position.y + size.height) <= p_rect.position.y)
 			return false;
 
 		return true;
@@ -234,17 +234,17 @@ struct Rect2 {
 
 		real_t dist = 1e20;
 
-		if (p_point.x < pos.x) {
-			dist = MIN(dist, pos.x - p_point.x);
+		if (p_point.x < position.x) {
+			dist = MIN(dist, position.x - p_point.x);
 		}
-		if (p_point.y < pos.y) {
-			dist = MIN(dist, pos.y - p_point.y);
+		if (p_point.y < position.y) {
+			dist = MIN(dist, position.y - p_point.y);
 		}
-		if (p_point.x >= (pos.x + size.x)) {
-			dist = MIN(p_point.x - (pos.x + size.x), dist);
+		if (p_point.x >= (position.x + size.x)) {
+			dist = MIN(p_point.x - (position.x + size.x), dist);
 		}
-		if (p_point.y >= (pos.y + size.y)) {
-			dist = MIN(p_point.y - (pos.y + size.y), dist);
+		if (p_point.y >= (position.y + size.y)) {
+			dist = MIN(p_point.y - (position.y + size.y), dist);
 		}
 
 		if (dist == 1e20)
@@ -259,9 +259,9 @@ struct Rect2 {
 
 	inline bool encloses(const Rect2 &p_rect) const {
 
-		return (p_rect.pos.x >= pos.x) && (p_rect.pos.y >= pos.y) &&
-			   ((p_rect.pos.x + p_rect.size.x) < (pos.x + size.x)) &&
-			   ((p_rect.pos.y + p_rect.size.y) < (pos.y + size.y));
+		return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&
+			   ((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) &&
+			   ((p_rect.position.y + p_rect.size.y) < (position.y + size.y));
 	}
 
 	inline bool has_no_area() const {
@@ -275,14 +275,14 @@ struct Rect2 {
 		if (!intersects(new_rect))
 			return Rect2();
 
-		new_rect.pos.x = MAX(p_rect.pos.x, pos.x);
-		new_rect.pos.y = MAX(p_rect.pos.y, pos.y);
+		new_rect.position.x = MAX(p_rect.position.x, position.x);
+		new_rect.position.y = MAX(p_rect.position.y, position.y);
 
-		Point2 p_rect_end = p_rect.pos + p_rect.size;
-		Point2 end = pos + size;
+		Point2 p_rect_end = p_rect.position + p_rect.size;
+		Point2 end = position + size;
 
-		new_rect.size.x = MIN(p_rect_end.x, end.x) - new_rect.pos.x;
-		new_rect.size.y = MIN(p_rect_end.y, end.y) - new_rect.pos.y;
+		new_rect.size.x = MIN(p_rect_end.x, end.x) - new_rect.position.x;
+		new_rect.size.y = MIN(p_rect_end.y, end.y) - new_rect.position.y;
 
 		return new_rect;
 	}
@@ -291,25 +291,25 @@ struct Rect2 {
 
 		Rect2 new_rect;
 
-		new_rect.pos.x = MIN(p_rect.pos.x, pos.x);
-		new_rect.pos.y = MIN(p_rect.pos.y, pos.y);
+		new_rect.position.x = MIN(p_rect.position.x, position.x);
+		new_rect.position.y = MIN(p_rect.position.y, position.y);
 
-		new_rect.size.x = MAX(p_rect.pos.x + p_rect.size.x, pos.x + size.x);
-		new_rect.size.y = MAX(p_rect.pos.y + p_rect.size.y, pos.y + size.y);
+		new_rect.size.x = MAX(p_rect.position.x + p_rect.size.x, position.x + size.x);
+		new_rect.size.y = MAX(p_rect.position.y + p_rect.size.y, position.y + size.y);
 
-		new_rect.size = new_rect.size - new_rect.pos; //make relative again
+		new_rect.size = new_rect.size - new_rect.position; //make relative again
 
 		return new_rect;
 	};
 	inline bool has_point(const Point2 &p_point) const {
-		if (p_point.x < pos.x)
+		if (p_point.x < position.x)
 			return false;
-		if (p_point.y < pos.y)
+		if (p_point.y < position.y)
 			return false;
 
-		if (p_point.x >= (pos.x + size.x))
+		if (p_point.x >= (position.x + size.x))
 			return false;
-		if (p_point.y >= (pos.y + size.y))
+		if (p_point.y >= (position.y + size.y))
 			return false;
 
 		return true;
@@ -317,14 +317,14 @@ struct Rect2 {
 
 	inline bool no_area() const { return (size.width <= 0 || size.height <= 0); }
 
-	bool operator==(const Rect2 &p_rect) const { return pos == p_rect.pos && size == p_rect.size; }
-	bool operator!=(const Rect2 &p_rect) const { return pos != p_rect.pos || size != p_rect.size; }
+	bool operator==(const Rect2 &p_rect) const { return position == p_rect.position && size == p_rect.size; }
+	bool operator!=(const Rect2 &p_rect) const { return position != p_rect.position || size != p_rect.size; }
 
 	inline Rect2 grow(real_t p_by) const {
 
 		Rect2 g = *this;
-		g.pos.x -= p_by;
-		g.pos.y -= p_by;
+		g.position.x -= p_by;
+		g.position.y -= p_by;
 		g.size.width += p_by * 2;
 		g.size.height += p_by * 2;
 		return g;
@@ -339,8 +339,8 @@ struct Rect2 {
 
 	inline void expand_to(const Vector2 &p_vector) { //in place function for speed
 
-		Vector2 begin = pos;
-		Vector2 end = pos + size;
+		Vector2 begin = position;
+		Vector2 end = position + size;
 
 		if (p_vector.x < begin.x)
 			begin.x = p_vector.x;
@@ -352,19 +352,19 @@ struct Rect2 {
 		if (p_vector.y > end.y)
 			end.y = p_vector.y;
 
-		pos = begin;
+		position = begin;
 		size = end - begin;
 	}
 
-	operator String() const { return String(pos) + ", " + String(size); }
+	operator String() const { return String(position) + ", " + String(size); }
 
 	Rect2() {}
 	Rect2(real_t p_x, real_t p_y, real_t p_width, real_t p_height) {
-		pos = Point2(p_x, p_y);
+		position = Point2(p_x, p_y);
 		size = Size2(p_width, p_height);
 	}
 	Rect2(const Point2 &p_pos, const Size2 &p_size) {
-		pos = p_pos;
+		position = p_pos;
 		size = p_size;
 	}
 };
@@ -434,24 +434,24 @@ typedef Point2i Size2i;
 
 struct Rect2i {
 
-	Point2i pos;
+	Point2i position;
 	Size2i size;
 
-	const Point2i &get_pos() const { return pos; }
-	void set_pos(const Point2i &p_pos) { pos = p_pos; }
+	const Point2i &get_position() const { return position; }
+	void set_position(const Point2i &p_pos) { position = p_pos; }
 	const Point2i &get_size() const { return size; }
 	void set_size(const Point2i &p_size) { size = p_size; }
 
 	int get_area() const { return size.width * size.height; }
 
 	inline bool intersects(const Rect2i &p_rect) const {
-		if (pos.x > (p_rect.pos.x + p_rect.size.width))
+		if (position.x > (p_rect.position.x + p_rect.size.width))
 			return false;
-		if ((pos.x + size.width) < p_rect.pos.x)
+		if ((position.x + size.width) < p_rect.position.x)
 			return false;
-		if (pos.y > (p_rect.pos.y + p_rect.size.height))
+		if (position.y > (p_rect.position.y + p_rect.size.height))
 			return false;
-		if ((pos.y + size.height) < p_rect.pos.y)
+		if ((position.y + size.height) < p_rect.position.y)
 			return false;
 
 		return true;
@@ -459,9 +459,9 @@ struct Rect2i {
 
 	inline bool encloses(const Rect2i &p_rect) const {
 
-		return (p_rect.pos.x >= pos.x) && (p_rect.pos.y >= pos.y) &&
-			   ((p_rect.pos.x + p_rect.size.x) < (pos.x + size.x)) &&
-			   ((p_rect.pos.y + p_rect.size.y) < (pos.y + size.y));
+		return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&
+			   ((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) &&
+			   ((p_rect.position.y + p_rect.size.y) < (position.y + size.y));
 	}
 
 	inline bool has_no_area() const {
@@ -475,14 +475,14 @@ struct Rect2i {
 		if (!intersects(new_rect))
 			return Rect2i();
 
-		new_rect.pos.x = MAX(p_rect.pos.x, pos.x);
-		new_rect.pos.y = MAX(p_rect.pos.y, pos.y);
+		new_rect.position.x = MAX(p_rect.position.x, position.x);
+		new_rect.position.y = MAX(p_rect.position.y, position.y);
 
-		Point2 p_rect_end = p_rect.pos + p_rect.size;
-		Point2 end = pos + size;
+		Point2 p_rect_end = p_rect.position + p_rect.size;
+		Point2 end = position + size;
 
-		new_rect.size.x = (int)(MIN(p_rect_end.x, end.x) - new_rect.pos.x);
-		new_rect.size.y = (int)(MIN(p_rect_end.y, end.y) - new_rect.pos.y);
+		new_rect.size.x = (int)(MIN(p_rect_end.x, end.x) - new_rect.position.x);
+		new_rect.size.y = (int)(MIN(p_rect_end.y, end.y) - new_rect.position.y);
 
 		return new_rect;
 	}
@@ -491,25 +491,25 @@ struct Rect2i {
 
 		Rect2i new_rect;
 
-		new_rect.pos.x = MIN(p_rect.pos.x, pos.x);
-		new_rect.pos.y = MIN(p_rect.pos.y, pos.y);
+		new_rect.position.x = MIN(p_rect.position.x, position.x);
+		new_rect.position.y = MIN(p_rect.position.y, position.y);
 
-		new_rect.size.x = MAX(p_rect.pos.x + p_rect.size.x, pos.x + size.x);
-		new_rect.size.y = MAX(p_rect.pos.y + p_rect.size.y, pos.y + size.y);
+		new_rect.size.x = MAX(p_rect.position.x + p_rect.size.x, position.x + size.x);
+		new_rect.size.y = MAX(p_rect.position.y + p_rect.size.y, position.y + size.y);
 
-		new_rect.size = new_rect.size - new_rect.pos; //make relative again
+		new_rect.size = new_rect.size - new_rect.position; //make relative again
 
 		return new_rect;
 	};
 	bool has_point(const Point2 &p_point) const {
-		if (p_point.x < pos.x)
+		if (p_point.x < position.x)
 			return false;
-		if (p_point.y < pos.y)
+		if (p_point.y < position.y)
 			return false;
 
-		if (p_point.x >= (pos.x + size.x))
+		if (p_point.x >= (position.x + size.x))
 			return false;
-		if (p_point.y >= (pos.y + size.y))
+		if (p_point.y >= (position.y + size.y))
 			return false;
 
 		return true;
@@ -517,14 +517,14 @@ struct Rect2i {
 
 	bool no_area() { return (size.width <= 0 || size.height <= 0); }
 
-	bool operator==(const Rect2i &p_rect) const { return pos == p_rect.pos && size == p_rect.size; }
-	bool operator!=(const Rect2i &p_rect) const { return pos != p_rect.pos || size != p_rect.size; }
+	bool operator==(const Rect2i &p_rect) const { return position == p_rect.position && size == p_rect.size; }
+	bool operator!=(const Rect2i &p_rect) const { return position != p_rect.position || size != p_rect.size; }
 
 	Rect2i grow(int p_by) const {
 
 		Rect2i g = *this;
-		g.pos.x -= p_by;
-		g.pos.y -= p_by;
+		g.position.x -= p_by;
+		g.position.y -= p_by;
 		g.size.width += p_by * 2;
 		g.size.height += p_by * 2;
 		return g;
@@ -532,8 +532,8 @@ struct Rect2i {
 
 	inline void expand_to(const Point2i &p_vector) {
 
-		Point2i begin = pos;
-		Point2i end = pos + size;
+		Point2i begin = position;
+		Point2i end = position + size;
 
 		if (p_vector.x < begin.x)
 			begin.x = p_vector.x;
@@ -545,24 +545,24 @@ struct Rect2i {
 		if (p_vector.y > end.y)
 			end.y = p_vector.y;
 
-		pos = begin;
+		position = begin;
 		size = end - begin;
 	}
 
-	operator String() const { return String(pos) + ", " + String(size); }
+	operator String() const { return String(position) + ", " + String(size); }
 
-	operator Rect2() const { return Rect2(pos, size); }
+	operator Rect2() const { return Rect2(position, size); }
 	Rect2i(const Rect2 &p_r2) {
-		pos = p_r2.pos;
+		position = p_r2.position;
 		size = p_r2.size;
 	}
 	Rect2i() {}
 	Rect2i(int p_x, int p_y, int p_width, int p_height) {
-		pos = Point2(p_x, p_y);
+		position = Point2(p_x, p_y);
 		size = Size2(p_width, p_height);
 	}
 	Rect2i(const Point2 &p_pos, const Size2 &p_size) {
-		pos = p_pos;
+		position = p_pos;
 		size = p_size;
 	}
 };
@@ -668,30 +668,30 @@ bool Rect2::intersects_transformed(const Transform2D &p_xform, const Rect2 &p_re
 	//SAT intersection between local and transformed rect2
 
 	Vector2 xf_points[4] = {
-		p_xform.xform(p_rect.pos),
-		p_xform.xform(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y)),
-		p_xform.xform(Vector2(p_rect.pos.x, p_rect.pos.y + p_rect.size.y)),
-		p_xform.xform(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y + p_rect.size.y)),
+		p_xform.xform(p_rect.position),
+		p_xform.xform(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y)),
+		p_xform.xform(Vector2(p_rect.position.x, p_rect.position.y + p_rect.size.y)),
+		p_xform.xform(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y + p_rect.size.y)),
 	};
 
 	real_t low_limit;
 
 	//base rect2 first (faster)
 
-	if (xf_points[0].y > pos.y)
+	if (xf_points[0].y > position.y)
 		goto next1;
-	if (xf_points[1].y > pos.y)
+	if (xf_points[1].y > position.y)
 		goto next1;
-	if (xf_points[2].y > pos.y)
+	if (xf_points[2].y > position.y)
 		goto next1;
-	if (xf_points[3].y > pos.y)
+	if (xf_points[3].y > position.y)
 		goto next1;
 
 	return false;
 
 next1:
 
-	low_limit = pos.y + size.y;
+	low_limit = position.y + size.y;
 
 	if (xf_points[0].y < low_limit)
 		goto next2;
@@ -706,20 +706,20 @@ next1:
 
 next2:
 
-	if (xf_points[0].x > pos.x)
+	if (xf_points[0].x > position.x)
 		goto next3;
-	if (xf_points[1].x > pos.x)
+	if (xf_points[1].x > position.x)
 		goto next3;
-	if (xf_points[2].x > pos.x)
+	if (xf_points[2].x > position.x)
 		goto next3;
-	if (xf_points[3].x > pos.x)
+	if (xf_points[3].x > position.x)
 		goto next3;
 
 	return false;
 
 next3:
 
-	low_limit = pos.x + size.x;
+	low_limit = position.x + size.x;
 
 	if (xf_points[0].x < low_limit)
 		goto next4;
@@ -735,10 +735,10 @@ next3:
 next4:
 
 	Vector2 xf_points2[4] = {
-		pos,
-		Vector2(pos.x + size.x, pos.y),
-		Vector2(pos.x, pos.y + size.y),
-		Vector2(pos.x + size.x, pos.y + size.y),
+		position,
+		Vector2(position.x + size.x, position.y),
+		Vector2(position.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]);
@@ -847,10 +847,10 @@ Rect2 Transform2D::xform(const Rect2 &p_rect) const {
 
 	Vector2 x = elements[0] * p_rect.size.x;
 	Vector2 y = elements[1] * p_rect.size.y;
-	Vector2 pos = xform(p_rect.pos);
+	Vector2 pos = xform(p_rect.position);
 
 	Rect2 new_rect;
-	new_rect.pos = pos;
+	new_rect.position = pos;
 	new_rect.expand_to(pos + x);
 	new_rect.expand_to(pos + y);
 	new_rect.expand_to(pos + x + y);
@@ -868,14 +868,14 @@ void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
 Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const {
 
 	Vector2 ends[4] = {
-		xform_inv(p_rect.pos),
-		xform_inv(Vector2(p_rect.pos.x, p_rect.pos.y + p_rect.size.y)),
-		xform_inv(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y + p_rect.size.y)),
-		xform_inv(Vector2(p_rect.pos.x + p_rect.size.x, p_rect.pos.y))
+		xform_inv(p_rect.position),
+		xform_inv(Vector2(p_rect.position.x, p_rect.position.y + p_rect.size.y)),
+		xform_inv(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y + p_rect.size.y)),
+		xform_inv(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y))
 	};
 
 	Rect2 new_rect;
-	new_rect.pos = ends[0];
+	new_rect.position = ends[0];
 	new_rect.expand_to(ends[1]);
 	new_rect.expand_to(ends[2]);
 	new_rect.expand_to(ends[3]);

core/variant.cpp

@@ -2549,8 +2549,8 @@ uint32_t Variant::hash() const {
 		} break;
 		case RECT2: {
 
-			uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Rect2 *>(_data._mem)->pos.x);
-			hash = hash_djb2_one_float(reinterpret_cast<const Rect2 *>(_data._mem)->pos.y, hash);
+			uint32_t hash = hash_djb2_one_float(reinterpret_cast<const Rect2 *>(_data._mem)->position.x);
+			hash = hash_djb2_one_float(reinterpret_cast<const Rect2 *>(_data._mem)->position.y, hash);
 			hash = hash_djb2_one_float(reinterpret_cast<const Rect2 *>(_data._mem)->size.x, hash);
 			return hash_djb2_one_float(reinterpret_cast<const Rect2 *>(_data._mem)->size.y, hash);
 		} break;
@@ -2820,7 +2820,7 @@ bool Variant::hash_compare(const Variant &p_variant) const {
 			const Rect2 *l = reinterpret_cast<const Rect2 *>(_data._mem);
 			const Rect2 *r = reinterpret_cast<const Rect2 *>(p_variant._data._mem);
 
-			return (hash_compare_vector2(l->pos, r->pos)) &&
+			return (hash_compare_vector2(l->position, r->position)) &&
 				   (hash_compare_vector2(l->size, r->size));
 		} break;
 

core/variant_op.cpp

@@ -1131,9 +1131,9 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
 
 				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
 				Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
-				if (*str == "pos") {
+				if (*str == "position") {
 					valid = true;
-					v->pos = p_value;
+					v->position = p_value;
 					return;
 				} else if (*str == "size") {
 					valid = true;
@@ -1141,7 +1141,7 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid)
 					return;
 				} else if (*str == "end") {
 					valid = true;
-					v->size = Vector2(p_value) - v->pos;
+					v->size = Vector2(p_value) - v->position;
 					return;
 				}
 			}
@@ -1589,15 +1589,15 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const {
 
 				const String *str = reinterpret_cast<const String *>(p_index._data._mem);
 				const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
-				if (*str == "pos") {
+				if (*str == "position") {
 					valid = true;
-					return v->pos;
+					return v->position;
 				} else if (*str == "size") {
 					valid = true;
 					return v->size;
 				} else if (*str == "end") {
 					valid = true;
-					return v->size + v->pos;
+					return v->size + v->position;
 				}
 			}
 		} break;
@@ -2111,7 +2111,7 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const {
 		} break; // 5
 		case RECT2: {
 
-			p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos"));
+			p_list->push_back(PropertyInfo(Variant::VECTOR2, "position"));
 			p_list->push_back(PropertyInfo(Variant::VECTOR2, "size"));
 			p_list->push_back(PropertyInfo(Variant::VECTOR2, "end"));
 
@@ -2759,7 +2759,7 @@ void Variant::blend(const Variant &a, const Variant &b, float c, Variant &r_dst)
 		case RECT2: {
 			const Rect2 *ra = reinterpret_cast<const Rect2 *>(a._data._mem);
 			const Rect2 *rb = reinterpret_cast<const Rect2 *>(b._data._mem);
-			r_dst = Rect2(ra->pos + rb->pos * c, ra->size + rb->size * c);
+			r_dst = Rect2(ra->position + rb->position * c, ra->size + rb->size * c);
 		}
 			return;
 		case VECTOR3: {
@@ -2879,7 +2879,7 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &
 		}
 			return;
 		case RECT2: {
-			r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->pos.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->pos, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
+			r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
 		}
 			return;
 		case VECTOR3: {

core/variant_parser.cpp

@@ -1616,7 +1616,7 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str
 		case Variant::RECT2: {
 
 			Rect2 aabb = p_variant;
-			p_store_string_func(p_store_string_ud, "Rect2( " + rtosfix(aabb.pos.x) + ", " + rtosfix(aabb.pos.y) + ", " + rtosfix(aabb.size.x) + ", " + rtosfix(aabb.size.y) + " )");
+			p_store_string_func(p_store_string_ud, "Rect2( " + rtosfix(aabb.position.x) + ", " + rtosfix(aabb.position.y) + ", " + rtosfix(aabb.size.x) + ", " + rtosfix(aabb.size.y) + " )");
 
 		} break;
 		case Variant::VECTOR3: {

drivers/gles3/rasterizer_canvas_gles3.cpp

@@ -473,7 +473,7 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *cur
 					}
 
 					Size2 texpixel_size(1.0 / texture->width, 1.0 / texture->height);
-					Rect2 src_rect = (rect->flags & CANVAS_RECT_REGION) ? Rect2(rect->source.pos * texpixel_size, rect->source.size * texpixel_size) : Rect2(0, 0, 1, 1);
+					Rect2 src_rect = (rect->flags & CANVAS_RECT_REGION) ? Rect2(rect->source.position * texpixel_size, rect->source.size * texpixel_size) : Rect2(0, 0, 1, 1);
 
 					if (rect->flags & CANVAS_RECT_FLIP_H) {
 						src_rect.size.x *= -1;
@@ -489,8 +489,8 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *cur
 
 					state.canvas_shader.set_uniform(CanvasShaderGLES3::COLOR_TEXPIXEL_SIZE, texpixel_size);
 
-					glVertexAttrib4f(1, rect->rect.pos.x, rect->rect.pos.y, rect->rect.size.x, rect->rect.size.y);
-					glVertexAttrib4f(2, src_rect.pos.x, src_rect.pos.y, src_rect.size.x, src_rect.size.y);
+					glVertexAttrib4f(1, rect->rect.position.x, rect->rect.position.y, rect->rect.size.x, rect->rect.size.y);
+					glVertexAttrib4f(2, src_rect.position.x, src_rect.position.y, src_rect.size.x, src_rect.size.y);
 					glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 					if (untile) {
@@ -500,7 +500,7 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *cur
 
 				} else {
 
-					glVertexAttrib4f(1, rect->rect.pos.x, rect->rect.pos.y, rect->rect.size.x, rect->rect.size.y);
+					glVertexAttrib4f(1, rect->rect.position.x, rect->rect.position.y, rect->rect.size.x, rect->rect.size.y);
 					glVertexAttrib4f(2, 0, 0, 1, 1);
 					glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 				}
@@ -521,7 +521,7 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *cur
 
 				if (!texture) {
 
-					glVertexAttrib4f(1, np->rect.pos.x, np->rect.pos.y, np->rect.size.x, np->rect.size.y);
+					glVertexAttrib4f(1, np->rect.position.x, np->rect.position.y, np->rect.size.x, np->rect.size.y);
 					glVertexAttrib4f(2, 0, 0, 1, 1);
 					glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 					continue;
@@ -535,50 +535,50 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *cur
 #define SRCRECT(m_x, m_y, m_w, m_h) glVertexAttrib4f(2, (m_x)*texpixel_size.x, (m_y)*texpixel_size.y, (m_w)*texpixel_size.x, (m_h)*texpixel_size.y)
 
 				//top left
-				DSTRECT(np->rect.pos.x, np->rect.pos.y, np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
-				SRCRECT(np->source.pos.x, np->source.pos.y, np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
+				DSTRECT(np->rect.position.x, np->rect.position.y, np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
+				SRCRECT(np->source.position.x, np->source.position.y, np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//top right
-				DSTRECT(np->rect.pos.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.pos.y, np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
-				SRCRECT(np->source.pos.x + np->source.size.width - np->margin[MARGIN_RIGHT], np->source.pos.y, np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+				DSTRECT(np->rect.position.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.position.y, np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+				SRCRECT(np->source.position.x + np->source.size.width - np->margin[MARGIN_RIGHT], np->source.position.y, np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//bottom right
-				DSTRECT(np->rect.pos.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.pos.y + np->rect.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_RIGHT], np->margin[MARGIN_BOTTOM]);
-				SRCRECT(np->source.pos.x + np->source.size.width - np->margin[MARGIN_RIGHT], np->source.pos.y + np->source.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_RIGHT], np->margin[MARGIN_BOTTOM]);
+				DSTRECT(np->rect.position.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.position.y + np->rect.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_RIGHT], np->margin[MARGIN_BOTTOM]);
+				SRCRECT(np->source.position.x + np->source.size.width - np->margin[MARGIN_RIGHT], np->source.position.y + np->source.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_RIGHT], np->margin[MARGIN_BOTTOM]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//bottom left
-				DSTRECT(np->rect.pos.x, np->rect.pos.y + np->rect.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_LEFT], np->margin[MARGIN_BOTTOM]);
-				SRCRECT(np->source.pos.x, np->source.pos.y + np->source.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_LEFT], np->margin[MARGIN_BOTTOM]);
+				DSTRECT(np->rect.position.x, np->rect.position.y + np->rect.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_LEFT], np->margin[MARGIN_BOTTOM]);
+				SRCRECT(np->source.position.x, np->source.position.y + np->source.size.height - np->margin[MARGIN_BOTTOM], np->margin[MARGIN_LEFT], np->margin[MARGIN_BOTTOM]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//top
-				DSTRECT(np->rect.pos.x + np->margin[MARGIN_LEFT], np->rect.pos.y, np->rect.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
-				SRCRECT(np->source.pos.x + np->margin[MARGIN_LEFT], np->source.pos.y, np->source.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+				DSTRECT(np->rect.position.x + np->margin[MARGIN_LEFT], np->rect.position.y, np->rect.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+				SRCRECT(np->source.position.x + np->margin[MARGIN_LEFT], np->source.position.y, np->source.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//bottom
-				DSTRECT(np->rect.pos.x + np->margin[MARGIN_LEFT], np->rect.pos.y + np->rect.size.height - np->margin[MARGIN_BOTTOM], np->rect.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
-				SRCRECT(np->source.pos.x + np->margin[MARGIN_LEFT], np->source.pos.y + np->source.size.height - np->margin[MARGIN_BOTTOM], np->source.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
+				DSTRECT(np->rect.position.x + np->margin[MARGIN_LEFT], np->rect.position.y + np->rect.size.height - np->margin[MARGIN_BOTTOM], np->rect.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->margin[MARGIN_TOP]);
+				SRCRECT(np->source.position.x + np->margin[MARGIN_LEFT], np->source.position.y + np->source.size.height - np->margin[MARGIN_BOTTOM], np->source.size.width - np->margin[MARGIN_LEFT] - np->margin[MARGIN_LEFT], np->margin[MARGIN_TOP]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//left
-				DSTRECT(np->rect.pos.x, np->rect.pos.y + np->margin[MARGIN_TOP], np->margin[MARGIN_LEFT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
-				SRCRECT(np->source.pos.x, np->source.pos.y + np->margin[MARGIN_TOP], np->margin[MARGIN_LEFT], np->source.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+				DSTRECT(np->rect.position.x, np->rect.position.y + np->margin[MARGIN_TOP], np->margin[MARGIN_LEFT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+				SRCRECT(np->source.position.x, np->source.position.y + np->margin[MARGIN_TOP], np->margin[MARGIN_LEFT], np->source.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				//right
-				DSTRECT(np->rect.pos.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.pos.y + np->margin[MARGIN_TOP], np->margin[MARGIN_RIGHT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
-				SRCRECT(np->source.pos.x + np->source.size.width - np->margin[MARGIN_RIGHT], np->source.pos.y + np->margin[MARGIN_TOP], np->margin[MARGIN_RIGHT], np->source.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+				DSTRECT(np->rect.position.x + np->rect.size.width - np->margin[MARGIN_RIGHT], np->rect.position.y + np->margin[MARGIN_TOP], np->margin[MARGIN_RIGHT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+				SRCRECT(np->source.position.x + np->source.size.width - np->margin[MARGIN_RIGHT], np->source.position.y + np->margin[MARGIN_TOP], np->margin[MARGIN_RIGHT], np->source.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
 				glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
 				if (np->draw_center) {
 
 					//center
-					DSTRECT(np->rect.pos.x + np->margin[MARGIN_LEFT], np->rect.pos.y + np->margin[MARGIN_TOP], np->rect.size.x - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
-					SRCRECT(np->source.pos.x + np->margin[MARGIN_LEFT], np->source.pos.y + np->margin[MARGIN_TOP], np->source.size.x - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->source.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+					DSTRECT(np->rect.position.x + np->margin[MARGIN_LEFT], np->rect.position.y + np->margin[MARGIN_TOP], np->rect.size.x - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->rect.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
+					SRCRECT(np->source.position.x + np->margin[MARGIN_LEFT], np->source.position.y + np->margin[MARGIN_TOP], np->source.size.x - np->margin[MARGIN_LEFT] - np->margin[MARGIN_RIGHT], np->source.size.height - np->margin[MARGIN_TOP] - np->margin[MARGIN_BOTTOM]);
 					glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 				}
 
@@ -670,8 +670,8 @@ void RasterizerCanvasGLES3::_canvas_item_render_commands(Item *p_item, Item *cur
 							//glScissor(viewport.x+current_clip->final_clip_rect.pos.x,viewport.y+ (viewport.height-(current_clip->final_clip_rect.pos.y+current_clip->final_clip_rect.size.height)),
 							//current_clip->final_clip_rect.size.width,current_clip->final_clip_rect.size.height);
 
-							int x = current_clip->final_clip_rect.pos.x;
-							int y = storage->frame.current_rt->height - (current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.y);
+							int x = current_clip->final_clip_rect.position.x;
+							int y = storage->frame.current_rt->height - (current_clip->final_clip_rect.position.y + current_clip->final_clip_rect.size.y);
 							int w = current_clip->final_clip_rect.size.x;
 							int h = current_clip->final_clip_rect.size.y;
 
@@ -787,7 +787,7 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list, int p_z, cons
 			if (current_clip) {
 
 				glEnable(GL_SCISSOR_TEST);
-				glScissor(current_clip->final_clip_rect.pos.x, (rt_size.height - (current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.height)), current_clip->final_clip_rect.size.width, current_clip->final_clip_rect.size.height);
+				glScissor(current_clip->final_clip_rect.position.x, (rt_size.height - (current_clip->final_clip_rect.position.y + current_clip->final_clip_rect.size.height)), current_clip->final_clip_rect.size.width, current_clip->final_clip_rect.size.height);
 
 			} else {
 
@@ -1108,7 +1108,7 @@ void RasterizerCanvasGLES3::canvas_render_items(Item *p_item_list, int p_z, cons
 		if (reclip) {
 
 			glEnable(GL_SCISSOR_TEST);
-			glScissor(current_clip->final_clip_rect.pos.x, (rt_size.height - (current_clip->final_clip_rect.pos.y + current_clip->final_clip_rect.size.height)), current_clip->final_clip_rect.size.width, current_clip->final_clip_rect.size.height);
+			glScissor(current_clip->final_clip_rect.position.x, (rt_size.height - (current_clip->final_clip_rect.position.y + current_clip->final_clip_rect.size.height)), current_clip->final_clip_rect.size.width, current_clip->final_clip_rect.size.height);
 		}
 
 		p_item_list = p_item_list->next;
@@ -1340,8 +1340,8 @@ void RasterizerCanvasGLES3::reset_canvas() {
 
 void RasterizerCanvasGLES3::draw_generic_textured_rect(const Rect2 &p_rect, const Rect2 &p_src) {
 
-	glVertexAttrib4f(1, p_rect.pos.x, p_rect.pos.y, p_rect.size.x, p_rect.size.y);
-	glVertexAttrib4f(2, p_src.pos.x, p_src.pos.y, p_src.size.x, p_src.size.y);
+	glVertexAttrib4f(1, p_rect.position.x, p_rect.position.y, p_rect.size.x, p_rect.size.y);
+	glVertexAttrib4f(2, p_src.position.x, p_src.position.y, p_src.size.x, p_src.size.y);
 	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 }
 

drivers/gles3/rasterizer_gles3.cpp

@@ -301,18 +301,18 @@ void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_c
 			//scale horizontally
 			screenrect.size.y = window_h;
 			screenrect.size.x = imgrect.size.x * window_h / imgrect.size.y;
-			screenrect.pos.x = (window_w - screenrect.size.x) / 2;
+			screenrect.position.x = (window_w - screenrect.size.x) / 2;
 
 		} else {
 			//scale vertically
 			screenrect.size.x = window_w;
 			screenrect.size.y = imgrect.size.y * window_w / imgrect.size.x;
-			screenrect.pos.y = (window_h - screenrect.size.y) / 2;
+			screenrect.position.y = (window_h - screenrect.size.y) / 2;
 		}
 	} else {
 
 		screenrect = imgrect;
-		screenrect.pos += ((Size2(window_w, window_h) - screenrect.size) / 2.0).floor();
+		screenrect.position += ((Size2(window_w, window_h) - screenrect.size) / 2.0).floor();
 	}
 
 	RasterizerStorageGLES3::Texture *t = storage->texture_owner.get(texture);

drivers/gles3/rasterizer_scene_gles3.cpp

@@ -2343,8 +2343,8 @@ void RasterizerSceneGLES3::_setup_directional_light(int p_index, const Transform
 
 		for (int j = 0; j < shadow_count; j++) {
 
-			uint32_t x = li->directional_rect.pos.x;
-			uint32_t y = li->directional_rect.pos.y;
+			uint32_t x = li->directional_rect.position.x;
+			uint32_t y = li->directional_rect.position.y;
 			uint32_t width = li->directional_rect.size.x;
 			uint32_t height = li->directional_rect.size.y;
 
@@ -2389,8 +2389,8 @@ void RasterizerSceneGLES3::_setup_directional_light(int p_index, const Transform
 
 			store_camera(shadow_mtx, &ubo_data.shadow_matrix1[16 * j]);
 
-			ubo_data.light_clamp[0] = atlas_rect.pos.x;
-			ubo_data.light_clamp[1] = atlas_rect.pos.y;
+			ubo_data.light_clamp[0] = atlas_rect.position.x;
+			ubo_data.light_clamp[1] = atlas_rect.position.y;
 			ubo_data.light_clamp[2] = atlas_rect.size.x;
 			ubo_data.light_clamp[3] = atlas_rect.size.y;
 		}
@@ -2579,8 +2579,8 @@ void RasterizerSceneGLES3::_setup_lights(RID *p_light_cull_result, int p_light_c
 					Rect2 rect(float(x) / atlas_size, float(y) / atlas_size, float(width) / atlas_size, float(height) / atlas_size);
 
 					ubo_data.light_params[3] = 1.0; //means it has shadow
-					ubo_data.light_clamp[0] = rect.pos.x;
-					ubo_data.light_clamp[1] = rect.pos.y;
+					ubo_data.light_clamp[0] = rect.position.x;
+					ubo_data.light_clamp[1] = rect.position.y;
 					ubo_data.light_clamp[2] = rect.size.x;
 					ubo_data.light_clamp[3] = rect.size.y;
 
@@ -4167,15 +4167,15 @@ void RasterizerSceneGLES3::render_shadow(RID p_light, RID p_shadow_atlas, int p_
 			} else if (directional_shadow.light_count == 2) {
 				light_instance->directional_rect = Rect2(0, 0, directional_shadow.size, directional_shadow.size / 2);
 				if (light_instance->light_directional_index == 1) {
-					light_instance->directional_rect.pos.x += light_instance->directional_rect.size.x;
+					light_instance->directional_rect.position.x += light_instance->directional_rect.size.x;
 				}
 			} else { //3 and 4
 				light_instance->directional_rect = Rect2(0, 0, directional_shadow.size / 2, directional_shadow.size / 2);
 				if (light_instance->light_directional_index & 1) {
-					light_instance->directional_rect.pos.x += light_instance->directional_rect.size.x;
+					light_instance->directional_rect.position.x += light_instance->directional_rect.size.x;
 				}
 				if (light_instance->light_directional_index / 2) {
-					light_instance->directional_rect.pos.y += light_instance->directional_rect.size.y;
+					light_instance->directional_rect.position.y += light_instance->directional_rect.size.y;
 				}
 			}
 		}
@@ -4183,8 +4183,8 @@ void RasterizerSceneGLES3::render_shadow(RID p_light, RID p_shadow_atlas, int p_
 		light_projection = light_instance->shadow_transform[p_pass].camera;
 		light_transform = light_instance->shadow_transform[p_pass].transform;
 
-		x = light_instance->directional_rect.pos.x;
-		y = light_instance->directional_rect.pos.y;
+		x = light_instance->directional_rect.position.x;
+		y = light_instance->directional_rect.position.y;
 		width = light_instance->directional_rect.size.x;
 		height = light_instance->directional_rect.size.y;
 

drivers/gles3/rasterizer_storage_gles3.cpp

@@ -1961,8 +1961,8 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 			} else if (value.get_type() == Variant::RECT2) {
 				Rect2 v = value;
 
-				gui[0] = v.pos.x;
-				gui[1] = v.pos.y;
+				gui[0] = v.position.x;
+				gui[1] = v.position.y;
 				gui[2] = v.size.x;
 				gui[3] = v.size.y;
 			} else if (value.get_type() == Variant::QUAT) {

editor/animation_editor.cpp

@@ -76,7 +76,7 @@ private:
 			Ref<StyleBox> sb = get_stylebox("normal", "LineEdit");
 			sb->draw(ci, r);
 			r.size -= sb->get_minimum_size();
-			r.pos += sb->get_offset();
+			r.position += sb->get_offset();
 			//VisualServer::get_singleton()->canvas_item_add
 
 			Ref<Font> f = get_font("font", "Label");
@@ -111,7 +111,7 @@ private:
 							iflp = 1.0 - iflp;
 						}
 
-						VisualServer::get_singleton()->canvas_item_add_line(ci, r.pos + Point2(iflp * r.size.width, prev * r.size.height), r.pos + Point2(ifl * r.size.width, h * r.size.height), mcolor);
+						VisualServer::get_singleton()->canvas_item_add_line(ci, r.position + Point2(iflp * r.size.width, prev * r.size.height), r.position + Point2(ifl * r.size.width, h * r.size.height), mcolor);
 						prev = h;
 					}
 
@@ -138,7 +138,7 @@ private:
 						iflp = 1.0 - iflp;
 					}
 
-					VisualServer::get_singleton()->canvas_item_add_line(ci, r.pos + Point2(iflp * r.size.width, prev * r.size.height), r.pos + Point2(ifl * r.size.width, h * r.size.height), color);
+					VisualServer::get_singleton()->canvas_item_add_line(ci, r.position + Point2(iflp * r.size.width, prev * r.size.height), r.position + Point2(ifl * r.size.width, h * r.size.height), color);
 					prev = h;
 				}
 			}
@@ -2076,7 +2076,7 @@ void AnimationKeyEditor::_track_editor_gui_input(const Ref<InputEvent> &p_input)
 
 					Rect2 area(ofs.x, ofs.y + ((int(mpos.y) / h) + 1) * h, name_limit, h);
 					track_name->set_text(animation->track_get_path(idx));
-					track_name->set_position(te->get_global_position() + area.pos);
+					track_name->set_position(te->get_global_position() + area.position);
 					track_name->set_size(area.size);
 					track_name->show_modal();
 					track_name->grab_focus();

editor/editor_audio_buses.cpp

@@ -342,7 +342,7 @@ void EditorAudioBus::_effect_edited() {
 	if (effect->get_metadata(0) == Variant()) {
 		Rect2 area = effects->get_item_rect(effect);
 
-		effect_options->set_position(effects->get_global_position() + area.pos + Vector2(0, area.size.y));
+		effect_options->set_position(effects->get_global_position() + area.position + Vector2(0, area.size.y));
 		effect_options->popup();
 		//add effect
 	} else {

editor/editor_fonts.cpp

@@ -49,8 +49,8 @@ static Ref<BitmapFont> make_font(int p_height, int p_ascent, int p_valign, int p
 
 		int chr = c[0];
 		Rect2 frect;
-		frect.pos.x = c[1];
-		frect.pos.y = c[2];
+		frect.position.x = c[1];
+		frect.position.y = c[2];
 		frect.size.x = c[3];
 		frect.size.y = c[4];
 		Point2 align(c[5], c[6] + p_valign);

editor/editor_node.cpp

@@ -3846,7 +3846,7 @@ void EditorNode::_dock_select_draw() {
 	unusable.a = 0.1;
 
 	Rect2 unr(s.x * 2, 0, s.x * 2, s.y * 2);
-	unr.pos += Vector2(2, 5);
+	unr.position += Vector2(2, 5);
 	unr.size -= Vector2(4, 7);
 
 	dock_select->draw_rect(unr, unusable);
@@ -3899,7 +3899,7 @@ void EditorNode::_dock_select_draw() {
 
 		Rect2 r(ofs, s);
 		dock_select_rect[i] = r;
-		r.pos += Vector2(2, 5);
+		r.position += Vector2(2, 5);
 		r.size -= Vector2(4, 7);
 
 		if (i == dock_select_rect_over) {

editor/editor_run.cpp

@@ -73,7 +73,7 @@ Error EditorRun::run(const String &p_scene, const String p_custom_args, const Li
 	}
 
 	Rect2 screen_rect;
-	screen_rect.pos = OS::get_singleton()->get_screen_position(screen);
+	screen_rect.position = OS::get_singleton()->get_screen_position(screen);
 	screen_rect.size = OS::get_singleton()->get_screen_size(screen);
 
 	Size2 desired_size;
@@ -95,21 +95,21 @@ Error EditorRun::run(const String &p_scene, const String p_custom_args, const Li
 		case 0: { // default
 
 			args.push_back("-p");
-			args.push_back(itos(screen_rect.pos.x) + "x" + itos(screen_rect.pos.y));
+			args.push_back(itos(screen_rect.position.x) + "x" + itos(screen_rect.position.y));
 		} break;
 		case 1: { // centered
-			Vector2 pos = screen_rect.pos + ((screen_rect.size - desired_size) / 2).floor();
+			Vector2 pos = screen_rect.position + ((screen_rect.size - desired_size) / 2).floor();
 			args.push_back("-p");
 			args.push_back(itos(pos.x) + "x" + itos(pos.y));
 		} break;
 		case 2: { // custom pos
 			Vector2 pos = EditorSettings::get_singleton()->get("run/window_placement/rect_custom_position");
-			pos += screen_rect.pos;
+			pos += screen_rect.position;
 			args.push_back("-p");
 			args.push_back(itos(pos.x) + "x" + itos(pos.y));
 		} break;
 		case 3: { // force maximized
-			Vector2 pos = screen_rect.pos;
+			Vector2 pos = screen_rect.position;
 			args.push_back("-p");
 			args.push_back(itos(pos.x) + "x" + itos(pos.y));
 			args.push_back("-mx");
@@ -117,7 +117,7 @@ Error EditorRun::run(const String &p_scene, const String p_custom_args, const Li
 		} break;
 		case 4: { // force fullscreen
 
-			Vector2 pos = screen_rect.pos;
+			Vector2 pos = screen_rect.position;
 			args.push_back("-p");
 			args.push_back(itos(pos.x) + "x" + itos(pos.y));
 			args.push_back("-f");

editor/plugins/animation_tree_editor_plugin.cpp

@@ -876,7 +876,7 @@ void AnimationTreeEditor::_draw_cos_line(const Vector2 &p_from, const Vector2 &p
 	static const int steps = 20;
 
 	Rect2 r;
-	r.pos = p_from;
+	r.position = p_from;
 	r.expand_to(p_to);
 	Vector2 sign = Vector2((p_from.x < p_to.x) ? 1 : -1, (p_from.y < p_to.y) ? 1 : -1);
 	bool flip = sign.x * sign.y < 0;
@@ -888,7 +888,7 @@ void AnimationTreeEditor::_draw_cos_line(const Vector2 &p_from, const Vector2 &p
 		float c = -Math::cos(d * Math_PI) * 0.5 + 0.5;
 		if (flip)
 			c = 1.0 - c;
-		Vector2 p = r.pos + Vector2(d * r.size.width, c * r.size.height);
+		Vector2 p = r.position + Vector2(d * r.size.width, c * r.size.height);
 
 		if (i > 0) {
 

editor/plugins/canvas_item_editor_plugin.cpp

@@ -536,10 +536,10 @@ void CanvasItemEditor::_find_canvas_items_at_rect(const Rect2 &p_rect, Node *p_n
 		Rect2 rect = c->get_item_rect();
 		Transform2D xform = p_parent_xform * p_canvas_xform * c->get_transform();
 
-		if (p_rect.has_point(xform.xform(rect.pos)) &&
-				p_rect.has_point(xform.xform(rect.pos + Vector2(rect.size.x, 0))) &&
-				p_rect.has_point(xform.xform(rect.pos + Vector2(rect.size.x, rect.size.y))) &&
-				p_rect.has_point(xform.xform(rect.pos + Vector2(0, rect.size.y)))) {
+		if (p_rect.has_point(xform.xform(rect.position)) &&
+				p_rect.has_point(xform.xform(rect.position + Vector2(rect.size.x, 0))) &&
+				p_rect.has_point(xform.xform(rect.position + Vector2(rect.size.x, rect.size.y))) &&
+				p_rect.has_point(xform.xform(rect.position + Vector2(0, rect.size.y)))) {
 
 			r_items->push_back(c);
 		}
@@ -652,7 +652,7 @@ void CanvasItemEditor::_key_move(const Vector2 &p_dir, bool p_snap, KeyMoveMODE
 			// drag =  transform.affine_inverse().basis_xform(p_dir); // zoom sensitive
 			drag = canvas_item->get_global_transform_with_canvas().affine_inverse().basis_xform(drag);
 			Rect2 local_rect = canvas_item->get_item_rect();
-			local_rect.pos += drag;
+			local_rect.position += drag;
 			undo_redo->add_do_method(canvas_item, "edit_set_rect", local_rect);
 
 		} else { // p_move_mode==MOVE_LOCAL_BASE || p_move_mode==MOVE_LOCAL_WITH_ROT
@@ -680,7 +680,7 @@ Point2 CanvasItemEditor::_find_topleftmost_point() {
 
 	Vector2 tl = Point2(1e10, 1e10);
 	Rect2 r2;
-	r2.pos = tl;
+	r2.position = tl;
 
 	List<Node *> &selection = editor_selection->get_selected_node_list();
 
@@ -695,13 +695,13 @@ Point2 CanvasItemEditor::_find_topleftmost_point() {
 		Rect2 rect = canvas_item->get_item_rect();
 		Transform2D xform = canvas_item->get_global_transform_with_canvas();
 
-		r2.expand_to(xform.xform(rect.pos));
-		r2.expand_to(xform.xform(rect.pos + Vector2(rect.size.x, 0)));
-		r2.expand_to(xform.xform(rect.pos + rect.size));
-		r2.expand_to(xform.xform(rect.pos + Vector2(0, rect.size.y)));
+		r2.expand_to(xform.xform(rect.position));
+		r2.expand_to(xform.xform(rect.position + Vector2(rect.size.x, 0)));
+		r2.expand_to(xform.xform(rect.position + rect.size));
+		r2.expand_to(xform.xform(rect.position + Vector2(0, rect.size.y)));
 	}
 
-	return r2.pos;
+	return r2.position;
 }
 
 int CanvasItemEditor::get_item_count() {
@@ -759,18 +759,18 @@ CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Transform2D &
 
 	Vector2 endpoints[4] = {
 
-		xform.xform(rect.pos),
-		xform.xform(rect.pos + Vector2(rect.size.x, 0)),
-		xform.xform(rect.pos + rect.size),
-		xform.xform(rect.pos + Vector2(0, rect.size.y))
+		xform.xform(rect.position),
+		xform.xform(rect.position + Vector2(rect.size.x, 0)),
+		xform.xform(rect.position + rect.size),
+		xform.xform(rect.position + Vector2(0, rect.size.y))
 	};
 
 	Vector2 endpointsl[4] = {
 
-		xforml.xform(rect.pos),
-		xforml.xform(rect.pos + Vector2(rect.size.x, 0)),
-		xforml.xform(rect.pos + rect.size),
-		xforml.xform(rect.pos + Vector2(0, rect.size.y))
+		xforml.xform(rect.position),
+		xforml.xform(rect.position + Vector2(rect.size.x, 0)),
+		xforml.xform(rect.position + rect.size),
+		xforml.xform(rect.position + Vector2(0, rect.size.y))
 	};
 
 	DragType dragger[] = {
@@ -1552,8 +1552,8 @@ void CanvasItemEditor::_viewport_gui_input(const Ref<InputEvent> &p_event) {
 					canvas_item->get_global_transform_with_canvas().affine_inverse().xform(dfrom);
 
 			Rect2 local_rect = canvas_item->get_item_rect();
-			Vector2 begin = local_rect.pos;
-			Vector2 end = local_rect.pos + local_rect.size;
+			Vector2 begin = local_rect.position;
+			Vector2 end = local_rect.position + local_rect.size;
 			Vector2 minsize = canvas_item->edit_get_minimum_size();
 
 			if (uniform) {
@@ -1645,7 +1645,7 @@ void CanvasItemEditor::_viewport_gui_input(const Ref<InputEvent> &p_event) {
 
 			if (!dragging_bone) {
 
-				local_rect.pos = begin;
+				local_rect.position = begin;
 				local_rect.size = end - begin;
 				canvas_item->edit_set_rect(local_rect);
 
@@ -1868,10 +1868,10 @@ void CanvasItemEditor::_viewport_draw() {
 
 		Vector2 endpoints[4] = {
 
-			xform.xform(rect.pos),
-			xform.xform(rect.pos + Vector2(rect.size.x, 0)),
-			xform.xform(rect.pos + rect.size),
-			xform.xform(rect.pos + Vector2(0, rect.size.y))
+			xform.xform(rect.position),
+			xform.xform(rect.position + Vector2(rect.size.x, 0)),
+			xform.xform(rect.position + rect.size),
+			xform.xform(rect.position + Vector2(0, rect.size.y))
 		};
 
 		Color c = Color(1, 0.6, 0.4, 0.7);
@@ -2212,7 +2212,7 @@ void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2 &r_rect, cons
 		lock.group = c->has_meta("_edit_group_");
 
 		if (lock.group || lock.lock) {
-			lock.pos = xform.xform(rect.pos);
+			lock.pos = xform.xform(rect.position);
 			lock_list.push_back(lock);
 		}
 
@@ -2228,10 +2228,10 @@ void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2 &r_rect, cons
 			bone_list[id].last_pass = bone_last_frame;
 		}
 
-		r_rect.expand_to(xform.xform(rect.pos));
-		r_rect.expand_to(xform.xform(rect.pos + Point2(rect.size.x, 0)));
-		r_rect.expand_to(xform.xform(rect.pos + Point2(0, rect.size.y)));
-		r_rect.expand_to(xform.xform(rect.pos + rect.size));
+		r_rect.expand_to(xform.xform(rect.position));
+		r_rect.expand_to(xform.xform(rect.position + Point2(rect.size.x, 0)));
+		r_rect.expand_to(xform.xform(rect.position + Point2(0, rect.size.y)));
+		r_rect.expand_to(xform.xform(rect.position + rect.size));
 	}
 }
 
@@ -2277,19 +2277,19 @@ void CanvasItemEditor::_update_scrollbars() {
 
 	//expand area so it's easier to do animations and stuff at 0,0
 	canvas_item_rect.size += screen_rect * 2;
-	canvas_item_rect.pos -= screen_rect;
+	canvas_item_rect.position -= screen_rect;
 
 	Point2 ofs;
 
 	if (canvas_item_rect.size.height <= (local_rect.size.y / zoom)) {
 
 		v_scroll->hide();
-		ofs.y = canvas_item_rect.pos.y;
+		ofs.y = canvas_item_rect.position.y;
 	} else {
 
 		v_scroll->show();
-		v_scroll->set_min(canvas_item_rect.pos.y);
-		v_scroll->set_max(canvas_item_rect.pos.y + canvas_item_rect.size.y);
+		v_scroll->set_min(canvas_item_rect.position.y);
+		v_scroll->set_max(canvas_item_rect.position.y + canvas_item_rect.size.y);
 		v_scroll->set_page(local_rect.size.y / zoom);
 		if (first_update) {
 			//so 0,0 is visible
@@ -2304,12 +2304,12 @@ void CanvasItemEditor::_update_scrollbars() {
 	if (canvas_item_rect.size.width <= (local_rect.size.x / zoom)) {
 
 		h_scroll->hide();
-		ofs.x = canvas_item_rect.pos.x;
+		ofs.x = canvas_item_rect.position.x;
 	} else {
 
 		h_scroll->show();
-		h_scroll->set_min(canvas_item_rect.pos.x);
-		h_scroll->set_max(canvas_item_rect.pos.x + canvas_item_rect.size.x);
+		h_scroll->set_min(canvas_item_rect.position.x);
+		h_scroll->set_max(canvas_item_rect.position.x + canvas_item_rect.size.x);
 		h_scroll->set_page(local_rect.size.x / zoom);
 		ofs.x = h_scroll->get_value();
 	}
@@ -2977,7 +2977,7 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 
 		Transform2D t(angle, Vector2(0.f, 0.f));
 		item_rect = t.xform(item_rect);
-		Rect2 canvas_item_rect(pos + scale * item_rect.pos, scale * item_rect.size);
+		Rect2 canvas_item_rect(pos + scale * item_rect.position, scale * item_rect.size);
 		if (count == 1) {
 			rect = canvas_item_rect;
 		} else {
@@ -2988,7 +2988,7 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 
 	if (p_op == VIEW_CENTER_TO_SELECTION) {
 
-		center = rect.pos + rect.size / 2;
+		center = rect.position + rect.size / 2;
 		Vector2 offset = viewport->get_size() / 2 - editor->get_scene_root()->get_global_canvas_transform().xform(center);
 		h_scroll->set_value(h_scroll->get_value() - offset.x / zoom);
 		v_scroll->set_value(v_scroll->get_value() - offset.y / zoom);

editor/plugins/polygon_2d_editor_plugin.cpp

@@ -675,14 +675,14 @@ void Polygon2DEditor::_uv_draw() {
 
 	rect = rect.grow(200);
 	updating_uv_scroll = true;
-	uv_hscroll->set_min(rect.pos.x);
-	uv_hscroll->set_max(rect.pos.x + rect.size.x);
+	uv_hscroll->set_min(rect.position.x);
+	uv_hscroll->set_max(rect.position.x + rect.size.x);
 	uv_hscroll->set_page(uv_edit_draw->get_size().x);
 	uv_hscroll->set_value(uv_draw_ofs.x);
 	uv_hscroll->set_step(0.001);
 
-	uv_vscroll->set_min(rect.pos.y);
-	uv_vscroll->set_max(rect.pos.y + rect.size.y);
+	uv_vscroll->set_min(rect.position.y);
+	uv_vscroll->set_max(rect.position.y + rect.size.y);
 	uv_vscroll->set_page(uv_edit_draw->get_size().y);
 	uv_vscroll->set_value(uv_draw_ofs.y);
 	uv_vscroll->set_step(0.001);

editor/plugins/spatial_editor_plugin.cpp

@@ -1752,10 +1752,10 @@ static void stroke_rect(CanvasItem *ci, Rect2 rect, Color color, real_t width =
 	// a---b
 	// |   |
 	// c---d
-	Vector2 a(rect.pos);
-	Vector2 b(rect.pos.x + rect.size.x, rect.pos.y);
-	Vector2 c(rect.pos.x, rect.pos.y + rect.size.y);
-	Vector2 d(rect.pos + rect.size);
+	Vector2 a(rect.position);
+	Vector2 b(rect.position.x + rect.size.x, rect.position.y);
+	Vector2 c(rect.position.x, rect.position.y + rect.size.y);
+	Vector2 d(rect.position + rect.size);
 
 	ci->draw_line(a, b, color, width);
 	ci->draw_line(b, d, color, width);
@@ -1804,15 +1804,15 @@ void SpatialEditorViewport::_draw() {
 			case Camera::KEEP_WIDTH: {
 
 				draw_rect.size = Size2(s.width, s.width / aspect);
-				draw_rect.pos.x = 0;
-				draw_rect.pos.y = (s.height - draw_rect.size.y) * 0.5;
+				draw_rect.position.x = 0;
+				draw_rect.position.y = (s.height - draw_rect.size.y) * 0.5;
 
 			} break;
 			case Camera::KEEP_HEIGHT: {
 
 				draw_rect.size = Size2(s.height * aspect, s.height);
-				draw_rect.pos.y = 0;
-				draw_rect.pos.x = (s.width - draw_rect.size.x) * 0.5;
+				draw_rect.position.y = 0;
+				draw_rect.position.x = (s.width - draw_rect.size.x) * 0.5;
 
 			} break;
 		}
@@ -1846,7 +1846,7 @@ void SpatialEditorViewport::_draw() {
 				real_t sy = r.size.y * logscale_t;
 
 				surface->draw_rect(r, Color(1, 1, 1, 0.2));
-				surface->draw_rect(Rect2(r.pos.x, r.pos.y + r.size.y - sy, r.size.x, sy), Color(1, 1, 1, 0.6));
+				surface->draw_rect(Rect2(r.position.x, r.position.y + r.size.y - sy, r.size.x, sy), Color(1, 1, 1, 0.6));
 				stroke_rect(surface, r.grow(1), Color(0, 0, 0, 0.7));
 			}
 		}

editor/plugins/texture_region_editor_plugin.cpp

@@ -114,10 +114,10 @@ void TextureRegionEditor::_region_draw() {
 		for (List<Rect2>::Element *E = autoslice_cache.front(); E; E = E->next()) {
 			Rect2 r = E->get();
 			Vector2 endpoints[4] = {
-				mtx.basis_xform(r.pos),
-				mtx.basis_xform(r.pos + Vector2(r.size.x, 0)),
-				mtx.basis_xform(r.pos + r.size),
-				mtx.basis_xform(r.pos + Vector2(0, r.size.y))
+				mtx.basis_xform(r.position),
+				mtx.basis_xform(r.position + Vector2(r.size.x, 0)),
+				mtx.basis_xform(r.position + r.size),
+				mtx.basis_xform(r.position + Vector2(0, r.size.y))
 			};
 			for (int i = 0; i < 4; i++) {
 				int next = (i + 1) % 4;
@@ -132,10 +132,10 @@ void TextureRegionEditor::_region_draw() {
 	scroll_rect.expand_to(mtx.basis_xform(edit_draw->get_size()));
 
 	Vector2 endpoints[4] = {
-		mtx.basis_xform(rect.pos),
-		mtx.basis_xform(rect.pos + Vector2(rect.size.x, 0)),
-		mtx.basis_xform(rect.pos + rect.size),
-		mtx.basis_xform(rect.pos + Vector2(0, rect.size.y))
+		mtx.basis_xform(rect.position),
+		mtx.basis_xform(rect.position + Vector2(rect.size.x, 0)),
+		mtx.basis_xform(rect.position + rect.size),
+		mtx.basis_xform(rect.position + Vector2(0, rect.size.y))
 	};
 	Color color(0.9, 0.5, 0.5);
 	for (int i = 0; i < 4; i++) {
@@ -162,14 +162,14 @@ void TextureRegionEditor::_region_draw() {
 
 	scroll_rect = scroll_rect.grow(200);
 	updating_scroll = true;
-	hscroll->set_min(scroll_rect.pos.x);
-	hscroll->set_max(scroll_rect.pos.x + scroll_rect.size.x);
+	hscroll->set_min(scroll_rect.position.x);
+	hscroll->set_max(scroll_rect.position.x + scroll_rect.size.x);
 	hscroll->set_page(edit_draw->get_size().x);
 	hscroll->set_value(draw_ofs.x);
 	hscroll->set_step(0.001);
 
-	vscroll->set_min(scroll_rect.pos.y);
-	vscroll->set_max(scroll_rect.pos.y + scroll_rect.size.y);
+	vscroll->set_min(scroll_rect.position.y);
+	vscroll->set_max(scroll_rect.position.y + scroll_rect.size.y);
 	vscroll->set_page(edit_draw->get_size().y);
 	vscroll->set_value(draw_ofs.y);
 	vscroll->set_step(0.001);
@@ -208,14 +208,14 @@ void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) {
 	mtx.scale_basis(Vector2(draw_zoom, draw_zoom));
 
 	Vector2 endpoints[8] = {
-		mtx.xform(rect.pos) + Vector2(-4, -4),
-		mtx.xform(rect.pos + Vector2(rect.size.x / 2, 0)) + Vector2(0, -4),
-		mtx.xform(rect.pos + Vector2(rect.size.x, 0)) + Vector2(4, -4),
-		mtx.xform(rect.pos + Vector2(rect.size.x, rect.size.y / 2)) + Vector2(4, 0),
-		mtx.xform(rect.pos + rect.size) + Vector2(4, 4),
-		mtx.xform(rect.pos + Vector2(rect.size.x / 2, rect.size.y)) + Vector2(0, 4),
-		mtx.xform(rect.pos + Vector2(0, rect.size.y)) + Vector2(-4, 4),
-		mtx.xform(rect.pos + Vector2(0, rect.size.y / 2)) + Vector2(-4, 0)
+		mtx.xform(rect.position) + Vector2(-4, -4),
+		mtx.xform(rect.position + Vector2(rect.size.x / 2, 0)) + Vector2(0, -4),
+		mtx.xform(rect.position + Vector2(rect.size.x, 0)) + Vector2(4, -4),
+		mtx.xform(rect.position + Vector2(rect.size.x, rect.size.y / 2)) + Vector2(4, 0),
+		mtx.xform(rect.position + rect.size) + Vector2(4, 4),
+		mtx.xform(rect.position + Vector2(rect.size.x / 2, rect.size.y)) + Vector2(0, 4),
+		mtx.xform(rect.position + Vector2(0, rect.size.y)) + Vector2(-4, 4),
+		mtx.xform(rect.position + Vector2(0, rect.size.y / 2)) + Vector2(-4, 0)
 	};
 
 	Ref<InputEventMouseButton> mb;
@@ -239,10 +239,10 @@ void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) {
 						margins[3] = obj_styleBox->get_margin_size(MARGIN_RIGHT);
 					}
 					Vector2 pos[4] = {
-						mtx.basis_xform(rect.pos + Vector2(0, margins[0])) - draw_ofs,
-						mtx.basis_xform(rect.pos + rect.size - Vector2(0, margins[1])) - draw_ofs,
-						mtx.basis_xform(rect.pos + Vector2(margins[2], 0)) - draw_ofs,
-						mtx.basis_xform(rect.pos + rect.size - Vector2(margins[3], 0)) - draw_ofs
+						mtx.basis_xform(rect.position + Vector2(0, margins[0])) - draw_ofs,
+						mtx.basis_xform(rect.position + rect.size - Vector2(0, margins[1])) - draw_ofs,
+						mtx.basis_xform(rect.position + Vector2(margins[2], 0)) - draw_ofs,
+						mtx.basis_xform(rect.position + rect.size - Vector2(margins[3], 0)) - draw_ofs
 					};
 					if (Math::abs(mb->get_position().y - pos[0].y) < 8) {
 						edited_margin = 0;
@@ -277,8 +277,8 @@ void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) {
 									r = obj_styleBox->get_region_rect();
 								else if (atlas_tex.is_valid())
 									r = atlas_tex->get_region();
-								rect.expand_to(r.pos);
-								rect.expand_to(r.pos + r.size);
+								rect.expand_to(r.position);
+								rect.expand_to(r.position + r.size);
 							}
 							undo_redo->create_action("Set Region Rect");
 							if (node_sprite) {
@@ -439,49 +439,49 @@ void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) {
 
 				switch (drag_index) {
 					case 0: {
-						Vector2 p = rect_prev.pos + rect_prev.size;
+						Vector2 p = rect_prev.position + rect_prev.size;
 						rect = Rect2(p, Size2());
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 1: {
-						Vector2 p = rect_prev.pos + Vector2(0, rect_prev.size.y);
+						Vector2 p = rect_prev.position + Vector2(0, rect_prev.size.y);
 						rect = Rect2(p, Size2(rect_prev.size.x, 0));
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 2: {
-						Vector2 p = rect_prev.pos + Vector2(0, rect_prev.size.y);
+						Vector2 p = rect_prev.position + Vector2(0, rect_prev.size.y);
 						rect = Rect2(p, Size2());
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 3: {
-						Vector2 p = rect_prev.pos;
+						Vector2 p = rect_prev.position;
 						rect = Rect2(p, Size2(0, rect_prev.size.y));
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 4: {
-						Vector2 p = rect_prev.pos;
+						Vector2 p = rect_prev.position;
 						rect = Rect2(p, Size2());
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 5: {
-						Vector2 p = rect_prev.pos;
+						Vector2 p = rect_prev.position;
 						rect = Rect2(p, Size2(rect_prev.size.x, 0));
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 6: {
-						Vector2 p = rect_prev.pos + Vector2(rect_prev.size.x, 0);
+						Vector2 p = rect_prev.position + Vector2(rect_prev.size.x, 0);
 						rect = Rect2(p, Size2());
 						rect.expand_to(new_pos);
 						apply_rect(rect);
 					} break;
 					case 7: {
-						Vector2 p = rect_prev.pos + Vector2(rect_prev.size.x, 0);
+						Vector2 p = rect_prev.position + Vector2(rect_prev.size.x, 0);
 						rect = Rect2(p, Size2(0, rect_prev.size.y));
 						rect.expand_to(new_pos);
 						apply_rect(rect);
@@ -693,7 +693,7 @@ void TextureRegionEditor::_edit_region() {
 						if (grown.has_point(Point2(x, y))) {
 							E->get().expand_to(Point2(x, y));
 							E->get().expand_to(Point2(x + 1, y + 1));
-							x = E->get().pos.x + E->get().size.x - 1;
+							x = E->get().position.x + E->get().size.x - 1;
 							bool merged = true;
 							while (merged) {
 								merged = false;
@@ -706,8 +706,8 @@ void TextureRegionEditor::_edit_region() {
 									if (F == E)
 										continue;
 									if (E->get().grow(1).intersects(F->get())) {
-										E->get().expand_to(F->get().pos);
-										E->get().expand_to(F->get().pos + F->get().size);
+										E->get().expand_to(F->get().position);
+										E->get().expand_to(F->get().position + F->get().size);
 										if (F->prev()) {
 											F = F->prev();
 											autoslice_cache.erase(F->next());

editor/plugins/tile_map_editor_plugin.cpp

@@ -98,8 +98,8 @@ void TileMapEditor::_menu_option(int p_option) {
 				return;
 
 			undo_redo->create_action("Erase Selection");
-			for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) {
-				for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) {
+			for (int i = rectangle.position.y; i <= rectangle.position.y + rectangle.size.y; i++) {
+				for (int j = rectangle.position.x; j <= rectangle.position.x + rectangle.size.x; j++) {
 
 					_set_cell(Point2i(j, i), TileMap::INVALID_CELL, false, false, false, true);
 				}
@@ -333,7 +333,7 @@ PoolVector<Vector2> TileMapEditor::_bucket_fill(const Point2i &p_start, bool era
 	}
 
 	Rect2i r = node->get_item_rect();
-	r.pos = r.pos / node->get_cell_size();
+	r.position = r.position / node->get_cell_size();
 	r.size = r.size / node->get_cell_size();
 
 	int area = r.get_area();
@@ -349,7 +349,7 @@ PoolVector<Vector2> TileMapEditor::_bucket_fill(const Point2i &p_start, bool era
 			invalidate_cache = true;
 		}
 		// Tile ID changed or position wasn't visited by the previous fill
-		int loc = (p_start.x - r.get_pos().x) + (p_start.y - r.get_pos().y) * r.get_size().x;
+		int loc = (p_start.x - r.position.x) + (p_start.y - r.position.y) * r.get_size().x;
 		if (prev_id != bucket_cache_tile || !bucket_cache_visited[loc]) {
 			invalidate_cache = true;
 		}
@@ -380,7 +380,7 @@ PoolVector<Vector2> TileMapEditor::_bucket_fill(const Point2i &p_start, bool era
 		if (node->get_cell(n.x, n.y) == prev_id) {
 
 			if (preview) {
-				int loc = (n.x - r.get_pos().x) + (n.y - r.get_pos().y) * r.get_size().x;
+				int loc = (n.x - r.position.x) + (n.y - r.position.y) * r.get_size().x;
 				if (bucket_cache_visited[loc])
 					continue;
 				bucket_cache_visited[loc] = true;
@@ -441,7 +441,7 @@ void TileMapEditor::_select(const Point2i &p_from, const Point2i &p_to) {
 		SWAP(begin.y, end.y);
 	}
 
-	rectangle.pos = begin;
+	rectangle.position = begin;
 	rectangle.size = end - begin;
 
 	canvas_item_editor->update();
@@ -460,7 +460,7 @@ void TileMapEditor::_draw_cell(int p_cell, const Point2i &p_point, bool p_flip_h
 	Size2 sc = p_xform.get_scale();
 
 	Rect2 rect = Rect2();
-	rect.pos = node->map_to_world(p_point) + node->get_cell_draw_offset();
+	rect.position = node->map_to_world(p_point) + node->get_cell_draw_offset();
 
 	if (r.has_no_area()) {
 		rect.size = t->get_size();
@@ -490,42 +490,42 @@ void TileMapEditor::_draw_cell(int p_cell, const Point2i &p_point, bool p_flip_h
 
 	if (node->get_tile_origin() == TileMap::TILE_ORIGIN_TOP_LEFT) {
 
-		rect.pos += tile_ofs;
+		rect.position += tile_ofs;
 	} else if (node->get_tile_origin() == TileMap::TILE_ORIGIN_BOTTOM_LEFT) {
 		Size2 cell_size = node->get_cell_size();
 
-		rect.pos += tile_ofs;
+		rect.position += tile_ofs;
 
 		if (p_transpose) {
 			if (p_flip_h)
-				rect.pos.x -= cell_size.x;
+				rect.position.x -= cell_size.x;
 			else
-				rect.pos.x += cell_size.x;
+				rect.position.x += cell_size.x;
 		} else {
 			if (p_flip_v)
-				rect.pos.y -= cell_size.y;
+				rect.position.y -= cell_size.y;
 			else
-				rect.pos.y += cell_size.y;
+				rect.position.y += cell_size.y;
 		}
 
 	} else if (node->get_tile_origin() == TileMap::TILE_ORIGIN_CENTER) {
-		rect.pos += node->get_cell_size() / 2;
+		rect.position += node->get_cell_size() / 2;
 		Vector2 s = r.size;
 
 		Vector2 center = (s / 2) - tile_ofs;
 
 		if (p_flip_h)
-			rect.pos.x -= s.x - center.x;
+			rect.position.x -= s.x - center.x;
 		else
-			rect.pos.x -= center.x;
+			rect.position.x -= center.x;
 
 		if (p_flip_v)
-			rect.pos.y -= s.y - center.y;
+			rect.position.y -= s.y - center.y;
 		else
-			rect.pos.y -= center.y;
+			rect.position.y -= center.y;
 	}
 
-	rect.pos = p_xform.xform(rect.pos);
+	rect.position = p_xform.xform(rect.position);
 	rect.size *= sc;
 
 	if (r.has_no_area())
@@ -560,9 +560,9 @@ void TileMapEditor::_update_copydata() {
 	if (!selection_active)
 		return;
 
-	for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) {
+	for (int i = rectangle.position.y; i <= rectangle.position.y + rectangle.size.y; i++) {
 
-		for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) {
+		for (int j = rectangle.position.x; j <= rectangle.position.x + rectangle.size.x; j++) {
 
 			TileData tcd;
 
@@ -737,8 +737,8 @@ bool TileMapEditor::forward_gui_input(const Ref<InputEvent> &p_event) {
 						if (id != TileMap::INVALID_CELL) {
 
 							undo_redo->create_action("Rectangle Paint");
-							for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) {
-								for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) {
+							for (int i = rectangle.position.y; i <= rectangle.position.y + rectangle.size.y; i++) {
+								for (int j = rectangle.position.x; j <= rectangle.position.x + rectangle.size.x; j++) {
 
 									_set_cell(Point2i(j, i), id, flip_h, flip_v, transpose, true);
 								}
@@ -749,7 +749,7 @@ bool TileMapEditor::forward_gui_input(const Ref<InputEvent> &p_event) {
 						}
 					} else if (tool == TOOL_DUPLICATING) {
 
-						Point2 ofs = over_tile - rectangle.pos;
+						Point2 ofs = over_tile - rectangle.position;
 
 						undo_redo->create_action(TTR("Duplicate"));
 						for (List<TileData>::Element *E = copydata.front(); E; E = E->next()) {
@@ -985,8 +985,8 @@ bool TileMapEditor::forward_gui_input(const Ref<InputEvent> &p_event) {
 
 				paint_undo.clear();
 
-				for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) {
-					for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) {
+				for (int i = rectangle.position.y; i <= rectangle.position.y + rectangle.size.y; i++) {
+					for (int j = rectangle.position.x; j <= rectangle.position.x + rectangle.size.x; j++) {
 
 						Point2i tile = Point2i(j, i);
 						paint_undo[tile] = _get_op_from_cell(tile);
@@ -1103,7 +1103,7 @@ void TileMapEditor::_canvas_draw() {
 	Size2 screen_size = canvas_item_editor->get_size();
 	{
 		Rect2 aabb;
-		aabb.pos = node->world_to_map(xform_inv.xform(Vector2()));
+		aabb.position = node->world_to_map(xform_inv.xform(Vector2()));
 		aabb.expand_to(node->world_to_map(xform_inv.xform(Vector2(0, screen_size.height))));
 		aabb.expand_to(node->world_to_map(xform_inv.xform(Vector2(screen_size.width, 0))));
 		aabb.expand_to(node->world_to_map(xform_inv.xform(screen_size)));
@@ -1113,10 +1113,10 @@ void TileMapEditor::_canvas_draw() {
 
 			int max_lines = 2000; //avoid crash if size too smal
 
-			for (int i = (si.pos.x) - 1; i <= (si.pos.x + si.size.x); i++) {
+			for (int i = (si.position.x) - 1; i <= (si.position.x + si.size.x); i++) {
 
-				Vector2 from = xform.xform(node->map_to_world(Vector2(i, si.pos.y)));
-				Vector2 to = xform.xform(node->map_to_world(Vector2(i, si.pos.y + si.size.y + 1)));
+				Vector2 from = xform.xform(node->map_to_world(Vector2(i, si.position.y)));
+				Vector2 to = xform.xform(node->map_to_world(Vector2(i, si.position.y + si.size.y + 1)));
 
 				Color col = i == 0 ? Color(1, 0.8, 0.2, 0.5) : Color(1, 0.3, 0.1, 0.2);
 				canvas_item_editor->draw_line(from, to, col, 1);
@@ -1127,9 +1127,9 @@ void TileMapEditor::_canvas_draw() {
 
 			int max_lines = 10000; //avoid crash if size too smal
 
-			for (int i = (si.pos.x) - 1; i <= (si.pos.x + si.size.x); i++) {
+			for (int i = (si.position.x) - 1; i <= (si.position.x + si.size.x); i++) {
 
-				for (int j = (si.pos.y) - 1; j <= (si.pos.y + si.size.y); j++) {
+				for (int j = (si.position.y) - 1; j <= (si.position.y + si.size.y); j++) {
 
 					Vector2 ofs;
 					if (ABS(j) & 1) {
@@ -1151,10 +1151,10 @@ void TileMapEditor::_canvas_draw() {
 
 		if (node->get_half_offset() != TileMap::HALF_OFFSET_Y) {
 
-			for (int i = (si.pos.y) - 1; i <= (si.pos.y + si.size.y); i++) {
+			for (int i = (si.position.y) - 1; i <= (si.position.y + si.size.y); i++) {
 
-				Vector2 from = xform.xform(node->map_to_world(Vector2(si.pos.x, i)));
-				Vector2 to = xform.xform(node->map_to_world(Vector2(si.pos.x + si.size.x + 1, i)));
+				Vector2 from = xform.xform(node->map_to_world(Vector2(si.position.x, i)));
+				Vector2 to = xform.xform(node->map_to_world(Vector2(si.position.x + si.size.x + 1, i)));
 
 				Color col = i == 0 ? Color(1, 0.8, 0.2, 0.5) : Color(1, 0.3, 0.1, 0.2);
 				canvas_item_editor->draw_line(from, to, col, 1);
@@ -1164,9 +1164,9 @@ void TileMapEditor::_canvas_draw() {
 			}
 		} else {
 
-			for (int i = (si.pos.y) - 1; i <= (si.pos.y + si.size.y); i++) {
+			for (int i = (si.position.y) - 1; i <= (si.position.y + si.size.y); i++) {
 
-				for (int j = (si.pos.x) - 1; j <= (si.pos.x + si.size.x); j++) {
+				for (int j = (si.position.x) - 1; j <= (si.position.x + si.size.x); j++) {
 
 					Vector2 ofs;
 					if (ABS(j) & 1) {
@@ -1188,10 +1188,10 @@ void TileMapEditor::_canvas_draw() {
 	if (selection_active) {
 
 		Vector<Vector2> points;
-		points.push_back(xform.xform(node->map_to_world((rectangle.pos))));
-		points.push_back(xform.xform(node->map_to_world((rectangle.pos + Point2(rectangle.size.x + 1, 0)))));
-		points.push_back(xform.xform(node->map_to_world((rectangle.pos + Point2(rectangle.size.x + 1, rectangle.size.y + 1)))));
-		points.push_back(xform.xform(node->map_to_world((rectangle.pos + Point2(0, rectangle.size.y + 1)))));
+		points.push_back(xform.xform(node->map_to_world((rectangle.position))));
+		points.push_back(xform.xform(node->map_to_world((rectangle.position + Point2(rectangle.size.x + 1, 0)))));
+		points.push_back(xform.xform(node->map_to_world((rectangle.position + Point2(rectangle.size.x + 1, rectangle.size.y + 1)))));
+		points.push_back(xform.xform(node->map_to_world((rectangle.position + Point2(0, rectangle.size.y + 1)))));
 
 		canvas_item_editor->draw_colored_polygon(points, Color(0.2, 0.8, 1, 0.4));
 	}
@@ -1248,8 +1248,8 @@ void TileMapEditor::_canvas_draw() {
 			if (id == TileMap::INVALID_CELL)
 				return;
 
-			for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) {
-				for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) {
+			for (int i = rectangle.position.y; i <= rectangle.position.y + rectangle.size.y; i++) {
+				for (int j = rectangle.position.x; j <= rectangle.position.x + rectangle.size.x; j++) {
 
 					_draw_cell(id, Point2i(j, i), flip_h, flip_v, transpose, xform);
 				}
@@ -1264,7 +1264,7 @@ void TileMapEditor::_canvas_draw() {
 			if (ts.is_null())
 				return;
 
-			Point2 ofs = over_tile - rectangle.pos;
+			Point2 ofs = over_tile - rectangle.position;
 
 			for (List<TileData>::Element *E = copydata.front(); E; E = E->next()) {
 
@@ -1277,13 +1277,13 @@ void TileMapEditor::_canvas_draw() {
 			}
 
 			Rect2i duplicate = rectangle;
-			duplicate.pos = over_tile;
+			duplicate.position = over_tile;
 
 			Vector<Vector2> points;
-			points.push_back(xform.xform(node->map_to_world(duplicate.pos)));
-			points.push_back(xform.xform(node->map_to_world((duplicate.pos + Point2(duplicate.size.x + 1, 0)))));
-			points.push_back(xform.xform(node->map_to_world((duplicate.pos + Point2(duplicate.size.x + 1, duplicate.size.y + 1)))));
-			points.push_back(xform.xform(node->map_to_world((duplicate.pos + Point2(0, duplicate.size.y + 1)))));
+			points.push_back(xform.xform(node->map_to_world(duplicate.position)));
+			points.push_back(xform.xform(node->map_to_world((duplicate.position + Point2(duplicate.size.x + 1, 0)))));
+			points.push_back(xform.xform(node->map_to_world((duplicate.position + Point2(duplicate.size.x + 1, duplicate.size.y + 1)))));
+			points.push_back(xform.xform(node->map_to_world((duplicate.position + Point2(0, duplicate.size.y + 1)))));
 
 			canvas_item_editor->draw_colored_polygon(points, Color(0.2, 1.0, 0.8, 0.2));
 

editor/project_settings.cpp

@@ -430,8 +430,8 @@ void ProjectSettings::_action_button_pressed(Object *p_obj, int p_column, int p_
 	if (p_id == 1) {
 		Point2 ofs = input_editor->get_global_position();
 		Rect2 ir = input_editor->get_item_rect(ti);
-		ir.pos.y -= input_editor->get_scroll().y;
-		ofs += ir.pos + ir.size;
+		ir.position.y -= input_editor->get_scroll().y;
+		ofs += ir.position + ir.size;
 		ofs.x -= 100;
 		popup_add->set_position(ofs);
 		popup_add->popup();

editor/property_editor.cpp

@@ -678,8 +678,8 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant::
 			field_names.push_back("h");
 			config_value_editors(4, 4, 10, field_names);
 			Rect2 r = v;
-			value_editor[0]->set_text(String::num(r.pos.x));
-			value_editor[1]->set_text(String::num(r.pos.y));
+			value_editor[0]->set_text(String::num(r.position.x));
+			value_editor[1]->set_text(String::num(r.position.y));
 			value_editor[2]->set_text(String::num(r.size.x));
 			value_editor[3]->set_text(String::num(r.size.y));
 		} break;
@@ -1539,13 +1539,13 @@ void CustomPropertyEditor::_modified(String p_string) {
 
 			Rect2 r2;
 			if (evaluator) {
-				r2.pos.x = evaluator->eval(value_editor[0]->get_text());
-				r2.pos.y = evaluator->eval(value_editor[1]->get_text());
+				r2.position.x = evaluator->eval(value_editor[0]->get_text());
+				r2.position.y = evaluator->eval(value_editor[1]->get_text());
 				r2.size.x = evaluator->eval(value_editor[2]->get_text());
 				r2.size.y = evaluator->eval(value_editor[3]->get_text());
 			} else {
-				r2.pos.x = value_editor[0]->get_text().to_double();
-				r2.pos.y = value_editor[1]->get_text().to_double();
+				r2.position.x = value_editor[0]->get_text().to_double();
+				r2.position.y = value_editor[1]->get_text().to_double();
 				r2.size.x = value_editor[2]->get_text().to_double();
 				r2.size.y = value_editor[3]->get_text().to_double();
 			}
@@ -3674,7 +3674,7 @@ void PropertyEditor::_draw_transparency(Object *t, const Rect2 &p_rect) {
 
 	// make a little space between consecutive color fields
 	Rect2 area = p_rect;
-	area.pos.y += 1;
+	area.position.y += 1;
 	area.size.height -= 2;
 	area.size.width -= arrow->get_size().width + 5;
 	tree->draw_texture_rect(get_icon("Transparent", "EditorIcons"), area, true);
@@ -3942,7 +3942,7 @@ void PropertyEditor::_custom_editor_request(bool p_arrow) {
 	int hint = d.has("hint") ? d["hint"].operator int() : -1;
 	String hint_text = d.has("hint_text") ? d["hint_text"] : "";
 	Rect2 where = tree->get_custom_popup_rect();
-	custom_editor->set_position(where.pos);
+	custom_editor->set_position(where.position);
 
 	if (custom_editor->edit(obj, name, type, v, hint, hint_text)) {
 		custom_editor->popup();
@@ -4049,9 +4049,9 @@ void PropertyEditor::_edit_button(Object *p_item, int p_column, int p_button) {
 			Variant v = obj->get(n);
 			custom_editor->edit(obj, n, (Variant::Type)t, v, h, ht);
 			Rect2 where = tree->get_item_rect(ti, 1);
-			where.pos -= tree->get_scroll();
-			where.pos += tree->get_global_position();
-			custom_editor->set_position(where.pos);
+			where.position -= tree->get_scroll();
+			where.position += tree->get_global_position();
+			custom_editor->set_position(where.position);
 			custom_editor->popup();
 
 		} else if (t == Variant::STRING) {
@@ -4062,9 +4062,9 @@ void PropertyEditor::_edit_button(Object *p_item, int p_column, int p_button) {
 			if (h == PROPERTY_HINT_FILE || h == PROPERTY_HINT_DIR || h == PROPERTY_HINT_GLOBAL_DIR || h == PROPERTY_HINT_GLOBAL_FILE) {
 
 				Rect2 where = tree->get_item_rect(ti, 1);
-				where.pos -= tree->get_scroll();
-				where.pos += tree->get_global_position();
-				custom_editor->set_position(where.pos);
+				where.position -= tree->get_scroll();
+				where.position += tree->get_global_position();
+				custom_editor->set_position(where.position);
 				custom_editor->popup();
 			} else {
 				custom_editor->popup_centered_ratio();
@@ -4140,7 +4140,7 @@ void PropertyEditor::_draw_flags(Object *t, const Rect2 &p_rect) {
 		if (i == 1)
 			ofs.y += bsize + 1;
 
-		ofs += p_rect.pos;
+		ofs += p_rect.position;
 		for (int j = 0; j < 10; j++) {
 
 			Point2 o = ofs + Point2(j * (bsize + 1), 0);

editor/scene_tree_editor.cpp

@@ -161,17 +161,17 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i
 	if (p_id == BUTTON_SUBSCENE) {
 		//open scene request
 		Rect2 item_rect = tree->get_item_rect(item, 0);
-		item_rect.pos.y -= tree->get_scroll().y;
-		item_rect.pos += tree->get_global_position();
+		item_rect.position.y -= tree->get_scroll().y;
+		item_rect.position += tree->get_global_position();
 
 		if (n == get_scene_node()) {
-			inheritance_menu->set_position(item_rect.pos + Vector2(0, item_rect.size.y));
+			inheritance_menu->set_position(item_rect.position + Vector2(0, item_rect.size.y));
 			inheritance_menu->set_size(Vector2(item_rect.size.x, 0));
 			inheritance_menu->popup();
 			instance_node = n->get_instance_ID();
 
 		} else {
-			instance_menu->set_position(item_rect.pos + Vector2(0, item_rect.size.y));
+			instance_menu->set_position(item_rect.position + Vector2(0, item_rect.size.y));
 			instance_menu->set_size(Vector2(item_rect.size.x, 0));
 			if (EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(n))
 				instance_menu->set_item_checked(0, true);

editor/script_editor_debugger.cpp

@@ -790,19 +790,19 @@ void ScriptEditorDebugger::_performance_draw() {
 
 		Point2i p(i % cols, i / cols);
 		Rect2i r(p * s, s);
-		r.pos += Point2(margin, margin);
+		r.position += Point2(margin, margin);
 		r.size -= Point2(margin, margin) * 2.0;
 		perf_draw->draw_style_box(graph_sb, r);
-		r.pos += graph_sb->get_offset();
+		r.position += graph_sb->get_offset();
 		r.size -= graph_sb->get_minimum_size();
 		int pi = which[i];
 		Color c = Color(0.7, 0.9, 0.5);
 		c.set_hsv(Math::fmod(c.get_h() + pi * 0.7654, 1), c.get_s(), c.get_v());
 
 		c.a = 0.8;
-		perf_draw->draw_string(graph_font, r.pos + Point2(0, graph_font->get_ascent()), perf_items[pi]->get_text(0), c, r.size.x);
+		perf_draw->draw_string(graph_font, r.position + Point2(0, graph_font->get_ascent()), perf_items[pi]->get_text(0), c, r.size.x);
 		c.a = 0.6;
-		perf_draw->draw_string(graph_font, r.pos + Point2(graph_font->get_char_size('X').width, graph_font->get_ascent() + graph_font->get_height()), perf_items[pi]->get_text(1), c, r.size.y);
+		perf_draw->draw_string(graph_font, r.position + Point2(graph_font->get_char_size('X').width, graph_font->get_ascent() + graph_font->get_height()), perf_items[pi]->get_text(1), c, r.size.y);
 
 		float spacing = point_sep / float(cols);
 		float from = r.size.width;
@@ -819,7 +819,7 @@ void ScriptEditorDebugger::_performance_draw() {
 
 			c.a = 0.7;
 			if (E != perf_history.front())
-				perf_draw->draw_line(r.pos + Point2(from, h), r.pos + Point2(from + spacing, prev), c, 2.0);
+				perf_draw->draw_line(r.position + Point2(from, h), r.position + Point2(from + spacing, prev), c, 2.0);
 			prev = h;
 			E = E->next();
 			from -= spacing;

main/input_default.cpp

@@ -493,10 +493,10 @@ Point2i InputDefault::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_moti
 			Math::fmod(p_motion->get_relative().x + rel_sgn.x * warp_margin.x, p_rect.size.x) - rel_sgn.x * warp_margin.x,
 			Math::fmod(p_motion->get_relative().y + rel_sgn.y * warp_margin.y, p_rect.size.y) - rel_sgn.y * warp_margin.y);
 
-	const Point2i pos_local = p_motion->get_global_position() - p_rect.pos;
+	const Point2i pos_local = p_motion->get_global_position() - p_rect.position;
 	const Point2i pos_warped(Math::fposmod(pos_local.x, p_rect.size.x), Math::fposmod(pos_local.y, p_rect.size.y));
 	if (pos_warped != pos_local) {
-		OS::get_singleton()->warp_mouse_pos(pos_warped + p_rect.pos);
+		OS::get_singleton()->warp_mouse_pos(pos_warped + p_rect.position);
 	}
 
 	return rel_warped;

modules/gdnative/godot/godot_rect2.cpp

@@ -38,11 +38,11 @@ extern "C" {
 
 void _rect2_api_anchor() {}
 
-void GDAPI godot_rect2_new_with_pos_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size) {
-	const Vector2 *pos = (const Vector2 *)p_pos;
+void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size) {
+	const Vector2 *position = (const Vector2 *)p_pos;
 	const Vector2 *size = (const Vector2 *)p_size;
 	Rect2 *dest = (Rect2 *)r_dest;
-	*dest = Rect2(*pos, *size);
+	*dest = Rect2(*position, *size);
 }
 
 void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height) {
@@ -124,11 +124,11 @@ godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const god
 	return *self == *b;
 }
 
-godot_vector2 GDAPI godot_rect2_get_pos(const godot_rect2 *p_self) {
+godot_vector2 GDAPI godot_rect2_get_position(const godot_rect2 *p_self) {
 	godot_vector2 dest;
 	Vector2 *d = (Vector2 *)&dest;
 	const Rect2 *self = (const Rect2 *)p_self;
-	*d = self->get_pos();
+	*d = self->get_position();
 	return dest;
 }
 
@@ -140,10 +140,10 @@ godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self) {
 	return dest;
 }
 
-void GDAPI godot_rect2_set_pos(godot_rect2 *p_self, const godot_vector2 *p_pos) {
+void GDAPI godot_rect2_set_position(godot_rect2 *p_self, const godot_vector2 *p_pos) {
 	Rect2 *self = (Rect2 *)p_self;
-	const Vector2 *pos = (const Vector2 *)p_pos;
-	self->set_pos(*pos);
+	const Vector2 *position = (const Vector2 *)p_pos;
+	self->set_position(*position);
 }
 
 void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size) {

modules/gdnative/godot/godot_rect2.h

@@ -46,7 +46,7 @@ typedef struct godot_rect2 {
 #include "../godot.h"
 #include "godot_vector2.h"
 
-void GDAPI godot_rect2_new_with_pos_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
+void GDAPI godot_rect2_new_with_position_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size);
 void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height);
 
 godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self);
@@ -71,11 +71,11 @@ godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vect
 
 godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b);
 
-godot_vector2 GDAPI godot_rect2_get_pos(const godot_rect2 *p_self);
+godot_vector2 GDAPI godot_rect2_get_position(const godot_rect2 *p_self);
 
 godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self);
 
-void GDAPI godot_rect2_set_pos(godot_rect2 *p_self, const godot_vector2 *p_pos);
+void GDAPI godot_rect2_set_position(godot_rect2 *p_self, const godot_vector2 *p_pos);
 
 void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size);
 

modules/visual_script/visual_script_editor.cpp

@@ -1011,7 +1011,7 @@ void VisualScriptEditor::_member_button(Object *p_item, int p_column, int p_butt
 				}
 
 				Rect2 pos = members->get_item_rect(ti);
-				new_function_menu->set_position(members->get_global_position() + pos.pos + Vector2(0, pos.size.y));
+				new_function_menu->set_position(members->get_global_position() + pos.position + Vector2(0, pos.size.y));
 				new_function_menu->popup();
 				return;
 			} else if (p_button == 0) {

platform/osx/os_osx.mm

@@ -974,7 +974,7 @@ void OS_OSX::initialize(const VideoMode &p_desired, int p_video_driver, int p_au
 
 		NSRect nsrect = [[screenArray objectAtIndex:i] visibleFrame];
 		Rect2 rect = Rect2(nsrect.origin.x, nsrect.origin.y, nsrect.size.width, nsrect.size.height);
-		rect.pos *= displayScale;
+		rect.position *= displayScale;
 		rect.size *= displayScale;
 		screens.push_back(rect);
 
@@ -1275,7 +1275,7 @@ void OS_OSX::set_current_screen(int p_screen) {
 Point2 OS_OSX::get_screen_position(int p_screen) const {
 
 	ERR_FAIL_INDEX_V(p_screen, screens.size(), Point2());
-	return screens[p_screen].pos;
+	return screens[p_screen].position;
 };
 
 int OS_OSX::get_screen_dpi(int p_screen) const {
@@ -1384,7 +1384,7 @@ void OS_OSX::set_window_maximized(bool p_enabled) {
 		[window_object setFrame:[[[NSScreen screens] objectAtIndex:current_screen] visibleFrame] display:YES];
 	} else {
 		set_window_size(restore_rect.size);
-		set_window_position(restore_rect.pos);
+		set_window_position(restore_rect.position);
 	};
 	maximized = p_enabled;
 };

platform/windows/os_windows.cpp

@@ -889,8 +889,8 @@ BOOL CALLBACK OS_Windows::MonitorEnumProc(HMONITOR hMonitor, HDC hdcMonitor, LPR
 	MonitorInfo minfo;
 	minfo.hMonitor = hMonitor;
 	minfo.hdcMonitor = hdcMonitor;
-	minfo.rect.pos.x = lprcMonitor->left;
-	minfo.rect.pos.y = lprcMonitor->top;
+	minfo.rect.position.x = lprcMonitor->left;
+	minfo.rect.position.y = lprcMonitor->top;
 	minfo.rect.size.x = lprcMonitor->right - lprcMonitor->left;
 	minfo.rect.size.y = lprcMonitor->bottom - lprcMonitor->top;
 
@@ -1370,7 +1370,7 @@ void OS_Windows::set_current_screen(int p_screen) {
 Point2 OS_Windows::get_screen_position(int p_screen) const {
 
 	ERR_FAIL_INDEX_V(p_screen, monitor_info.size(), Point2());
-	return Vector2(monitor_info[p_screen].rect.pos);
+	return Vector2(monitor_info[p_screen].rect.position);
 }
 Size2 OS_Windows::get_screen_size(int p_screen) const {
 

scene/2d/camera_2d.cpp

@@ -120,20 +120,20 @@ Transform2D Camera2D::get_camera_transform() {
 		Rect2 screen_rect(-screen_offset + camera_pos, screen_size * zoom);
 
 		if (offset != Vector2())
-			screen_rect.pos += offset;
+			screen_rect.position += offset;
 
 		if (limit_smoothing_enabled) {
-			if (screen_rect.pos.x < limit[MARGIN_LEFT])
-				camera_pos.x -= screen_rect.pos.x - limit[MARGIN_LEFT];
+			if (screen_rect.position.x < limit[MARGIN_LEFT])
+				camera_pos.x -= screen_rect.position.x - limit[MARGIN_LEFT];
 
-			if (screen_rect.pos.x + screen_rect.size.x > limit[MARGIN_RIGHT])
-				camera_pos.x -= screen_rect.pos.x + screen_rect.size.x - limit[MARGIN_RIGHT];
+			if (screen_rect.position.x + screen_rect.size.x > limit[MARGIN_RIGHT])
+				camera_pos.x -= screen_rect.position.x + screen_rect.size.x - limit[MARGIN_RIGHT];
 
-			if (screen_rect.pos.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
-				camera_pos.y -= screen_rect.pos.y + screen_rect.size.y - limit[MARGIN_BOTTOM];
+			if (screen_rect.position.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
+				camera_pos.y -= screen_rect.position.y + screen_rect.size.y - limit[MARGIN_BOTTOM];
 
-			if (screen_rect.pos.y < limit[MARGIN_TOP])
-				camera_pos.y -= screen_rect.pos.y - limit[MARGIN_TOP];
+			if (screen_rect.position.y < limit[MARGIN_TOP])
+				camera_pos.y -= screen_rect.position.y - limit[MARGIN_TOP];
 		}
 
 		if (smoothing_enabled && !get_tree()->is_editor_hint()) {
@@ -160,42 +160,42 @@ Transform2D Camera2D::get_camera_transform() {
 	}
 
 	Rect2 screen_rect(-screen_offset + ret_camera_pos, screen_size * zoom);
-	if (screen_rect.pos.x < limit[MARGIN_LEFT])
-		screen_rect.pos.x = limit[MARGIN_LEFT];
+	if (screen_rect.position.x < limit[MARGIN_LEFT])
+		screen_rect.position.x = limit[MARGIN_LEFT];
 
-	if (screen_rect.pos.x + screen_rect.size.x > limit[MARGIN_RIGHT])
-		screen_rect.pos.x = limit[MARGIN_RIGHT] - screen_rect.size.x;
+	if (screen_rect.position.x + screen_rect.size.x > limit[MARGIN_RIGHT])
+		screen_rect.position.x = limit[MARGIN_RIGHT] - screen_rect.size.x;
 
-	if (screen_rect.pos.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
-		screen_rect.pos.y = limit[MARGIN_BOTTOM] - screen_rect.size.y;
+	if (screen_rect.position.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
+		screen_rect.position.y = limit[MARGIN_BOTTOM] - screen_rect.size.y;
 
-	if (screen_rect.pos.y < limit[MARGIN_TOP])
-		screen_rect.pos.y = limit[MARGIN_TOP];
+	if (screen_rect.position.y < limit[MARGIN_TOP])
+		screen_rect.position.y = limit[MARGIN_TOP];
 
 	if (offset != Vector2()) {
 
-		screen_rect.pos += offset;
-		if (screen_rect.pos.x + screen_rect.size.x > limit[MARGIN_RIGHT])
-			screen_rect.pos.x = limit[MARGIN_RIGHT] - screen_rect.size.x;
+		screen_rect.position += offset;
+		if (screen_rect.position.x + screen_rect.size.x > limit[MARGIN_RIGHT])
+			screen_rect.position.x = limit[MARGIN_RIGHT] - screen_rect.size.x;
 
-		if (screen_rect.pos.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
-			screen_rect.pos.y = limit[MARGIN_BOTTOM] - screen_rect.size.y;
+		if (screen_rect.position.y + screen_rect.size.y > limit[MARGIN_BOTTOM])
+			screen_rect.position.y = limit[MARGIN_BOTTOM] - screen_rect.size.y;
 
-		if (screen_rect.pos.x < limit[MARGIN_LEFT])
-			screen_rect.pos.x = limit[MARGIN_LEFT];
+		if (screen_rect.position.x < limit[MARGIN_LEFT])
+			screen_rect.position.x = limit[MARGIN_LEFT];
 
-		if (screen_rect.pos.y < limit[MARGIN_TOP])
-			screen_rect.pos.y = limit[MARGIN_TOP];
+		if (screen_rect.position.y < limit[MARGIN_TOP])
+			screen_rect.position.y = limit[MARGIN_TOP];
 	}
 
-	camera_screen_center = screen_rect.pos + screen_rect.size * 0.5;
+	camera_screen_center = screen_rect.position + screen_rect.size * 0.5;
 
 	Transform2D xform;
 	if (rotating) {
 		xform.set_rotation(angle);
 	}
 	xform.scale_basis(zoom);
-	xform.set_origin(screen_rect.pos /*.floor()*/);
+	xform.set_origin(screen_rect.position /*.floor()*/);
 
 	/*
 	if (0) {

scene/2d/collision_polygon_2d.cpp

@@ -233,7 +233,7 @@ void CollisionPolygon2D::set_polygon(const Vector<Point2> &p_polygon) {
 
 			aabb = Rect2(-10, -10, 20, 20);
 		} else {
-			aabb.pos -= aabb.size * 0.3;
+			aabb.position -= aabb.size * 0.3;
 			aabb.size += aabb.size * 0.6;
 		}
 		_update_parent();

scene/2d/line_builder.cpp

@@ -83,8 +83,8 @@ static inline Vector2 rotate90(const Vector2 &v) {
 
 static inline Vector2 interpolate(const Rect2 &r, const Vector2 &v) {
 	return Vector2(
-			Math::lerp(r.get_pos().x, r.get_pos().x + r.get_size().x, v.x),
-			Math::lerp(r.get_pos().y, r.get_pos().y + r.get_size().y, v.y));
+			Math::lerp(r.position.x, r.position.x + r.get_size().x, v.x),
+			Math::lerp(r.position.y, r.position.y + r.get_size().y, v.y));
 }
 
 //----------------------------------------------------------------------------

scene/2d/node_2d.cpp

@@ -76,9 +76,9 @@ void Node2D::edit_set_rect(const Rect2 &p_edit_rect) {
 
 	Vector2 zero_offset;
 	if (r.size.x != 0)
-		zero_offset.x = -r.pos.x / r.size.x;
+		zero_offset.x = -r.position.x / r.size.x;
 	if (r.size.y != 0)
-		zero_offset.y = -r.pos.y / r.size.y;
+		zero_offset.y = -r.position.y / r.size.y;
 
 	Size2 new_scale(1, 1);
 
@@ -87,7 +87,7 @@ void Node2D::edit_set_rect(const Rect2 &p_edit_rect) {
 	if (r.size.y != 0)
 		new_scale.y = p_edit_rect.size.y / r.size.y;
 
-	Point2 new_pos = p_edit_rect.pos + p_edit_rect.size * zero_offset; //p_edit_rect.pos - r.pos;
+	Point2 new_pos = p_edit_rect.position + p_edit_rect.size * zero_offset; //p_edit_rect.pos - r.pos;
 
 	Transform2D postxf;
 	postxf.set_rotation_and_scale(angle, _scale);

scene/2d/particles_2d.cpp

@@ -568,8 +568,8 @@ void Particles2D::_notification(int p_what) {
 
 					if (total_frames > 1) {
 						int frame = Math::fast_ftoi(Math::floor(p.frame * total_frames)) % total_frames;
-						src_rect.pos.x = size.x * (frame % h_frames);
-						src_rect.pos.y = size.y * (frame / h_frames);
+						src_rect.position.x = size.x * (frame % h_frames);
+						src_rect.position.y = size.y * (frame / h_frames);
 					}
 					Rect2 dst_rect(Point2(), size);
 					if (flip_h)

scene/2d/polygon_2d.cpp

@@ -38,7 +38,7 @@ Rect2 Polygon2D::get_item_rect() const {
 		for (int i = 0; i < l; i++) {
 			Vector2 pos = r[i] + offset;
 			if (i == 0)
-				item_rect.pos = pos;
+				item_rect.position = pos;
 			else
 				item_rect.expand_to(pos);
 		}
@@ -95,7 +95,7 @@ void Polygon2D::_notification(int p_what) {
 
 				for (int i = 0; i < len; i++) {
 					if (i == 0)
-						bounds.pos = points[i];
+						bounds.position = points[i];
 					else
 						bounds.expand_to(points[i]);
 					if (points[i].y > highest_y) {
@@ -110,10 +110,10 @@ void Polygon2D::_notification(int p_what) {
 
 				Vector2 ep[7] = {
 					Vector2(points[highest_idx].x, points[highest_idx].y + invert_border),
-					Vector2(bounds.pos + bounds.size),
-					Vector2(bounds.pos + Vector2(bounds.size.x, 0)),
-					Vector2(bounds.pos),
-					Vector2(bounds.pos + Vector2(0, bounds.size.y)),
+					Vector2(bounds.position + bounds.size),
+					Vector2(bounds.position + Vector2(bounds.size.x, 0)),
+					Vector2(bounds.position),
+					Vector2(bounds.position + Vector2(0, bounds.size.y)),
 					Vector2(points[highest_idx].x - CMP_EPSILON, points[highest_idx].y + invert_border),
 					Vector2(points[highest_idx].x - CMP_EPSILON, points[highest_idx].y),
 				};

scene/2d/sprite.cpp

@@ -75,8 +75,8 @@ void Sprite::_notification(int p_what) {
 				s = s / Size2(hframes, vframes);
 
 				src_rect.size = s;
-				src_rect.pos.x += float(frame % hframes) * s.x;
-				src_rect.pos.y += float(frame / hframes) * s.y;
+				src_rect.position.x += float(frame % hframes) * s.x;
+				src_rect.position.y += float(frame / hframes) * s.y;
 			}
 
 			Point2 ofs = offset;

scene/2d/tile_map.cpp

@@ -370,14 +370,14 @@ void TileMap::_update_dirty_quadrants() {
 				s = tex->get_size();
 			else {
 				s = r.size;
-				r.pos.x += fp_adjust;
-				r.pos.y += fp_adjust;
+				r.position.x += fp_adjust;
+				r.position.y += fp_adjust;
 				r.size.x -= fp_adjust * 2.0;
 				r.size.y -= fp_adjust * 2.0;
 			}
 
 			Rect2 rect;
-			rect.pos = offset.floor();
+			rect.position = offset.floor();
 			rect.size = s;
 
 			if (rect.size.y > rect.size.x) {
@@ -406,39 +406,39 @@ void TileMap::_update_dirty_quadrants() {
 			Vector2 center_ofs;
 
 			if (tile_origin == TILE_ORIGIN_TOP_LEFT) {
-				rect.pos += tile_ofs;
+				rect.position += tile_ofs;
 
 			} else if (tile_origin == TILE_ORIGIN_BOTTOM_LEFT) {
 
-				rect.pos += tile_ofs;
+				rect.position += tile_ofs;
 
 				if (c.transpose) {
 					if (c.flip_h)
-						rect.pos.x -= cell_size.x;
+						rect.position.x -= cell_size.x;
 					else
-						rect.pos.x += cell_size.x;
+						rect.position.x += cell_size.x;
 				} else {
 					if (c.flip_v)
-						rect.pos.y -= cell_size.y;
+						rect.position.y -= cell_size.y;
 					else
-						rect.pos.y += cell_size.y;
+						rect.position.y += cell_size.y;
 				}
 
 			} else if (tile_origin == TILE_ORIGIN_CENTER) {
-				rect.pos += tcenter;
+				rect.position += tcenter;
 
 				Vector2 center = (s / 2) - tile_ofs;
 				center_ofs = tcenter - (s / 2);
 
 				if (c.flip_h)
-					rect.pos.x -= s.x - center.x;
+					rect.position.x -= s.x - center.x;
 				else
-					rect.pos.x -= center.x;
+					rect.position.x -= center.x;
 
 				if (c.flip_v)
-					rect.pos.y -= s.y - center.y;
+					rect.position.y -= s.y - center.y;
 				else
-					rect.pos.y -= center.y;
+					rect.position.y -= center.y;
 			}
 
 			Color modulate = tile_set->tile_get_modulate(c.id);
@@ -549,7 +549,7 @@ void TileMap::_recompute_rect_cache() {
 	for (Map<PosKey, Quadrant>::Element *E = quadrant_map.front(); E; E = E->next()) {
 
 		Rect2 r;
-		r.pos = _map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size());
+		r.position = _map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size());
 		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size() + _get_quadrant_size(), E->key().y * _get_quadrant_size()));
 		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size() + _get_quadrant_size(), E->key().y * _get_quadrant_size() + _get_quadrant_size()));
 		r.expand_to(_map_to_world(E->key().x * _get_quadrant_size(), E->key().y * _get_quadrant_size() + _get_quadrant_size()));

scene/3d/sprite_3d.cpp

@@ -335,8 +335,8 @@ void Sprite3D::_draw() {
 		s = s / Size2i(hframes, vframes);
 
 		src_rect.size = s;
-		src_rect.pos.x += (frame % hframes) * s.x;
-		src_rect.pos.y += (frame / hframes) * s.y;
+		src_rect.position.x += (frame % hframes) * s.x;
+		src_rect.position.y += (frame / hframes) * s.y;
 	}
 
 	Point2i ofs = get_offset();
@@ -360,17 +360,17 @@ void Sprite3D::_draw() {
 
 	Vector2 vertices[4] = {
 
-		(final_rect.pos + Vector2(0, final_rect.size.y)) * pixel_size,
-		(final_rect.pos + final_rect.size) * pixel_size,
-		(final_rect.pos + Vector2(final_rect.size.x, 0)) * pixel_size,
-		final_rect.pos * pixel_size,
+		(final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size,
+		(final_rect.position + final_rect.size) * pixel_size,
+		(final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size,
+		final_rect.position * pixel_size,
 
 	};
 	Vector2 uvs[4] = {
-		final_src_rect.pos / tsize,
-		(final_src_rect.pos + Vector2(final_src_rect.size.x, 0)) / tsize,
-		(final_src_rect.pos + final_src_rect.size) / tsize,
-		(final_src_rect.pos + Vector2(0, final_src_rect.size.y)) / tsize,
+		final_src_rect.position / tsize,
+		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / tsize,
+		(final_src_rect.position + final_src_rect.size) / tsize,
+		(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / tsize,
 	};
 
 	if (is_flipped_h()) {
@@ -861,17 +861,17 @@ void AnimatedSprite3D::_draw() {
 
 	Vector2 vertices[4] = {
 
-		(final_rect.pos + Vector2(0, final_rect.size.y)) * pixel_size,
-		(final_rect.pos + final_rect.size) * pixel_size,
-		(final_rect.pos + Vector2(final_rect.size.x, 0)) * pixel_size,
-		final_rect.pos * pixel_size,
+		(final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size,
+		(final_rect.position + final_rect.size) * pixel_size,
+		(final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size,
+		final_rect.position * pixel_size,
 
 	};
 	Vector2 uvs[4] = {
-		final_src_rect.pos / tsize,
-		(final_src_rect.pos + Vector2(final_src_rect.size.x, 0)) / tsize,
-		(final_src_rect.pos + final_src_rect.size) / tsize,
-		(final_src_rect.pos + Vector2(0, final_src_rect.size.y)) / tsize,
+		final_src_rect.position / tsize,
+		(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / tsize,
+		(final_src_rect.position + final_src_rect.size) / tsize,
+		(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / tsize,
 	};
 
 	if (is_flipped_h()) {

scene/gui/button_array.cpp

@@ -236,8 +236,8 @@ void ButtonArray::_notification(int p_what) {
 				}
 
 				Rect2 r;
-				r.pos[orientation] = ofs;
-				r.pos[!orientation] = 0;
+				r.position[orientation] = ofs;
+				r.position[!orientation] = 0;
 				r.size[orientation] = s;
 				r.size[!orientation] = op_size;
 
@@ -272,10 +272,10 @@ void ButtonArray::_notification(int p_what) {
 				Point2 text_ofs = ((r.size - ssize - sbsize) / 2.0 + Point2(0, f->get_ascent())).floor() + sbofs;
 				if (buttons[i].icon.is_valid()) {
 
-					draw_texture(buttons[i].icon, r.pos + Point2(text_ofs.x, Math::floor((r.size.height - buttons[i].icon->get_height()) / 2.0)));
+					draw_texture(buttons[i].icon, r.position + Point2(text_ofs.x, Math::floor((r.size.height - buttons[i].icon->get_height()) / 2.0)));
 					text_ofs.x += buttons[i].icon->get_width() + icon_sep;
 				}
-				draw_string(f, text_ofs + r.pos, buttons[i].xl_text, c);
+				draw_string(f, text_ofs + r.position, buttons[i].xl_text, c);
 				buttons[i]._pos_cache = ofs;
 				buttons[i]._size_cache = s;
 

scene/gui/container.cpp

@@ -96,18 +96,18 @@ void Container::fit_child_in_rect(Control *p_child, const Rect2 &p_rect) {
 
 	if (!(p_child->get_h_size_flags() & SIZE_FILL)) {
 		r.size.x = minsize.x;
-		r.pos.x += Math::floor((p_rect.size.x - minsize.x) / 2);
+		r.position.x += Math::floor((p_rect.size.x - minsize.x) / 2);
 	}
 
 	if (!(p_child->get_v_size_flags() & SIZE_FILL)) {
 		r.size.y = minsize.y;
-		r.pos.y += Math::floor((p_rect.size.y - minsize.y) / 2);
+		r.position.y += Math::floor((p_rect.size.y - minsize.y) / 2);
 	}
 
 	for (int i = 0; i < 4; i++)
 		p_child->set_anchor(Margin(i), ANCHOR_BEGIN);
 
-	p_child->set_position(r.pos);
+	p_child->set_position(r.position);
 	p_child->set_size(r.size);
 	p_child->set_rotation(0);
 	p_child->set_scale(Vector2(1, 1));

scene/gui/control.cpp

@@ -58,7 +58,7 @@ void Control::edit_set_state(const Variant &p_state) {
 	Dictionary s = p_state;
 
 	Rect2 state = s["rect"];
-	set_position(state.pos);
+	set_position(state.position);
 	set_size(state.size);
 	set_rotation(s["rot"]);
 	set_scale(s["scale"]);
@@ -94,15 +94,15 @@ void Control::edit_set_rect(const Rect2 &p_edit_rect) {
 
 	Transform2D postxf;
 	postxf.set_rotation_and_scale(data.rotation, data.scale);
-	Vector2 new_pos = postxf.xform(p_edit_rect.pos);
+	Vector2 new_pos = postxf.xform(p_edit_rect.position);
 
 	Vector2 pos = get_position() + new_pos;
 
 	Rect2 new_rect = get_rect();
-	new_rect.pos = pos.snapped(Vector2(1, 1));
+	new_rect.position = pos.snapped(Vector2(1, 1));
 	new_rect.size = p_edit_rect.size.snapped(Vector2(1, 1));
 
-	set_position(new_rect.pos);
+	set_position(new_rect.position);
 	set_size(new_rect.size);
 }
 
@@ -1477,7 +1477,7 @@ Rect2 Control::get_global_rect() const {
 Rect2 Control::get_window_rect() const {
 	ERR_FAIL_COND_V(!is_inside_tree(), Rect2());
 	Rect2 gr = get_global_rect();
-	gr.pos += get_viewport()->get_visible_rect().pos;
+	gr.position += get_viewport()->get_visible_rect().position;
 	return gr;
 }
 
@@ -1949,10 +1949,10 @@ Control *Control::_get_focus_neighbour(Margin p_margin, int p_count) {
 	Transform2D xform = get_global_transform();
 	Rect2 rect = get_item_rect();
 
-	points[0] = xform.xform(rect.pos);
-	points[1] = xform.xform(rect.pos + Point2(rect.size.x, 0));
-	points[2] = xform.xform(rect.pos + rect.size);
-	points[3] = xform.xform(rect.pos + Point2(0, rect.size.y));
+	points[0] = xform.xform(rect.position);
+	points[1] = xform.xform(rect.position + Point2(rect.size.x, 0));
+	points[2] = xform.xform(rect.position + rect.size);
+	points[3] = xform.xform(rect.position + Point2(0, rect.size.y));
 
 	const Vector2 dir[4] = {
 		Vector2(-1, 0),
@@ -2008,10 +2008,10 @@ void Control::_window_find_focus_neighbour(const Vector2 &p_dir, Node *p_at, con
 		Transform2D xform = c->get_global_transform();
 		Rect2 rect = c->get_item_rect();
 
-		points[0] = xform.xform(rect.pos);
-		points[1] = xform.xform(rect.pos + Point2(rect.size.x, 0));
-		points[2] = xform.xform(rect.pos + rect.size);
-		points[3] = xform.xform(rect.pos + Point2(0, rect.size.y));
+		points[0] = xform.xform(rect.position);
+		points[1] = xform.xform(rect.position + Point2(rect.size.x, 0));
+		points[2] = xform.xform(rect.position + rect.size);
+		points[3] = xform.xform(rect.position + Point2(0, rect.size.y));
 
 		float min = 1e7;
 

scene/gui/dialogs.cpp

@@ -90,15 +90,15 @@ bool WindowDialog::has_point(const Point2 &p_point) const {
 
 	// Enlarge upwards for title bar.
 	int title_height = get_constant("title_height", "WindowDialog");
-	r.pos.y -= title_height;
+	r.position.y -= title_height;
 	r.size.y += title_height;
 
 	// Inflate by the resizable border thickness.
 	if (resizable) {
 		int scaleborder_size = get_constant("scaleborder_size", "WindowDialog");
-		r.pos.x -= scaleborder_size;
+		r.position.x -= scaleborder_size;
 		r.size.width += scaleborder_size * 2;
-		r.pos.y -= scaleborder_size;
+		r.position.y -= scaleborder_size;
 		r.size.height += scaleborder_size * 2;
 	}
 
@@ -162,28 +162,28 @@ void WindowDialog::_gui_input(const Ref<InputEvent> &p_event) {
 			Size2 min_size = get_minimum_size();
 
 			if (drag_type == DRAG_MOVE) {
-				rect.pos = global_pos - drag_offset;
+				rect.position = global_pos - drag_offset;
 			} else {
 				if (drag_type & DRAG_RESIZE_TOP) {
-					int bottom = rect.pos.y + rect.size.height;
+					int bottom = rect.position.y + rect.size.height;
 					int max_y = bottom - min_size.height;
-					rect.pos.y = MIN(global_pos.y - drag_offset.y, max_y);
-					rect.size.height = bottom - rect.pos.y;
+					rect.position.y = MIN(global_pos.y - drag_offset.y, max_y);
+					rect.size.height = bottom - rect.position.y;
 				} else if (drag_type & DRAG_RESIZE_BOTTOM) {
-					rect.size.height = global_pos.y - rect.pos.y + drag_offset_far.y;
+					rect.size.height = global_pos.y - rect.position.y + drag_offset_far.y;
 				}
 				if (drag_type & DRAG_RESIZE_LEFT) {
-					int right = rect.pos.x + rect.size.width;
+					int right = rect.position.x + rect.size.width;
 					int max_x = right - min_size.width;
-					rect.pos.x = MIN(global_pos.x - drag_offset.x, max_x);
-					rect.size.width = right - rect.pos.x;
+					rect.position.x = MIN(global_pos.x - drag_offset.x, max_x);
+					rect.size.width = right - rect.position.x;
 				} else if (drag_type & DRAG_RESIZE_RIGHT) {
-					rect.size.width = global_pos.x - rect.pos.x + drag_offset_far.x;
+					rect.size.width = global_pos.x - rect.position.x + drag_offset_far.x;
 				}
 			}
 
 			set_size(rect.size);
-			set_position(rect.pos);
+			set_position(rect.position);
 		}
 	}
 }

scene/gui/graph_edit.cpp

@@ -168,24 +168,24 @@ void GraphEdit::_update_scroll() {
 			continue;
 
 		Rect2 r;
-		r.pos = gn->get_offset() * zoom;
+		r.position = gn->get_offset() * zoom;
 		r.size = gn->get_size() * zoom;
 		screen = screen.merge(r);
 	}
 
-	screen.pos -= get_size();
+	screen.position -= get_size();
 	screen.size += get_size() * 2.0;
 
-	h_scroll->set_min(screen.pos.x);
-	h_scroll->set_max(screen.pos.x + screen.size.x);
+	h_scroll->set_min(screen.position.x);
+	h_scroll->set_max(screen.position.x + screen.size.x);
 	h_scroll->set_page(get_size().x);
 	if (h_scroll->get_max() - h_scroll->get_min() <= h_scroll->get_page())
 		h_scroll->hide();
 	else
 		h_scroll->show();
 
-	v_scroll->set_min(screen.pos.y);
-	v_scroll->set_max(screen.pos.y + screen.size.y);
+	v_scroll->set_min(screen.position.y);
+	v_scroll->set_max(screen.position.y + screen.size.y);
 	v_scroll->set_page(get_size().y);
 
 	if (v_scroll->get_max() - v_scroll->get_min() <= v_scroll->get_page())

scene/gui/graph_node.cpp

@@ -239,7 +239,7 @@ void GraphNode::_notification(int p_what) {
 		if (show_close) {
 			Vector2 cpos = Point2(w + sb->get_margin(MARGIN_LEFT), -close->get_height() + close_offset);
 			draw_texture(close, cpos);
-			close_rect.pos = cpos;
+			close_rect.position = cpos;
 			close_rect.size = close->get_size();
 		} else {
 			close_rect = Rect2();

scene/gui/item_list.cpp

@@ -857,7 +857,7 @@ void ItemList::_notification(int p_what) {
 					items[i].rect_cache = items[i].min_rect_cache;
 					if (same_column_width)
 						items[i].rect_cache.size.x = max_column_width;
-					items[i].rect_cache.pos = ofs;
+					items[i].rect_cache.position = ofs;
 					max_h = MAX(max_h, items[i].rect_cache.size.y);
 					ofs.x += items[i].rect_cache.size.x + hseparation;
 					//print_line("item "+itos(i)+" ofs "+rtos(items[i].rect_cache.size.x));
@@ -906,10 +906,10 @@ void ItemList::_notification(int p_what) {
 			int from = scroll_bar->get_value();
 			int to = from + scroll_bar->get_page();
 
-			if (r.pos.y < from) {
-				scroll_bar->set_value(r.pos.y);
-			} else if (r.pos.y + r.size.y > to) {
-				scroll_bar->set_value(r.pos.y + r.size.y - (to - from));
+			if (r.position.y < from) {
+				scroll_bar->set_value(r.position.y);
+			} else if (r.position.y + r.size.y > to) {
+				scroll_bar->set_value(r.position.y + r.size.y - (to - from));
 			}
 		}
 
@@ -928,25 +928,25 @@ void ItemList::_notification(int p_what) {
 				continue;
 
 			if (current_columns == 1) {
-				rcache.size.width = width - rcache.pos.x;
+				rcache.size.width = width - rcache.position.x;
 			}
 
 			Rect2 r = rcache;
-			r.pos += base_ofs;
+			r.position += base_ofs;
 
 			// Use stylebox to dimension potential bg color, even if not selected
-			r.pos.x -= sbsel->get_margin(MARGIN_LEFT);
+			r.position.x -= sbsel->get_margin(MARGIN_LEFT);
 			r.size.x += sbsel->get_margin(MARGIN_LEFT) + sbsel->get_margin(MARGIN_RIGHT);
-			r.pos.y -= sbsel->get_margin(MARGIN_TOP);
+			r.position.y -= sbsel->get_margin(MARGIN_TOP);
 			r.size.y += sbsel->get_margin(MARGIN_TOP) + sbsel->get_margin(MARGIN_BOTTOM);
 
 			if (items[i].selected) {
 				draw_style_box(sbsel, r);
 			}
 			if (items[i].custom_bg.a > 0.001) {
-				r.pos.x += 2;
+				r.position.x += 2;
 				r.size.x -= 4;
-				r.pos.y += 2;
+				r.position.y += 2;
 				r.size.y -= 4;
 				draw_rect(r, items[i].custom_bg);
 			}
@@ -965,7 +965,7 @@ void ItemList::_notification(int p_what) {
 
 				Vector2 icon_ofs;
 
-				Point2 pos = items[i].rect_cache.pos + icon_ofs + base_ofs;
+				Point2 pos = items[i].rect_cache.position + icon_ofs + base_ofs;
 
 				if (icon_mode == ICON_MODE_TOP) {
 
@@ -985,7 +985,7 @@ void ItemList::_notification(int p_what) {
 
 				if (fixed_icon_size.x > 0 && fixed_icon_size.y > 0) {
 					Rect2 adj = _adjust_to_max_size(items[i].get_icon_size() * icon_scale, icon_size);
-					draw_rect.pos += adj.pos;
+					draw_rect.position += adj.position;
 					draw_rect.size = adj.size;
 				}
 
@@ -1001,7 +1001,7 @@ void ItemList::_notification(int p_what) {
 
 			if (items[i].tag_icon.is_valid()) {
 
-				draw_texture(items[i].tag_icon, items[i].rect_cache.pos + base_ofs);
+				draw_texture(items[i].tag_icon, items[i].rect_cache.position + base_ofs);
 			}
 
 			if (items[i].text != "") {
@@ -1046,7 +1046,7 @@ void ItemList::_notification(int p_what) {
 					text_ofs.y += font->get_ascent();
 					text_ofs = text_ofs.floor();
 					text_ofs += base_ofs;
-					text_ofs += items[i].rect_cache.pos;
+					text_ofs += items[i].rect_cache.position;
 
 					for (int j = 0; j < ss; j++) {
 
@@ -1074,7 +1074,7 @@ void ItemList::_notification(int p_what) {
 					text_ofs.y += font->get_ascent();
 					text_ofs = text_ofs.floor();
 					text_ofs += base_ofs;
-					text_ofs += items[i].rect_cache.pos;
+					text_ofs += items[i].rect_cache.position;
 
 					draw_string(font, text_ofs, items[i].text, modulate, max_len + 1);
 				}
@@ -1083,7 +1083,7 @@ void ItemList::_notification(int p_what) {
 			if (select_mode == SELECT_MULTI && i == current) {
 
 				Rect2 r = rcache;
-				r.pos += base_ofs;
+				r.position += base_ofs;
 				draw_style_box(cursor, r);
 			}
 		}
@@ -1141,7 +1141,7 @@ bool ItemList::is_pos_at_end_of_items(const Point2 &p_pos) const {
 	pos.y += scroll_bar->get_value();
 
 	Rect2 endrect = items[items.size() - 1].rect_cache;
-	return (pos.y > endrect.pos.y + endrect.size.y);
+	return (pos.y > endrect.position.y + endrect.size.y);
 }
 
 String ItemList::get_tooltip(const Point2 &p_pos) const {

scene/gui/popup.cpp

@@ -170,8 +170,8 @@ void Popup::popup_centered(const Size2 &p_size) {
 	Rect2 rect;
 	rect.size = p_size == Size2() ? get_size() : p_size;
 
-	rect.pos = ((window_size - rect.size) / 2.0).floor();
-	set_position(rect.pos);
+	rect.position = ((window_size - rect.size) / 2.0).floor();
+	set_position(rect.position);
 	set_size(rect.size);
 
 	show_modal(exclusive);
@@ -193,8 +193,8 @@ void Popup::popup_centered_ratio(float p_screen_ratio) {
 	Rect2 rect;
 	Point2 window_size = get_viewport_rect().size;
 	rect.size = (window_size * p_screen_ratio).floor();
-	rect.pos = ((window_size - rect.size) / 2.0).floor();
-	set_position(rect.pos);
+	rect.position = ((window_size - rect.size) / 2.0).floor();
+	set_position(rect.position);
 	set_size(rect.size);
 
 	show_modal(exclusive);
@@ -216,7 +216,7 @@ void Popup::popup(const Rect2 &bounds) {
 
 	// Fit the popup into the optionally provided bounds.
 	if (!bounds.has_no_area()) {
-		set_position(bounds.pos);
+		set_position(bounds.position);
 		set_size(bounds.size);
 	}
 	_fix_size();

scene/gui/popup_menu.cpp

@@ -190,12 +190,12 @@ void PopupMenu::_activate_submenu(int over) {
 	PopupMenu *pum = pm->cast_to<PopupMenu>();
 	if (pum) {
 
-		pr.pos -= pum->get_global_position();
+		pr.position -= pum->get_global_position();
 		pum->clear_autohide_areas();
-		pum->add_autohide_area(Rect2(pr.pos.x, pr.pos.y, pr.size.x, items[over]._ofs_cache));
+		pum->add_autohide_area(Rect2(pr.position.x, pr.position.y, pr.size.x, items[over]._ofs_cache));
 		if (over < items.size() - 1) {
 			int from = items[over + 1]._ofs_cache;
-			pum->add_autohide_area(Rect2(pr.pos.x, pr.pos.y + from, pr.size.x, pr.size.y - from));
+			pum->add_autohide_area(Rect2(pr.position.x, pr.position.y + from, pr.size.x, pr.size.y - from));
 		}
 	}
 }

scene/gui/scroll_bar.cpp

@@ -267,14 +267,14 @@ void ScrollBar::_notification(int p_what) {
 
 			grabber_rect.size.width = get_grabber_size();
 			grabber_rect.size.height = get_size().height;
-			grabber_rect.pos.y = 0;
-			grabber_rect.pos.x = get_grabber_offset() + decr->get_width() + bg->get_margin(MARGIN_LEFT);
+			grabber_rect.position.y = 0;
+			grabber_rect.position.x = get_grabber_offset() + decr->get_width() + bg->get_margin(MARGIN_LEFT);
 		} else {
 
 			grabber_rect.size.width = get_size().width;
 			grabber_rect.size.height = get_grabber_size();
-			grabber_rect.pos.y = get_grabber_offset() + decr->get_height() + bg->get_margin(MARGIN_TOP);
-			grabber_rect.pos.x = 0;
+			grabber_rect.position.y = get_grabber_offset() + decr->get_height() + bg->get_margin(MARGIN_TOP);
+			grabber_rect.position.x = 0;
 		}
 
 		grabber->draw(ci, grabber_rect);

scene/gui/scroll_container.cpp

@@ -233,14 +233,14 @@ void ScrollContainer::_notification(int p_what) {
 
 			Rect2 r = Rect2(-scroll, minsize);
 			if (!scroll_h || (!h_scroll->is_visible_in_tree() && c->get_h_size_flags() & SIZE_EXPAND)) {
-				r.pos.x = 0;
+				r.position.x = 0;
 				if (c->get_h_size_flags() & SIZE_EXPAND)
 					r.size.width = MAX(size.width, minsize.width);
 				else
 					r.size.width = minsize.width;
 			}
 			if (!scroll_v || (!v_scroll->is_visible_in_tree() && c->get_v_size_flags() & SIZE_EXPAND)) {
-				r.pos.y = 0;
+				r.position.y = 0;
 				r.size.height = size.height;
 				if (c->get_v_size_flags() & SIZE_EXPAND)
 					r.size.height = MAX(size.height, minsize.height);

scene/gui/tab_container.cpp

@@ -233,7 +233,7 @@ void TabContainer::_notification(int p_what) {
 				Control *control = tabs[i + first_tab_cache]->cast_to<Control>();
 				String text = control->has_meta("_tab_name") ? String(XL_MESSAGE(String(control->get_meta("_tab_name")))) : String(control->get_name());
 
-				int x_content = tab_rect.pos.x + tab_style->get_margin(MARGIN_LEFT);
+				int x_content = tab_rect.position.x + tab_style->get_margin(MARGIN_LEFT);
 				int top_margin = tab_style->get_margin(MARGIN_TOP);
 				int y_center = top_margin + (tab_rect.size.y - tab_style->get_minimum_size().y) / 2;
 

scene/gui/tabs.cpp

@@ -340,8 +340,8 @@ void Tabs::_notification(int p_what) {
 
 					Rect2 rb_rect;
 					rb_rect.size = style->get_minimum_size() + rb->get_size();
-					rb_rect.pos.x = w;
-					rb_rect.pos.y = sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - (rb_rect.size.y)) / 2;
+					rb_rect.position.x = w;
+					rb_rect.position.y = sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - (rb_rect.size.y)) / 2;
 
 					if (rb_hover == i) {
 						if (rb_pressing)
@@ -350,7 +350,7 @@ void Tabs::_notification(int p_what) {
 							style->draw(ci, rb_rect);
 					}
 
-					rb->draw(ci, Point2i(w + style->get_margin(MARGIN_LEFT), rb_rect.pos.y + style->get_margin(MARGIN_TOP)));
+					rb->draw(ci, Point2i(w + style->get_margin(MARGIN_LEFT), rb_rect.position.y + style->get_margin(MARGIN_TOP)));
 					w += rb->get_width();
 					tabs[i].rb_rect = rb_rect;
 				}
@@ -364,8 +364,8 @@ void Tabs::_notification(int p_what) {
 
 					Rect2 cb_rect;
 					cb_rect.size = style->get_minimum_size() + cb->get_size();
-					cb_rect.pos.x = w;
-					cb_rect.pos.y = sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - (cb_rect.size.y)) / 2;
+					cb_rect.position.x = w;
+					cb_rect.position.y = sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - (cb_rect.size.y)) / 2;
 
 					if (!tabs[i].disabled && cb_hover == i) {
 						if (cb_pressing)
@@ -374,7 +374,7 @@ void Tabs::_notification(int p_what) {
 							style->draw(ci, cb_rect);
 					}
 
-					cb->draw(ci, Point2i(w + style->get_margin(MARGIN_LEFT), cb_rect.pos.y + style->get_margin(MARGIN_TOP)));
+					cb->draw(ci, Point2i(w + style->get_margin(MARGIN_LEFT), cb_rect.position.y + style->get_margin(MARGIN_TOP)));
 					w += cb->get_width();
 					tabs[i].cb_rect = cb_rect;
 				}

scene/gui/text_edit.cpp

@@ -1069,16 +1069,16 @@ void TextEdit::_notification(int p_what) {
 				int th = h + csb->get_minimum_size().y;
 
 				if (cursor_pos.y + get_row_height() + th > get_size().height) {
-					completion_rect.pos.y = cursor_pos.y - th;
+					completion_rect.position.y = cursor_pos.y - th;
 				} else {
-					completion_rect.pos.y = cursor_pos.y + get_row_height() + csb->get_offset().y;
+					completion_rect.position.y = cursor_pos.y + get_row_height() + csb->get_offset().y;
 					completion_below = true;
 				}
 
 				if (cursor_pos.x - nofs + w + scrollw > get_size().width) {
-					completion_rect.pos.x = get_size().width - w - scrollw;
+					completion_rect.position.x = get_size().width - w - scrollw;
 				} else {
-					completion_rect.pos.x = cursor_pos.x - nofs;
+					completion_rect.position.x = cursor_pos.x - nofs;
 				}
 
 				completion_rect.size.width = w + 2;
@@ -1086,14 +1086,14 @@ void TextEdit::_notification(int p_what) {
 				if (completion_options.size() <= maxlines)
 					scrollw = 0;
 
-				draw_style_box(csb, Rect2(completion_rect.pos - csb->get_offset(), completion_rect.size + csb->get_minimum_size() + Size2(scrollw, 0)));
+				draw_style_box(csb, Rect2(completion_rect.position - csb->get_offset(), completion_rect.size + csb->get_minimum_size() + Size2(scrollw, 0)));
 
 				if (cache.completion_background_color.a > 0.01) {
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(completion_rect.pos, completion_rect.size + Size2(scrollw, 0)), cache.completion_background_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(completion_rect.position, completion_rect.size + Size2(scrollw, 0)), cache.completion_background_color);
 				}
 				int line_from = CLAMP(completion_index - lines / 2, 0, completion_options.size() - lines);
-				VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(completion_rect.pos.x, completion_rect.pos.y + (completion_index - line_from) * get_row_height()), Size2(completion_rect.size.width, get_row_height())), cache.completion_selected_color);
-				draw_rect(Rect2(completion_rect.pos, Size2(nofs, completion_rect.size.height)), cache.completion_existing_color);
+				VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(completion_rect.position.x, completion_rect.position.y + (completion_index - line_from) * get_row_height()), Size2(completion_rect.size.width, get_row_height())), cache.completion_selected_color);
+				draw_rect(Rect2(completion_rect.position, Size2(nofs, completion_rect.size.height)), cache.completion_existing_color);
 
 				for (int i = 0; i < lines; i++) {
 
@@ -1105,14 +1105,14 @@ void TextEdit::_notification(int p_what) {
 							text_color = color_regions[j].color;
 						}
 					}
-					draw_string(cache.font, Point2(completion_rect.pos.x, completion_rect.pos.y + i * get_row_height() + cache.font->get_ascent()), completion_options[l], text_color, completion_rect.size.width);
+					draw_string(cache.font, Point2(completion_rect.position.x, completion_rect.position.y + i * get_row_height() + cache.font->get_ascent()), completion_options[l], text_color, completion_rect.size.width);
 				}
 
 				if (scrollw) {
 					//draw a small scroll rectangle to show a position in the options
 					float r = maxlines / (float)completion_options.size();
 					float o = line_from / (float)completion_options.size();
-					draw_rect(Rect2(completion_rect.pos.x + completion_rect.size.width, completion_rect.pos.y + o * completion_rect.size.y, scrollw, completion_rect.size.y * r), scrollc);
+					draw_rect(Rect2(completion_rect.position.x + completion_rect.size.width, completion_rect.position.y + o * completion_rect.size.y, scrollw, completion_rect.size.y * r), scrollc);
 				}
 
 				completion_line_ofs = line_from;
@@ -1468,7 +1468,7 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
 
 			if (mb->get_button_index() == BUTTON_LEFT) {
 
-				completion_index = CLAMP(completion_line_ofs + (mb->get_position().y - completion_rect.pos.y) / get_row_height(), 0, completion_options.size() - 1);
+				completion_index = CLAMP(completion_line_ofs + (mb->get_position().y - completion_rect.position.y) / get_row_height(), 0, completion_options.size() - 1);
 
 				completion_current = completion_options[completion_index];
 				update();

scene/gui/tree.cpp

@@ -904,8 +904,8 @@ void Tree::draw_item_rect(const TreeItem::Cell &p_cell, const Rect2i &p_rect, co
 			bmsize.width = p_cell.icon_max_w;
 		}
 
-		p_cell.draw_icon(ci, rect.pos + Size2i(0, Math::floor((real_t)(rect.size.y - bmsize.y) / 2)), bmsize);
-		rect.pos.x += bmsize.x + cache.hseparation;
+		p_cell.draw_icon(ci, rect.position + Size2i(0, Math::floor((real_t)(rect.size.y - bmsize.y) / 2)), bmsize);
+		rect.position.x += bmsize.x + cache.hseparation;
 		rect.size.x -= bmsize.x + cache.hseparation;
 	}
 
@@ -920,8 +920,8 @@ void Tree::draw_item_rect(const TreeItem::Cell &p_cell, const Rect2i &p_rect, co
 	if (p_cell.suffix != String())
 		text += " " + p_cell.suffix;
 
-	rect.pos.y += Math::floor((rect.size.y - font->get_height()) / 2.0) + font->get_ascent();
-	font->draw(ci, rect.pos, text, p_color, rect.size.x);
+	rect.position.y += Math::floor((rect.size.y - font->get_height()) / 2.0) + font->get_ascent();
+	font->draw(ci, rect.position, text, p_color, rect.size.x);
 }
 
 #if 0
@@ -1034,16 +1034,16 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 			Rect2i item_rect = Rect2i(Point2i(ofs, p_pos.y) - cache.offset + p_draw_ofs, Size2i(w, label_h));
 			Rect2i cell_rect = item_rect;
 			if (i != 0) {
-				cell_rect.pos.x -= cache.hseparation;
+				cell_rect.position.x -= cache.hseparation;
 				cell_rect.size.x += cache.hseparation;
 			}
 
-			VisualServer::get_singleton()->canvas_item_add_line(ci, Point2i(cell_rect.pos.x, cell_rect.pos.y + cell_rect.size.height), cell_rect.pos + cell_rect.size, cache.guide_color, 1);
+			VisualServer::get_singleton()->canvas_item_add_line(ci, Point2i(cell_rect.position.x, cell_rect.position.y + cell_rect.size.height), cell_rect.position + cell_rect.size, cache.guide_color, 1);
 
 			if (i == 0) {
 
 				if (p_item->cells[0].selected && select_mode == SELECT_ROW) {
-					Rect2i row_rect = Rect2i(Point2i(cache.bg->get_margin(MARGIN_LEFT), item_rect.pos.y), Size2i(get_size().width - cache.bg->get_minimum_size().width, item_rect.size.y));
+					Rect2i row_rect = Rect2i(Point2i(cache.bg->get_margin(MARGIN_LEFT), item_rect.position.y), Size2i(get_size().width - cache.bg->get_minimum_size().width, item_rect.size.y));
 					//Rect2 r = Rect2i(row_rect.pos,row_rect.size);
 					//r.grow(cache.selected->get_margin(MARGIN_LEFT));
 					if (has_focus())
@@ -1055,34 +1055,34 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 
 			if (p_item->cells[i].selected && select_mode != SELECT_ROW) {
 
-				Rect2i r(item_rect.pos, item_rect.size);
+				Rect2i r(item_rect.position, item_rect.size);
 				if (p_item->cells[i].text.size() > 0) {
 					float icon_width = p_item->cells[i].get_icon_size().width;
-					r.pos.x += icon_width;
+					r.position.x += icon_width;
 					r.size.x -= icon_width;
 				}
 				//r.grow(cache.selected->get_margin(MARGIN_LEFT));
 				if (has_focus()) {
 					cache.selected_focus->draw(ci, r);
-					p_item->set_meta("__focus_rect", Rect2(r.pos, r.size));
+					p_item->set_meta("__focus_rect", Rect2(r.position, r.size));
 				} else {
 					cache.selected->draw(ci, r);
 				}
 				if (text_editor->is_visible_in_tree()) {
-					text_editor->set_position(get_global_position() + r.pos);
+					text_editor->set_position(get_global_position() + r.position);
 				}
 			}
 
 			if (p_item->cells[i].custom_bg_color) {
 
 				Rect2 r = cell_rect;
-				r.pos.x -= cache.hseparation;
+				r.position.x -= cache.hseparation;
 				r.size.x += cache.hseparation;
 				if (p_item->cells[i].custom_bg_outline) {
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x, r.pos.y, r.size.x, 1), p_item->cells[i].bg_color);
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x, r.pos.y + r.size.y - 1, r.size.x, 1), p_item->cells[i].bg_color);
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x, r.pos.y, 1, r.size.y), p_item->cells[i].bg_color);
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x + r.size.x - 1, r.pos.y, 1, r.size.y), p_item->cells[i].bg_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x, r.position.y, r.size.x, 1), p_item->cells[i].bg_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x, r.position.y + r.size.y - 1, r.size.x, 1), p_item->cells[i].bg_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x, r.position.y, 1, r.size.y), p_item->cells[i].bg_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x + r.size.x - 1, r.position.y, 1, r.size.y), p_item->cells[i].bg_color);
 				} else {
 					VisualServer::get_singleton()->canvas_item_add_rect(ci, r, p_item->cells[i].bg_color);
 				}
@@ -1093,22 +1093,22 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 				Rect2 r = cell_rect;
 
 				if (drop_mode_section == -1 || drop_mode_section == 0) {
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x, r.pos.y, r.size.x, 1), cache.drop_position_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x, r.position.y, r.size.x, 1), cache.drop_position_color);
 				}
 
 				if (drop_mode_section == 0) {
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x, r.pos.y, 1, r.size.y), cache.drop_position_color);
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x + r.size.x - 1, r.pos.y, 1, r.size.y), cache.drop_position_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x, r.position.y, 1, r.size.y), cache.drop_position_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x + r.size.x - 1, r.position.y, 1, r.size.y), cache.drop_position_color);
 				}
 
 				if (drop_mode_section == 1 || drop_mode_section == 0) {
-					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.pos.x, r.pos.y + r.size.y, r.size.x, 1), cache.drop_position_color);
+					VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(r.position.x, r.position.y + r.size.y, r.size.x, 1), cache.drop_position_color);
 				}
 			}
 
 			Color col = p_item->cells[i].custom_color ? p_item->cells[i].color : get_color(p_item->cells[i].selected ? "font_color_selected" : "font_color");
 
-			Point2i text_pos = item_rect.pos;
+			Point2i text_pos = item_rect.position;
 			text_pos.y += Math::floor((item_rect.size.y - font->get_height()) / 2) + font_ascent;
 
 			switch (p_item->cells[i].mode) {
@@ -1121,7 +1121,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 
 					Ref<Texture> checked = cache.checked;
 					Ref<Texture> unchecked = cache.unchecked;
-					Point2i check_ofs = item_rect.pos;
+					Point2i check_ofs = item_rect.position;
 					check_ofs.y += Math::floor((real_t)(item_rect.size.y - checked->get_height()) / 2);
 
 					if (p_item->cells[i].checked) {
@@ -1136,7 +1136,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 					text_pos.x += check_w;
 
 					item_rect.size.x -= check_w;
-					item_rect.pos.x += check_w;
+					item_rect.position.x += check_w;
 
 					draw_item_rect(p_item->cells[i], item_rect, col);
 
@@ -1164,7 +1164,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 						font->draw(ci, text_pos, s, col, item_rect.size.x - downarrow->get_width());
 
 						//?
-						Point2i arrow_pos = item_rect.pos;
+						Point2i arrow_pos = item_rect.position;
 						arrow_pos.x += item_rect.size.x - downarrow->get_width();
 						arrow_pos.y += Math::floor(((item_rect.size.y - downarrow->get_height())) / 2.0);
 
@@ -1184,7 +1184,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 						if (!p_item->cells[i].editable)
 							break;
 
-						Point2i updown_pos = item_rect.pos;
+						Point2i updown_pos = item_rect.position;
 						updown_pos.x += item_rect.size.x - updown->get_width();
 						updown_pos.y += Math::floor(((item_rect.size.y - updown->get_height())) / 2.0);
 
@@ -1203,7 +1203,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 					}
 
 					Point2i icon_ofs = (item_rect.size - icon_size) / 2;
-					icon_ofs += item_rect.pos;
+					icon_ofs += item_rect.position;
 
 					draw_texture_rect(p_item->cells[i].icon, Rect2(icon_ofs, icon_size));
 					//p_item->cells[i].icon->draw(ci, icon_ofs);
@@ -1230,7 +1230,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 
 					Rect2i ir = item_rect;
 
-					Point2i arrow_pos = item_rect.pos;
+					Point2i arrow_pos = item_rect.position;
 					arrow_pos.x += item_rect.size.x - downarrow->get_width();
 					arrow_pos.y += Math::floor(((item_rect.size.y - downarrow->get_height())) / 2.0);
 					ir.size.width -= downarrow->get_width();
@@ -2457,7 +2457,7 @@ bool Tree::edit_selected() {
 
 		edited_item = s;
 		edited_col = col;
-		custom_popup_rect = Rect2i(get_global_position() + rect.pos, rect.size);
+		custom_popup_rect = Rect2i(get_global_position() + rect.position, rect.size);
 		emit_signal("custom_popup_edited", false);
 		item_edited(col, s);
 
@@ -2472,7 +2472,7 @@ bool Tree::edit_selected() {
 		}
 
 		popup_menu->set_size(Size2(rect.size.width, 0));
-		popup_menu->set_position(get_global_position() + rect.pos + Point2i(0, rect.size.height));
+		popup_menu->set_position(get_global_position() + rect.position + Point2i(0, rect.size.height));
 		popup_menu->popup();
 		popup_edited_item = s;
 		popup_edited_item_col = col;
@@ -2480,7 +2480,7 @@ bool Tree::edit_selected() {
 
 	} else if (c.mode == TreeItem::CELL_MODE_STRING || c.mode == TreeItem::CELL_MODE_RANGE || c.mode == TreeItem::CELL_MODE_RANGE_EXPRESSION) {
 
-		Point2i textedpos = get_global_position() + rect.pos;
+		Point2i textedpos = get_global_position() + rect.position;
 		text_editor->set_position(textedpos);
 		text_editor->set_size(rect.size);
 		text_editor->clear();
@@ -2727,7 +2727,7 @@ void Tree::_notification(int p_what) {
 				ofs += tbrect.size.width;
 				//text
 				int clip_w = tbrect.size.width - sb->get_minimum_size().width;
-				f->draw_halign(ci, tbrect.pos + Point2i(sb->get_offset().x, (tbrect.size.height - f->get_height()) / 2 + f->get_ascent()), HALIGN_CENTER, clip_w, columns[i].title, cache.title_button_color);
+				f->draw_halign(ci, tbrect.position + Point2i(sb->get_offset().x, (tbrect.size.height - f->get_height()) / 2 + f->get_ascent()), HALIGN_CENTER, clip_w, columns[i].title, cache.title_button_color);
 			}
 		}
 	}
@@ -3109,11 +3109,11 @@ Rect2 Tree::get_item_rect(TreeItem *p_item, int p_column) const {
 	int ofs = get_item_offset(p_item);
 	int height = compute_item_height(p_item);
 	Rect2 r;
-	r.pos.y = ofs;
+	r.position.y = ofs;
 	r.size.height = height;
 
 	if (p_column == -1) {
-		r.pos.x = 0;
+		r.position.x = 0;
 		r.size.x = get_size().width;
 	} else {
 
@@ -3121,7 +3121,7 @@ Rect2 Tree::get_item_rect(TreeItem *p_item, int p_column) const {
 		for (int i = 0; i < p_column; i++) {
 			accum += get_column_width(i);
 		}
-		r.pos.x = accum;
+		r.position.x = accum;
 		r.size.x = get_column_width(p_column);
 	}
 

scene/main/viewport.cpp

@@ -1310,7 +1310,7 @@ Transform2D Viewport::_get_input_pre_xform() const {
 
 	if (to_screen_rect != Rect2()) {
 
-		pre_xf.elements[2] = -to_screen_rect.pos;
+		pre_xf.elements[2] = -to_screen_rect.position;
 		pre_xf.scale(size / to_screen_rect.size);
 	}
 
@@ -1473,17 +1473,17 @@ void Viewport::_gui_show_tooltip() {
 	gui.tooltip_label->set_text(tooltip);
 	Rect2 r(gui.tooltip_pos + Point2(10, 10), gui.tooltip_label->get_combined_minimum_size() + ttp->get_minimum_size());
 	Rect2 vr = gui.tooltip_label->get_viewport_rect();
-	if (r.size.x + r.pos.x > vr.size.x)
-		r.pos.x = vr.size.x - r.size.x;
-	else if (r.pos.x < 0)
-		r.pos.x = 0;
+	if (r.size.x + r.position.x > vr.size.x)
+		r.position.x = vr.size.x - r.size.x;
+	else if (r.position.x < 0)
+		r.position.x = 0;
 
-	if (r.size.y + r.pos.y > vr.size.y)
-		r.pos.y = vr.size.y - r.size.y;
-	else if (r.pos.y < 0)
-		r.pos.y = 0;
+	if (r.size.y + r.position.y > vr.size.y)
+		r.position.y = vr.size.y - r.size.y;
+	else if (r.position.y < 0)
+		r.position.y = 0;
 
-	gui.tooltip_popup->set_global_position(r.pos);
+	gui.tooltip_popup->set_global_position(r.position);
 	gui.tooltip_popup->set_size(r.size);
 
 	gui.tooltip_popup->raise();

scene/resources/animation.cpp

@@ -1133,7 +1133,7 @@ Variant Animation::_cubic_interpolate(const Variant &p_pre_a, const Variant &p_a
 			Rect2 pb = p_post_b;
 
 			return Rect2(
-					a.pos.cubic_interpolate(b.pos, pa.pos, pb.pos, p_c),
+					a.position.cubic_interpolate(b.position, pa.position, pb.position, p_c),
 					a.size.cubic_interpolate(b.size, pa.size, pb.size, p_c));
 
 		} break;

scene/resources/bit_mask.cpp

@@ -67,9 +67,9 @@ void BitMap::set_bit_rect(const Rect2 &p_rect, bool p_value) {
 	Rect2i current = Rect2i(0, 0, width, height).clip(p_rect);
 	uint8_t *data = bitmask.ptr();
 
-	for (int i = current.pos.x; i < current.pos.x + current.size.x; i++) {
+	for (int i = current.position.x; i < current.position.x + current.size.x; i++) {
 
-		for (int j = current.pos.y; j < current.pos.y + current.size.y; j++) {
+		for (int j = current.position.y; j < current.position.y + current.size.y; j++) {
 
 			int ofs = width * j + i;
 			int bbyte = ofs / 8;

scene/resources/capsule_shape_2d.cpp

@@ -80,7 +80,7 @@ Rect2 CapsuleShape2D::get_rect() const {
 
 	Vector2 he = Point2(get_radius(), get_radius() + get_height() * 0.5);
 	Rect2 rect;
-	rect.pos = -he;
+	rect.position = -he;
 	rect.size = he * 2.0;
 	return rect;
 }

scene/resources/circle_shape_2d.cpp

@@ -58,7 +58,7 @@ void CircleShape2D::_bind_methods() {
 
 Rect2 CircleShape2D::get_rect() const {
 	Rect2 rect;
-	rect.pos = -Point2(get_radius(), get_radius());
+	rect.position = -Point2(get_radius(), get_radius());
 	rect.size = Point2(get_radius(), get_radius()) * 2.0;
 	return rect;
 }

scene/resources/concave_polygon_shape_2d.cpp

@@ -68,7 +68,7 @@ Rect2 ConcavePolygonShape2D::get_rect() const {
 	PoolVector<Vector2>::Read r = s.read();
 	for (int i = 0; i < len; i++) {
 		if (i == 0)
-			rect.pos = r[i];
+			rect.position = r[i];
 		else
 			rect.expand_to(r[i]);
 	}

scene/resources/convex_polygon_shape_2d.cpp

@@ -78,7 +78,7 @@ Rect2 ConvexPolygonShape2D::get_rect() const {
 	Rect2 rect;
 	for (int i = 0; i < points.size(); i++) {
 		if (i == 0)
-			rect.pos = points[i];
+			rect.position = points[i];
 		else
 			rect.expand_to(points[i]);
 	}

scene/resources/default_theme/default_theme.cpp

@@ -138,8 +138,8 @@ static Ref<BitmapFont> make_font(int p_height, int p_ascent, int p_valign, int p
 
 		int chr = c[0];
 		Rect2 frect;
-		frect.pos.x = c[1];
-		frect.pos.y = c[2];
+		frect.position.x = c[1];
+		frect.position.y = c[2];
 		frect.size.x = c[3];
 		frect.size.y = c[4];
 		Point2 align(c[5], c[6] + p_valign);
@@ -170,8 +170,8 @@ static Ref<BitmapFont> make_font2(int p_height, int p_ascent, int p_charcount, c
 
 		int chr = c[0];
 		Rect2 frect;
-		frect.pos.x = c[1];
-		frect.pos.y = c[2];
+		frect.position.x = c[1];
+		frect.position.y = c[2];
 		frect.size.x = c[3];
 		frect.size.y = c[4];
 		Point2 align(c[6], c[5]);

scene/resources/font.cpp

@@ -120,8 +120,8 @@ PoolVector<int> BitmapFont::_get_chars() const {
 		const Character *c = char_map.getptr(*key);
 		chars.push_back(*key);
 		chars.push_back(c->texture_idx);
-		chars.push_back(c->rect.pos.x);
-		chars.push_back(c->rect.pos.y);
+		chars.push_back(c->rect.position.x);
+		chars.push_back(c->rect.position.y);
 
 		chars.push_back(c->rect.size.x);
 		chars.push_back(c->rect.size.y);
@@ -272,9 +272,9 @@ Error BitmapFont::create_from_fnt(const String &p_string) {
 			Rect2 rect;
 
 			if (keys.has("x"))
-				rect.pos.x = keys["x"].to_int();
+				rect.position.x = keys["x"].to_int();
 			if (keys.has("y"))
-				rect.pos.y = keys["y"].to_int();
+				rect.position.y = keys["y"].to_int();
 			if (keys.has("width"))
 				rect.size.width = keys["width"].to_int();
 			if (keys.has("height"))

scene/resources/polygon_path_finder.cpp

@@ -71,7 +71,7 @@ void PolygonPathFinder::setup(const Vector<Vector2> &p_points, const Vector<int>
 		outside_point.y = i == 0 ? p_points[0].y : (MAX(p_points[i].y, outside_point.y));
 
 		if (i == 0) {
-			bounds.pos = points[i].pos;
+			bounds.position = points[i].pos;
 		} else {
 			bounds.expand_to(points[i].pos);
 		}

scene/resources/segment_shape_2d.cpp

@@ -35,7 +35,7 @@
 void SegmentShape2D::_update_shape() {
 
 	Rect2 r;
-	r.pos = a;
+	r.position = a;
 	r.size = b;
 	Physics2DServer::get_singleton()->shape_set_data(get_rid(), r);
 	emit_changed();
@@ -69,7 +69,7 @@ void SegmentShape2D::draw(const RID &p_to_rid, const Color &p_color) {
 Rect2 SegmentShape2D::get_rect() const {
 
 	Rect2 rect;
-	rect.pos = a;
+	rect.position = a;
 	rect.expand_to(b);
 	return rect;
 }
@@ -121,7 +121,7 @@ void RayShape2D::draw(const RID &p_to_rid, const Color &p_color) {
 Rect2 RayShape2D::get_rect() const {
 
 	Rect2 rect;
-	rect.pos = Vector2();
+	rect.position = Vector2();
 	rect.expand_to(Vector2(0, length));
 	rect = rect.grow(0.707 * 4);
 	return rect;

scene/resources/shape_line_2d.cpp

@@ -76,7 +76,7 @@ Rect2 LineShape2D::get_rect() const {
 	Vector2 l1[2] = { point - get_normal().tangent() * 100, point + get_normal().tangent() * 100 };
 	Vector2 l2[2] = { point, point + get_normal() * 30 };
 	Rect2 rect;
-	rect.pos = l1[0];
+	rect.position = l1[0];
 	rect.expand_to(l1[1]);
 	rect.expand_to(l2[0]);
 	rect.expand_to(l2[1]);

scene/resources/style_box.cpp

@@ -138,8 +138,8 @@ void StyleBoxTexture::draw(RID p_canvas_item, const Rect2 &p_rect) const {
 
 	texture->get_rect_region(rect, src_rect, rect, src_rect);
 
-	rect.pos.x -= expand_margin[MARGIN_LEFT];
-	rect.pos.y -= expand_margin[MARGIN_TOP];
+	rect.position.x -= expand_margin[MARGIN_LEFT];
+	rect.position.y -= expand_margin[MARGIN_TOP];
 	rect.size.x += expand_margin[MARGIN_LEFT] + expand_margin[MARGIN_RIGHT];
 	rect.size.y += expand_margin[MARGIN_TOP] + expand_margin[MARGIN_BOTTOM];
 
@@ -352,26 +352,26 @@ void StyleBoxFlat::draw(RID p_canvas_item, const Rect2 &p_rect) const {
 			color_downright.b = (border_size - i) * color_downright.b / border_size + i * bg_color.b / border_size;
 		}
 
-		vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r.pos.x, r.pos.y + r.size.y - 1), Size2(r.size.x, 1)), color_downright);
-		vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r.pos.x + r.size.x - 1, r.pos.y), Size2(1, r.size.y)), color_downright);
+		vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r.position.x, r.position.y + r.size.y - 1), Size2(r.size.x, 1)), color_downright);
+		vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r.position.x + r.size.x - 1, r.position.y), Size2(1, r.size.y)), color_downright);
 
-		vs->canvas_item_add_rect(p_canvas_item, Rect2(r.pos, Size2(r.size.x, 1)), color_upleft);
-		vs->canvas_item_add_rect(p_canvas_item, Rect2(r.pos, Size2(1, r.size.y)), color_upleft);
+		vs->canvas_item_add_rect(p_canvas_item, Rect2(r.position, Size2(r.size.x, 1)), color_upleft);
+		vs->canvas_item_add_rect(p_canvas_item, Rect2(r.position, Size2(1, r.size.y)), color_upleft);
 
-		r.pos.x++;
-		r.pos.y++;
+		r.position.x++;
+		r.position.y++;
 		r.size.x -= 2;
 		r.size.y -= 2;
 	}
 
 	if (draw_center)
-		vs->canvas_item_add_rect(p_canvas_item, Rect2(r.pos, r.size), bg_color);
+		vs->canvas_item_add_rect(p_canvas_item, Rect2(r.position, r.size), bg_color);
 
 	Rect2i r_add = p_rect;
-	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.pos.x - additional_border_size[MARGIN_LEFT], r_add.pos.y - additional_border_size[MARGIN_TOP]), Size2(r_add.size.width + additional_border_size[MARGIN_LEFT] + additional_border_size[MARGIN_RIGHT], additional_border_size[MARGIN_TOP])), light_color);
-	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.pos.x - additional_border_size[MARGIN_LEFT], r_add.pos.y), Size2(additional_border_size[MARGIN_LEFT], r_add.size.height)), light_color);
-	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.pos.x + r_add.size.width, r_add.pos.y), Size2(additional_border_size[MARGIN_RIGHT], r_add.size.height)), dark_color);
-	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.pos.x - additional_border_size[MARGIN_LEFT], r_add.pos.y + r_add.size.height), Size2(r_add.size.width + additional_border_size[MARGIN_LEFT] + additional_border_size[MARGIN_RIGHT], additional_border_size[MARGIN_BOTTOM])), dark_color);
+	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.position.x - additional_border_size[MARGIN_LEFT], r_add.position.y - additional_border_size[MARGIN_TOP]), Size2(r_add.size.width + additional_border_size[MARGIN_LEFT] + additional_border_size[MARGIN_RIGHT], additional_border_size[MARGIN_TOP])), light_color);
+	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.position.x - additional_border_size[MARGIN_LEFT], r_add.position.y), Size2(additional_border_size[MARGIN_LEFT], r_add.size.height)), light_color);
+	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.position.x + r_add.size.width, r_add.position.y), Size2(additional_border_size[MARGIN_RIGHT], r_add.size.height)), dark_color);
+	vs->canvas_item_add_rect(p_canvas_item, Rect2(Point2i(r_add.position.x - additional_border_size[MARGIN_LEFT], r_add.position.y + r_add.size.height), Size2(r_add.size.width + additional_border_size[MARGIN_LEFT] + additional_border_size[MARGIN_RIGHT], additional_border_size[MARGIN_BOTTOM])), dark_color);
 }
 
 float StyleBoxFlat::get_style_margin(Margin p_margin) const {

scene/resources/texture.cpp

@@ -860,7 +860,7 @@ void AtlasTexture::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_m
 		rc.size.height = atlas->get_height();
 	}
 
-	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, Rect2(p_pos + margin.pos, rc.size), atlas->get_rid(), rc, p_modulate, p_transpose);
+	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, Rect2(p_pos + margin.position, rc.size), atlas->get_rid(), rc, p_modulate, p_transpose);
 }
 
 void AtlasTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
@@ -879,7 +879,7 @@ void AtlasTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile
 	}
 
 	Vector2 scale = p_rect.size / (region.size + margin.size);
-	Rect2 dr(p_rect.pos + margin.pos * scale, rc.size * scale);
+	Rect2 dr(p_rect.position + margin.position * scale, rc.size * scale);
 
 	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), rc, p_modulate, p_transpose);
 }
@@ -892,24 +892,24 @@ void AtlasTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, cons
 		return;
 
 	Rect2 src = p_src_rect;
-	src.pos += (rc.pos - margin.pos);
+	src.position += (rc.position - margin.position);
 	Rect2 src_c = rc.clip(src);
 	if (src_c.size == Size2())
 		return;
-	Vector2 ofs = (src_c.pos - src.pos);
+	Vector2 ofs = (src_c.position - src.position);
 
 	Vector2 scale = p_rect.size / p_src_rect.size;
 	if (scale.x < 0) {
-		float mx = (margin.size.width - margin.pos.x);
-		mx -= margin.pos.x;
+		float mx = (margin.size.width - margin.position.x);
+		mx -= margin.position.x;
 		ofs.x = -(ofs.x + mx);
 	}
 	if (scale.y < 0) {
-		float my = margin.size.height - margin.pos.y;
-		my -= margin.pos.y;
+		float my = margin.size.height - margin.position.y;
+		my -= margin.position.y;
 		ofs.y = -(ofs.y + my);
 	}
-	Rect2 dr(p_rect.pos + ofs * scale, src_c.size * scale);
+	Rect2 dr(p_rect.position + ofs * scale, src_c.size * scale);
 
 	VS::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, dr, atlas->get_rid(), src_c, p_modulate, p_transpose);
 }
@@ -922,24 +922,24 @@ bool AtlasTexture::get_rect_region(const Rect2 &p_rect, const Rect2 &p_src_rect,
 		return false;
 
 	Rect2 src = p_src_rect;
-	src.pos += (rc.pos - margin.pos);
+	src.position += (rc.position - margin.position);
 	Rect2 src_c = rc.clip(src);
 	if (src_c.size == Size2())
 		return false;
-	Vector2 ofs = (src_c.pos - src.pos);
+	Vector2 ofs = (src_c.position - src.position);
 
 	Vector2 scale = p_rect.size / p_src_rect.size;
 	if (scale.x < 0) {
-		float mx = (margin.size.width - margin.pos.x);
-		mx -= margin.pos.x;
+		float mx = (margin.size.width - margin.position.x);
+		mx -= margin.position.x;
 		ofs.x = -(ofs.x + mx);
 	}
 	if (scale.y < 0) {
-		float my = margin.size.height - margin.pos.y;
-		my -= margin.pos.y;
+		float my = margin.size.height - margin.position.y;
+		my -= margin.position.y;
 		ofs.y = -(ofs.y + my);
 	}
-	Rect2 dr(p_rect.pos + ofs * scale, src_c.size * scale);
+	Rect2 dr(p_rect.position + ofs * scale, src_c.size * scale);
 
 	r_rect = dr;
 	r_src_rect = src_c;
@@ -1096,7 +1096,7 @@ void LargeTexture::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile
 	for (int i = 0; i < pieces.size(); i++) {
 
 		// TODO
-		pieces[i].texture->draw_rect(p_canvas_item, Rect2(pieces[i].offset * scale + p_rect.pos, pieces[i].texture->get_size() * scale), false, p_modulate, p_transpose);
+		pieces[i].texture->draw_rect(p_canvas_item, Rect2(pieces[i].offset * scale + p_rect.position, pieces[i].texture->get_size() * scale), false, p_modulate, p_transpose);
 	}
 }
 void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose) const {
@@ -1116,8 +1116,8 @@ void LargeTexture::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, cons
 		Rect2 local = p_src_rect.clip(rect);
 		Rect2 target = local;
 		target.size *= scale;
-		target.pos = p_rect.pos + (p_src_rect.pos + rect.pos) * scale;
-		local.pos -= rect.pos;
+		target.position = p_rect.position + (p_src_rect.position + rect.position) * scale;
+		local.position -= rect.position;
 		pieces[i].texture->draw_rect_region(p_canvas_item, target, local, p_modulate, p_transpose);
 	}
 }

scene/resources/world_2d.cpp

@@ -97,9 +97,9 @@ struct SpatialIndexer2D {
 
 	void _notifier_update_cells(VisibilityNotifier2D *p_notifier, const Rect2 &p_rect, bool p_add) {
 
-		Point2i begin = p_rect.pos;
+		Point2i begin = p_rect.position;
 		begin /= cell_size;
-		Point2i end = p_rect.pos + p_rect.size;
+		Point2i end = p_rect.position + p_rect.size;
 		end /= cell_size;
 		for (int i = begin.x; i <= end.x; i++) {
 
@@ -220,9 +220,9 @@ struct SpatialIndexer2D {
 
 		for (Map<Viewport *, ViewportData>::Element *E = viewports.front(); E; E = E->next()) {
 
-			Point2i begin = E->get().rect.pos;
+			Point2i begin = E->get().rect.position;
 			begin /= cell_size;
-			Point2i end = E->get().rect.pos + E->get().rect.size;
+			Point2i end = E->get().rect.position + E->get().rect.size;
 			end /= cell_size;
 			pass++;
 			List<VisibilityNotifier2D *> added;

servers/physics_2d/broad_phase_2d_hash_grid.cpp

@@ -116,8 +116,8 @@ void BroadPhase2DHashGrid::_enter_grid(Element *p_elem, const Rect2 &p_rect, boo
 		return;
 	}
 
-	Point2i from = (p_rect.pos / cell_size).floor();
-	Point2i to = ((p_rect.pos + p_rect.size) / cell_size).floor();
+	Point2i from = (p_rect.position / cell_size).floor();
+	Point2i to = ((p_rect.position + p_rect.size) / cell_size).floor();
 
 	for (int i = from.x; i <= to.x; i++) {
 
@@ -214,8 +214,8 @@ void BroadPhase2DHashGrid::_exit_grid(Element *p_elem, const Rect2 &p_rect, bool
 		return;
 	}
 
-	Point2i from = (p_rect.pos / cell_size).floor();
-	Point2i to = ((p_rect.pos + p_rect.size) / cell_size).floor();
+	Point2i from = (p_rect.position / cell_size).floor();
+	Point2i to = ((p_rect.position + p_rect.size) / cell_size).floor();
 
 	for (int i = from.x; i <= to.x; i++) {
 
@@ -574,8 +574,8 @@ int BroadPhase2DHashGrid::cull_aabb(const Rect2 &p_aabb, CollisionObject2DSW **p
 
 	pass++;
 
-	Point2i from = (p_aabb.pos / cell_size).floor();
-	Point2i to = ((p_aabb.pos + p_aabb.size) / cell_size).floor();
+	Point2i from = (p_aabb.position / cell_size).floor();
+	Point2i to = ((p_aabb.position + p_aabb.size) / cell_size).floor();
 	int cullcount = 0;
 
 	for (int i = from.x; i <= to.x; i++) {

servers/physics_2d/collision_object_2d_sw.cpp

@@ -169,7 +169,7 @@ void CollisionObject2DSW::_update_shapes_with_motion(const Vector2 &p_motion) {
 		Rect2 shape_aabb = s.shape->get_aabb();
 		Transform2D xform = transform * s.xform;
 		shape_aabb = xform.xform(shape_aabb);
-		shape_aabb = shape_aabb.merge(Rect2(shape_aabb.pos + p_motion, shape_aabb.size)); //use motion
+		shape_aabb = shape_aabb.merge(Rect2(shape_aabb.position + p_motion, shape_aabb.size)); //use motion
 		s.aabb_cache = shape_aabb;
 
 		space->get_broadphase()->move(s.bpid, shape_aabb);

servers/physics_2d/collision_solver_2d_sw.cpp

@@ -203,7 +203,7 @@ bool CollisionSolver2DSW::solve_concave(const Shape2DSW *p_shape_A, const Transf
 		smin *= axis_scale;
 		smax *= axis_scale;
 
-		local_aabb.pos[i] = smin;
+		local_aabb.position[i] = smin;
 		local_aabb.size[i] = smax - smin;
 	}
 

servers/physics_2d/shape_2d_sw.cpp

@@ -246,12 +246,12 @@ void SegmentShape2DSW::set_data(const Variant &p_data) {
 	ERR_FAIL_COND(p_data.get_type() != Variant::RECT2);
 
 	Rect2 r = p_data;
-	a = r.pos;
+	a = r.position;
 	b = r.size;
 	n = (b - a).tangent();
 
 	Rect2 aabb;
-	aabb.pos = a;
+	aabb.position = a;
 	aabb.expand_to(b);
 	if (aabb.size.x == 0)
 		aabb.size.x = 0.001;
@@ -263,7 +263,7 @@ void SegmentShape2DSW::set_data(const Variant &p_data) {
 Variant SegmentShape2DSW::get_data() const {
 
 	Rect2 r;
-	r.pos = a;
+	r.position = a;
 	r.size = b;
 	return r;
 }
@@ -621,13 +621,13 @@ bool ConvexPolygonShape2DSW::intersect_segment(const Vector2 &p_begin, const Vec
 real_t ConvexPolygonShape2DSW::get_moment_of_inertia(real_t p_mass, const Size2 &p_scale) const {
 
 	Rect2 aabb;
-	aabb.pos = points[0].pos * p_scale;
+	aabb.position = points[0].pos * p_scale;
 	for (int i = 0; i < point_count; i++) {
 
 		aabb.expand_to(points[i].pos * p_scale);
 	}
 
-	return p_mass * aabb.size.dot(aabb.size) / 12.0 + p_mass * (aabb.pos + aabb.size * 0.5).length_squared();
+	return p_mass * aabb.size.dot(aabb.size) / 12.0 + p_mass * (aabb.position + aabb.size * 0.5).length_squared();
 }
 
 void ConvexPolygonShape2DSW::set_data(const Variant &p_data) {
@@ -677,7 +677,7 @@ void ConvexPolygonShape2DSW::set_data(const Variant &p_data) {
 
 	ERR_FAIL_COND(point_count == 0);
 	Rect2 aabb;
-	aabb.pos = points[0].pos;
+	aabb.position = points[0].pos;
 	for (int i = 1; i < point_count; i++)
 		aabb.expand_to(points[i].pos);
 
@@ -942,7 +942,7 @@ void ConcavePolygonShape2DSW::set_data(const Variant &p_data) {
 		}
 
 		points.resize(pointmap.size());
-		aabb.pos = pointmap.front()->key();
+		aabb.position = pointmap.front()->key();
 		for (Map<Point2, int>::Element *E = pointmap.front(); E; E = E->next()) {
 
 			aabb.expand_to(E->key());
@@ -953,7 +953,7 @@ void ConcavePolygonShape2DSW::set_data(const Variant &p_data) {
 		main_vbh.resize(segments.size());
 		for (int i = 0; i < main_vbh.size(); i++) {
 
-			main_vbh[i].aabb.pos = points[segments[i].points[0]];
+			main_vbh[i].aabb.position = points[segments[i].points[0]];
 			main_vbh[i].aabb.expand_to(points[segments[i].points[1]]);
 			main_vbh[i].left = -1;
 			main_vbh[i].right = i;

servers/physics_2d/shape_2d_sw.h

@@ -513,7 +513,7 @@ class ConcavePolygonShape2DSW : public ConcaveShape2DSW {
 
 		_FORCE_INLINE_ bool operator()(const BVH &a, const BVH &b) const {
 
-			return (a.aabb.pos.x + a.aabb.size.x * 0.5) < (b.aabb.pos.x + b.aabb.size.x * 0.5);
+			return (a.aabb.position.x + a.aabb.size.x * 0.5) < (b.aabb.position.x + b.aabb.size.x * 0.5);
 		}
 	};
 
@@ -521,7 +521,7 @@ class ConcavePolygonShape2DSW : public ConcaveShape2DSW {
 
 		_FORCE_INLINE_ bool operator()(const BVH &a, const BVH &b) const {
 
-			return (a.aabb.pos.y + a.aabb.size.y * 0.5) < (b.aabb.pos.y + b.aabb.size.y * 0.5);
+			return (a.aabb.position.y + a.aabb.size.y * 0.5) < (b.aabb.position.y + b.aabb.size.y * 0.5);
 		}
 	};
 

servers/physics_2d/space_2d_sw.cpp

@@ -50,7 +50,7 @@ int Physics2DDirectSpaceStateSW::intersect_point(const Vector2 &p_point, ShapeRe
 		return 0;
 
 	Rect2 aabb;
-	aabb.pos = p_point - Vector2(0.00001, 0.00001);
+	aabb.position = p_point - Vector2(0.00001, 0.00001);
 	aabb.size = Vector2(0.00002, 0.00002);
 
 	int amount = space->broadphase->cull_aabb(aabb, space->intersection_query_results, Space2DSW::INTERSECTION_QUERY_MAX, space->intersection_query_subindex_results);
@@ -223,7 +223,7 @@ bool Physics2DDirectSpaceStateSW::cast_motion(const RID &p_shape, const Transfor
 	ERR_FAIL_COND_V(!shape, false);
 
 	Rect2 aabb = p_xform.xform(shape->get_aabb());
-	aabb = aabb.merge(Rect2(aabb.pos + p_motion, aabb.size)); //motion
+	aabb = aabb.merge(Rect2(aabb.position + p_motion, aabb.size)); //motion
 	aabb = aabb.grow(p_margin);
 
 	/*
@@ -339,7 +339,7 @@ bool Physics2DDirectSpaceStateSW::collide_shape(RID p_shape, const Transform2D &
 	ERR_FAIL_COND_V(!shape, 0);
 
 	Rect2 aabb = p_shape_xform.xform(shape->get_aabb());
-	aabb = aabb.merge(Rect2(aabb.pos + p_motion, aabb.size)); //motion
+	aabb = aabb.merge(Rect2(aabb.position + p_motion, aabb.size)); //motion
 	aabb = aabb.grow(p_margin);
 
 	int amount = space->broadphase->cull_aabb(aabb, space->intersection_query_results, Space2DSW::INTERSECTION_QUERY_MAX, space->intersection_query_subindex_results);
@@ -434,7 +434,7 @@ bool Physics2DDirectSpaceStateSW::rest_info(RID p_shape, const Transform2D &p_sh
 	ERR_FAIL_COND_V(!shape, 0);
 
 	Rect2 aabb = p_shape_xform.xform(shape->get_aabb());
-	aabb = aabb.merge(Rect2(aabb.pos + p_motion, aabb.size)); //motion
+	aabb = aabb.merge(Rect2(aabb.position + p_motion, aabb.size)); //motion
 	aabb = aabb.grow(p_margin);
 
 	int amount = space->broadphase->cull_aabb(aabb, space->intersection_query_results, Space2DSW::INTERSECTION_QUERY_MAX, space->intersection_query_subindex_results);
@@ -656,7 +656,7 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 			}
 
 			body_transform.elements[2] += recover_motion;
-			body_aabb.pos += recover_motion;
+			body_aabb.position += recover_motion;
 
 			recover_attempts--;
 
@@ -671,7 +671,7 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 		// STEP 2 ATTEMPT MOTION
 
 		Rect2 motion_aabb = body_aabb;
-		motion_aabb.pos += p_motion;
+		motion_aabb.position += p_motion;
 		motion_aabb = motion_aabb.merge(body_aabb);
 
 		int amount = _cull_aabb_for_body(p_body, motion_aabb);
@@ -807,7 +807,7 @@ bool Space2DSW::test_body_motion(Body2DSW *p_body, const Transform2D &p_from, co
 		Transform2D body_shape_xform = ugt * p_body->get_shape_transform(best_shape);
 		Shape2DSW *body_shape = p_body->get_shape(best_shape);
 
-		body_aabb.pos += p_motion * unsafe;
+		body_aabb.position += p_motion * unsafe;
 
 		int amount = _cull_aabb_for_body(p_body, body_aabb);
 

servers/visual/rasterizer.h

@@ -769,7 +769,7 @@ public:
 					case Item::Command::TYPE_LINE: {
 
 						const Item::CommandLine *line = static_cast<const Item::CommandLine *>(c);
-						r.pos = line->from;
+						r.position = line->from;
 						r.expand_to(line->to);
 					} break;
 					case Item::Command::TYPE_RECT: {
@@ -786,7 +786,7 @@ public:
 					case Item::Command::TYPE_PRIMITIVE: {
 
 						const Item::CommandPrimitive *primitive = static_cast<const Item::CommandPrimitive *>(c);
-						r.pos = primitive->points[0];
+						r.position = primitive->points[0];
 						for (int i = 1; i < primitive->points.size(); i++) {
 
 							r.expand_to(primitive->points[i]);
@@ -797,7 +797,7 @@ public:
 						const Item::CommandPolygon *polygon = static_cast<const Item::CommandPolygon *>(c);
 						int l = polygon->points.size();
 						const Point2 *pp = &polygon->points[0];
-						r.pos = pp[0];
+						r.position = pp[0];
 						for (int i = 1; i < l; i++) {
 
 							r.expand_to(pp[i]);
@@ -822,7 +822,7 @@ public:
 					case Item::Command::TYPE_CIRCLE: {
 
 						const Item::CommandCircle *circle = static_cast<const Item::CommandCircle *>(c);
-						r.pos = Point2(-circle->radius, -circle->radius) + circle->pos;
+						r.position = Point2(-circle->radius, -circle->radius) + circle->pos;
 						r.size = Point2(circle->radius * 2.0, circle->radius * 2.0);
 					} break;
 					case Item::Command::TYPE_TRANSFORM: {

servers/visual/visual_server_canvas.cpp

@@ -61,7 +61,7 @@ void VisualServerCanvas::_render_canvas_item(Item *p_canvas_item, const Transfor
 	Rect2 rect = ci->get_rect();
 	Transform2D xform = p_transform * ci->xform;
 	Rect2 global_rect = xform.xform(rect);
-	global_rect.pos += p_clip_rect.pos;
+	global_rect.position += p_clip_rect.position;
 
 	if (ci->use_parent_material && p_material_owner)
 		ci->material_owner = p_material_owner;
@@ -119,7 +119,7 @@ void VisualServerCanvas::_render_canvas_item(Item *p_canvas_item, const Transfor
 		ci->final_transform = xform;
 		ci->final_modulate = Color(modulate.r * ci->self_modulate.r, modulate.g * ci->self_modulate.g, modulate.b * ci->self_modulate.b, modulate.a * ci->self_modulate.a);
 		ci->global_rect_cache = global_rect;
-		ci->global_rect_cache.pos -= p_clip_rect.pos;
+		ci->global_rect_cache.position -= p_clip_rect.position;
 		ci->light_masked = false;
 
 		int zidx = p_z - VS::CANVAS_ITEM_Z_MIN;
@@ -1041,7 +1041,7 @@ void VisualServerCanvas::canvas_occluder_polygon_set_shape_as_lines(RID p_occlud
 		PoolVector<Vector2>::Read r = p_shape.read();
 		for (int i = 0; i < lc; i++) {
 			if (i == 0)
-				occluder_poly->aabb.pos = r[i];
+				occluder_poly->aabb.position = r[i];
 			else
 				occluder_poly->aabb.expand_to(r[i]);
 		}

servers/visual/visual_server_viewport.cpp

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

servers/visual_server.cpp

@@ -399,7 +399,7 @@ Error VisualServer::_surface_set_data(Array p_arrays, uint32_t p_format, uint32_
 						}
 					}
 
-					r_aabb = Rect3(Vector3(aabb.pos.x, aabb.pos.y, 0), Vector3(aabb.size.x, aabb.size.y, 0));
+					r_aabb = Rect3(Vector3(aabb.position.x, aabb.position.y, 0), Vector3(aabb.size.x, aabb.size.y, 0));
 
 				} else {
 					PoolVector<Vector3> array = p_arrays[ai];