maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

renamed all Rect2.pos to Rect2.position

Browse source
This commit is contained in:
alexholly 2017-06-04 00:25:13 +02:00
parent 69bec86028
commit a3c90b0293
84 changed files with 685 additions and 685 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
core/helper/math_fieldwise.cpp
View file

@ -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)

12
core/image.cpp
View file

@ -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];

8
core/io/marshalls.cpp
View file

@ -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]);
}

8
core/io/resource_format_binary.cpp
View file

@ -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);

4
core/math/camera_matrix.cpp
View file

@ -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;
}

2
core/math/math_2d.cpp
View file

@ -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;

210
core/math/math_2d.h
View file

@ -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]);

6
core/variant.cpp
View file

@ -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;

18
core/variant_op.cpp
View file

@ -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: {

2
core/variant_parser.cpp
View file

@ -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: {

58
drivers/gles3/rasterizer_canvas_gles3.cpp
View file

@ -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);
}

6
drivers/gles3/rasterizer_gles3.cpp
View file

@ -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);

22
drivers/gles3/rasterizer_scene_gles3.cpp
View file

@ -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;
@ -4159,15 +4159,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;
}
}
}
@ -4175,8 +4175,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;

4
drivers/gles3/rasterizer_storage_gles3.cpp
View file

@ -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) {

8
editor/animation_editor.cpp
View file

@ -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();

2
editor/editor_audio_buses.cpp
View file

@ -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 {

4
editor/editor_fonts.cpp
View file

@ -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);

4
editor/editor_node.cpp
View file

@ -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) {

12
editor/editor_run.cpp
View file

@ -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");

4
editor/plugins/animation_tree_editor_plugin.cpp
View file

@ -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) {

80
editor/plugins/canvas_item_editor_plugin.cpp
View file

@ -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);

8
editor/plugins/polygon_2d_editor_plugin.cpp
View file

@ -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);

18
editor/plugins/spatial_editor_plugin.cpp
View file

@ -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));
}
}

74
editor/plugins/texture_region_editor_plugin.cpp
View file

@ -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());

98
editor/plugins/tile_map_editor_plugin.cpp
View file

@ -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));

4
editor/project_settings.cpp
View file

@ -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();

30
editor/property_editor.cpp
View file

@ -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();
}
@ -3668,7 +3668,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);
@ -3926,7 +3926,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();
@ -4033,9 +4033,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) {
@ -4046,9 +4046,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();
@ -4124,7 +4124,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);

8
editor/scene_tree_editor.cpp
View file

@ -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);

10
editor/script_editor_debugger.cpp
View file

@ -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;

4
main/input_default.cpp
View file

@ -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;

16
modules/gdnative/godot/godot_rect2.cpp
View file

@ -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) {

6
modules/gdnative/godot/godot_rect2.h
View file

@ -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);

2
modules/visual_script/visual_script_editor.cpp
View file

@ -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) {

6
platform/osx/os_osx.mm
View file

@ -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;
};

6
platform/windows/os_windows.cpp
View file

@ -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 {

56
scene/2d/camera_2d.cpp
View file

@ -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) {

2
scene/2d/collision_polygon_2d.cpp
View file

@ -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();

4
scene/2d/line_builder.cpp
View file

@ -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));
}
//----------------------------------------------------------------------------

6
scene/2d/node_2d.cpp
View file

@ -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);

4
scene/2d/particles_2d.cpp
View file

@ -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)

12
scene/2d/polygon_2d.cpp
View file

@ -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),
};

4
scene/2d/sprite.cpp
View file

@ -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;

30
scene/2d/tile_map.cpp
View file

@ -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()));

36
scene/3d/sprite_3d.cpp
View file

@ -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()) {

8
scene/gui/button_array.cpp
View file

@ -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;

6
scene/gui/container.cpp
View file

@ -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));

26
scene/gui/control.cpp
View file

@ -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;

26
scene/gui/dialogs.cpp
View file

@ -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);
}
}
}

12
scene/gui/graph_edit.cpp
View file

@ -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())

2
scene/gui/graph_node.cpp
View file

@ -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();

36
scene/gui/item_list.cpp
View file

@ -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 {

10
scene/gui/popup.cpp
View file

@ -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();

6
scene/gui/popup_menu.cpp
View file

@ -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));
}
}
}

8
scene/gui/scroll_bar.cpp
View file

@ -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);

4
scene/gui/scroll_container.cpp
View file

@ -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);

2
scene/gui/tab_container.cpp
View file

@ -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;

12
scene/gui/tabs.cpp
View file

@ -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;
}

22
scene/gui/text_edit.cpp
View file

@ -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();

68
scene/gui/tree.cpp
View file

@ -877,8 +877,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;
}
@ -893,8 +893,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
@ -1007,16 +1007,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())
@ -1028,34 +1028,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);
}
@ -1066,22 +1066,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) {
@ -1094,7 +1094,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) {
@ -1109,7 +1109,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);
@ -1137,7 +1137,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);
@ -1157,7 +1157,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);
@ -1176,7 +1176,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);
@ -1205,7 +1205,7 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
ir.size.width -= downarrow->get_width();
draw_item_rect(p_item->cells[i], ir, col);
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);
@ -2401,7 +2401,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);
@ -2416,7 +2416,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;
@ -2424,7 +2424,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();
@ -2671,7 +2671,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);
}
}
}
@ -3053,11 +3053,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 {
@ -3065,7 +3065,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);
}

20
scene/main/viewport.cpp
View file

@ -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();

2
scene/resources/animation.cpp
View file

@ -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;

4
scene/resources/bit_mask.cpp
View file

@ -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;

2
scene/resources/capsule_shape_2d.cpp
View file

@ -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;
}

2
scene/resources/circle_shape_2d.cpp
View file

@ -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;
}

2
scene/resources/concave_polygon_shape_2d.cpp
View file

@ -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]);
}

2
scene/resources/convex_polygon_shape_2d.cpp
View file

@ -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]);
}

8
scene/resources/default_theme/default_theme.cpp
View file

@ -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]);

8
scene/resources/font.cpp
View file

@ -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"))

2
scene/resources/polygon_path_finder.cpp
View file

@ -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);
}

6
scene/resources/segment_shape_2d.cpp
View file

@ -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;

2
scene/resources/shape_line_2d.cpp
View file

@ -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]);

26
scene/resources/style_box.cpp
View file

@ -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 {

38
scene/resources/texture.cpp
View file

@ -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);
}
}

8
scene/resources/world_2d.cpp
View file

@ -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;

12
servers/physics_2d/broad_phase_2d_hash_grid.cpp
View file

@ -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++) {

2
servers/physics_2d/collision_object_2d_sw.cpp
View file

@ -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);

2
servers/physics_2d/collision_solver_2d_sw.cpp
View file

@ -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;
}

16
servers/physics_2d/shape_2d_sw.cpp
View file

@ -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;

4
servers/physics_2d/shape_2d_sw.h
View file

@ -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);
}
};

14
servers/physics_2d/space_2d_sw.cpp
View file

@ -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);

8
servers/visual/rasterizer.h
View file

@ -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: {

6
servers/visual/visual_server_canvas.cpp
View file

@ -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]);
}

2
servers/visual/visual_server_viewport.cpp
View file

@ -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()) {

2
servers/visual_server.cpp
View file

@ -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];