asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

mono: add Abs() to Rect2 and rename private fields

Browse source
This commit is contained in:
Kelly Thomas 2018-08-19 11:46:12 +08:00
parent c93888ae71
commit 792a8446ac
1 changed files with 64 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
modules/mono/glue/cs_files/Rect2.cs
View file

@ -11,24 +11,24 @@ namespace Godot
[StructLayout(LayoutKind.Sequential)]
public struct Rect2 : IEquatable<Rect2>
{
private Vector2 position;
private Vector2 size;
private Vector2 _position;
private Vector2 _size;
public Vector2 Position
{
get { return position; }
set { position = value; }
get { return _position; }
set { _position = value; }
}
public Vector2 Size
{
get { return size; }
set { size = value; }
get { return _size; }
set { _size = value; }
}
public Vector2 End
{
get { return position + size; }
get { return _position + _size; }
}
public real_t Area
@ -36,6 +36,13 @@ namespace Godot
get { return GetArea(); }
}
public Rect2 Abs()
{
Vector2 end = End;
Vector2 topLeft = new Vector2(Mathf.Min(_position.x, end.x), Mathf.Min(_position.y, end.y));
return new Rect2(topLeft, _size.Abs());
}
public Rect2 Clip(Rect2 b)
{
var newRect = b;
@ -43,31 +50,31 @@ namespace Godot
if (!Intersects(newRect))
return new Rect2();
newRect.position.x = Mathf.Max(b.position.x, position.x);
newRect.position.y = Mathf.Max(b.position.y, position.y);
newRect._position.x = Mathf.Max(b._position.x, _position.x);
newRect._position.y = Mathf.Max(b._position.y, _position.y);
Vector2 bEnd = b.position + b.size;
Vector2 end = position + size;
Vector2 bEnd = b._position + b._size;
Vector2 end = _position + _size;
newRect.size.x = Mathf.Min(bEnd.x, end.x) - newRect.position.x;
newRect.size.y = Mathf.Min(bEnd.y, end.y) - newRect.position.y;
newRect._size.x = Mathf.Min(bEnd.x, end.x) - newRect._position.x;
newRect._size.y = Mathf.Min(bEnd.y, end.y) - newRect._position.y;
return newRect;
}
public bool Encloses(Rect2 b)
{
return b.position.x >= position.x && b.position.y >= position.y &&
b.position.x + b.size.x < position.x + size.x &&
b.position.y + b.size.y < position.y + size.y;
return b._position.x >= _position.x && b._position.y >= _position.y &&
b._position.x + b._size.x < _position.x + _size.x &&
b._position.y + b._size.y < _position.y + _size.y;
}
public Rect2 Expand(Vector2 to)
{
var expanded = this;
Vector2 begin = expanded.position;
Vector2 end = expanded.position + expanded.size;
Vector2 begin = expanded._position;
Vector2 end = expanded._position + expanded._size;
if (to.x < begin.x)
begin.x = to.x;
@ -79,25 +86,25 @@ namespace Godot
if (to.y > end.y)
end.y = to.y;
expanded.position = begin;
expanded.size = end - begin;
expanded._position = begin;
expanded._size = end - begin;
return expanded;
}
public real_t GetArea()
{
return size.x * size.y;
return _size.x * _size.y;
}
public Rect2 Grow(real_t by)
{
var g = this;
g.position.x -= by;
g.position.y -= by;
g.size.x += by * 2;
g.size.y += by * 2;
g._position.x -= by;
g._position.y -= by;
g._size.x += by * 2;
g._size.y += by * 2;
return g;
}
@ -106,10 +113,10 @@ namespace Godot
{
var g = this;
g.position.x -= left;
g.position.y -= top;
g.size.x += left + right;
g.size.y += top + bottom;
g._position.x -= left;
g._position.y -= top;
g._size.x += left + right;
g._size.y += top + bottom;
return g;
}
@ -128,19 +135,19 @@ namespace Godot
public bool HasNoArea()
{
return size.x <= 0 || size.y <= 0;
return _size.x <= 0 || _size.y <= 0;
}
public bool HasPoint(Vector2 point)
{
if (point.x < position.x)
if (point.x < _position.x)
return false;
if (point.y < position.y)
if (point.y < _position.y)
return false;
if (point.x >= position.x + size.x)
if (point.x >= _position.x + _size.x)
return false;
if (point.y >= position.y + size.y)
if (point.y >= _position.y + _size.y)
return false;
return true;
@ -148,13 +155,13 @@ namespace Godot
public bool Intersects(Rect2 b)
{
if (position.x > b.position.x + b.size.x)
if (_position.x > b._position.x + b._size.x)
return false;
if (position.x + size.x < b.position.x)
if (_position.x + _size.x < b._position.x)
return false;
if (position.y > b.position.y + b.size.y)
if (_position.y > b._position.y + b._size.y)
return false;
if (position.y + size.y < b.position.y)
if (_position.y + _size.y < b._position.y)
return false;
return true;
@ -164,13 +171,13 @@ namespace Godot
{
Rect2 newRect;
newRect.position.x = Mathf.Min(b.position.x, position.x);
newRect.position.y = Mathf.Min(b.position.y, position.y);
newRect._position.x = Mathf.Min(b._position.x, _position.x);
newRect._position.y = Mathf.Min(b._position.y, _position.y);
newRect.size.x = Mathf.Max(b.position.x + b.size.x, position.x + size.x);
newRect.size.y = Mathf.Max(b.position.y + b.size.y, position.y + size.y);
newRect._size.x = Mathf.Max(b._position.x + b._size.x, _position.x + _size.x);
newRect._size.y = Mathf.Max(b._position.y + b._size.y, _position.y + _size.y);
newRect.size = newRect.size - newRect.position; // Make relative again
newRect._size = newRect._size - newRect._position; // Make relative again
return newRect;
}
@ -178,23 +185,23 @@ namespace Godot
// Constructors
public Rect2(Vector2 position, Vector2 size)
{
this.position = position;
this.size = size;
_position = position;
_size = size;
}
public Rect2(Vector2 position, real_t width, real_t height)
{
this.position = position;
size = new Vector2(width, height);
_position = position;
_size = new Vector2(width, height);
}
public Rect2(real_t x, real_t y, Vector2 size)
{
position = new Vector2(x, y);
this.size = size;
_position = new Vector2(x, y);
_size = size;
}
public Rect2(real_t x, real_t y, real_t width, real_t height)
{
position = new Vector2(x, y);
size = new Vector2(width, height);
_position = new Vector2(x, y);
_size = new Vector2(width, height);
}
public static bool operator ==(Rect2 left, Rect2 right)
@ -219,20 +226,20 @@ namespace Godot
public bool Equals(Rect2 other)
{
return position.Equals(other.position) && size.Equals(other.size);
return _position.Equals(other._position) && _size.Equals(other._size);
}
public override int GetHashCode()
{
return position.GetHashCode() ^ size.GetHashCode();
return _position.GetHashCode() ^ _size.GetHashCode();
}
public override string ToString()
{
return String.Format("({0}, {1})", new object[]
{
position.ToString(),
size.ToString()
_position.ToString(),
_size.ToString()
});
}
@ -240,8 +247,8 @@ namespace Godot
{
return String.Format("({0}, {1})", new object[]
{
position.ToString(format),
size.ToString(format)
_position.ToString(format),
_size.ToString(format)
});
}
}