Rect2

public Rect2(Vector2 position, Vector2 size);

Constructs the rectangle from Position and full Size, not two corners. Stores values directly without normalizing negative extents. default(Rect2) has zero position and size.

public Rect2(Vector2 position, float width, float height);

Constructs the rectangle from Position and full Size, not two corners. Stores values directly without normalizing negative extents. default(Rect2) has zero position and size.

public Rect2(float x, float y, Vector2 size);

Constructs the rectangle from Position and full Size, not two corners. Stores values directly without normalizing negative extents. default(Rect2) has zero position and size.

public Rect2(float x, float y, float width, float height);

Constructs the rectangle from Position and full Size, not two corners. Stores values directly without normalizing negative extents. default(Rect2) has zero position and size.

public float Area { get; }

Computes Size.X * Size.Y without normalization. Two negative extents also produce a positive product; use HasArea() to require positive extents.

public Vector2 End { get; set; }

Ending corner, Position + Size. Assignment changes Size to value - Position without moving Position. HasPoint() excludes the right and bottom boundaries at these coordinates.

public Vector2 Position { get; set; }

Starting corner. Assignment preserves Size and shifts End by the same amount. The calling code determines the coordinate system.

public Vector2 Size { get; set; }

Full width and height: End = Position + Size. Assignment preserves Position. Negative components are not corrected; use Abs() to normalize them.

public Rect2 Abs();

Returns a copy with Position set to the componentwise minimum of the original Position and End, and Size to the absolute original Size. Zero extents remain zero. The original is unchanged.

public bool Encloses(Rect2 b);

Tests complete containment of b Position and End with inclusive bounds. An equal rectangle is enclosed; a zero rectangle on End can also be enclosed even though HasPoint(End) is false. These are distinct tests. Use nonnegative extents for both rectangles.

public bool Equals(Rect2 other);

Compares Position and Size exactly, without normalization, tolerance or an overlap test. A NaN component does not equal its copy; +0 and -0 are equal.

public override bool Equals(object? obj);

Compares Position and Size exactly, without normalization, tolerance or an overlap test. For obj, accepts only a boxed Rect2; null and other types return false. A NaN component does not equal its copy; +0 and -0 are equal.

public Rect2 Expand(Vector2 to);

Returns the smallest copy whose bounds cover the original bounds and to. A point expanding the right or bottom side becomes part of End and remains excluded by HasPoint(). No padding is added automatically. If the point must lie strictly inside, provide the required padding explicitly.

public Vector2 GetCenter();

Computes Position + Size * 0.5f in rectangle coordinates. Odd extents retain fractional halves; does not apply an object Transform2D.

public override int GetHashCode();

Returns HashCode.Combine(Position, Size). Exactly equal values have equal hashes, but a hash match does not prove equality. By default, Dictionary<Rect2, T> uses exact Equals(), not approximate comparison. Do not persist the hash as an identifier or checksum across runs.

public Vector2 GetSupport(Vector2 direction);

Selects a corner of the closed bounds: a positive direction component selects the corresponding End component; otherwise it selects Position. No normalization is needed; zero direction returns Position. A corner on End can be excluded by HasPoint() while still being the support point.

public Rect2 Grow(float by);

Returns a copy with Position - Vector2.One * by and Size + Vector2.One * (2 * by). Padding applies to each of four sides, not once to the full size. Negative padding shrinks the region. Shrinking is not clamped at zero: excessive shrinking creates negative Size.

public Rect2 GrowIndividual(float left, float top, float right, float bottom);

Returns a copy with Position = Position - (left, top) and Size = Size + (left + right, top + bottom). Argument order is left, top, right, bottom. Negative padding shrinks the region. Shrinking is not clamped at zero: excessive shrinking creates negative Size.

public Rect2 GrowSide(Side side, float by);

Returns a copy changing only Side.Left, Side.Top, Side.Right or Side.Bottom. Left and top growth also changes Position. An unknown Side value leaves the copy unchanged. Negative padding shrinks the region. Shrinking is not clamped at zero: excessive shrinking creates negative Size.

public bool HasArea();

Returns Size.X > 0 && Size.Y > 0. This checks positive extents; Area > 0 is not equivalent when components are negative.

public bool HasPoint(Vector2 point);

For finite coordinates: Tests Position.X <= point.X < End.X and Position.Y <= point.Y < End.Y. Left and top borders are included; right and bottom are excluded. A zero width or height contains no points. Call Abs() first for negative Size. NaN is not automatically rejected and can make this method return true for the point. Check IsFinite() on the bounds and the input point separately.

public Rect2 Intersection(Rect2 b);

First calls Intersects(b) with its ordinary rules, then clips the common bounds. Separated rectangles and contact alone between positive-size rectangles return default(Rect2), a zero rectangle at the origin. This result does not retain the contact location. Normalize negative extents with Abs() before calling.

public bool Intersects(Rect2 b, bool includeBorders = false);

Tests intervals on X and Y. For positive extents, side- or corner-only contact returns false with includeBorders = false and true with includeBorders = true. Does not call HasArea(): a degenerate rectangle strictly inside another can return true. Both inputs need nonnegative Size and the same coordinate system.

public bool IsEqualApprox(Rect2 other);

Compares Position and Size componentwise using Mathf.IsEqualApprox(). In the current float SDK, exact equality succeeds immediately; otherwise abs(a - b) < max(0.000001, 0.000001 * abs(a)) is required, with a taken from this rectangle. Operand order can affect boundary results; the test is not transitive. It does not replace Dictionary key equality or validate finiteness: equal infinities pass.

public bool IsFinite();

Checks all four Position and Size components for NaN and infinity. Zero or negative extents can be finite: this does not replace HasArea().

public Rect2 Merge(Rect2 b);

Returns the smallest rectangle enclosing both inputs. Any gap between separated regions is also included. Neither input is changed. Both rectangles need nonnegative Size and the same coordinate system.

public override string ToString();

Returns Position.ToString(format) + ", " + Size.ToString(format), with two parenthesized vectors. Numbers use InvariantCulture. This is diagnostic text, not a save format or JSON. Equivalent to ToString(null).

public string ToString(string? format);

Returns Position.ToString(format) + ", " + Size.ToString(format), with two parenthesized vectors. Numbers use InvariantCulture. This is diagnostic text, not a save format or JSON. The format applies to all four components; an invalid format can throw FormatException.

public static bool operator ==(Rect2 left, Rect2 right);

Compares Position and Size exactly, without normalization, tolerance or an overlap test. A NaN component does not equal its copy; +0 and -0 are equal.

public static bool operator !=(Rect2 left, Rect2 right);

Compares Position and Size exactly, without normalization, tolerance or an overlap test. Operator != negates this comparison. A NaN component does not equal its copy; +0 and -0 are equal.