Rect2I

public Rect2I(Vector2I position, Vector2I size);

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

public Rect2I(Vector2I position, int width, int height);

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

public Rect2I(int x, int y, Vector2I size);

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

public Rect2I(int x, int y, int width, int height);

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

public int Area { get; }

Computes Size.X * Size.Y without normalization. Two negative extents also produce a positive product; use HasArea() to require positive extents. In the installed SDK, int multiplication can overflow without clamping the result.

public Vector2I 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 Vector2I Position { get; set; }

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

public Vector2I Size { get; set; }

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

public Rect2I 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. A Size component equal to int.MinValue throws OverflowException; also avoid Position + Size overflow.

public bool Encloses(Rect2I 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(Rect2I other);

Compares Position and Size exactly, without normalization, tolerance or an overlap test.

public override bool Equals(object? obj);

Compares Position and Size exactly, without normalization, tolerance or an overlap test. For obj, accepts only a boxed Rect2I; null and other types return false.

public Rect2I Expand(Vector2I 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. To include a whole cell, use Merge(new Rect2I(to, Vector2I.One)), first ensuring to + Vector2I.One cannot overflow.

public Vector2I GetCenter();

Computes Position + Size / 2: first divides Size components using integer division toward zero, then adds Position. For odd positive extents, the result is biased toward Position even at negative coordinates. For example, Position.X = -10 and Size.X = 3 produce -9.

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<Rect2I, T> uses exact Equals(), not approximate comparison. Do not persist the hash as an identifier or checksum across runs.

public Rect2I Grow(int by);

Returns a copy with Position - Vector2I.One * by and Size + Vector2I.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 Rect2I GrowIndividual(int left, int top, int right, int 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 Rect2I GrowSide(Side side, int 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(Vector2I point);

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.

public Rect2I Intersection(Rect2I 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(Rect2I), a zero rectangle at the origin. This result does not retain the contact location. Normalize negative extents with Abs() before calling.

public bool Intersects(Rect2I b);

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

public Rect2I Merge(Rect2I 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 ==(Rect2I left, Rect2I right);

Compares Position and Size exactly, without normalization, tolerance or an overlap test.

public static explicit operator Rect2I(Rect2 value);

Converts Rect2 to Rect2I by truncating Position and Size components independently toward zero. For example, (-1.9, 1.9), (2.9, 3.9) becomes (-1, 1), (2, 3). This neither rounds End nor constructs an enclosing pixel region. Use finite values representable as int.

public static implicit operator Rect2(Rect2I value);

Converts Position and Size from int to float and constructs Rect2. No explicit cast is required, but large integers can lose precision: 16777217 becomes 16777216 in the current float SDK. Converting back need not restore the original coordinates.

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

Compares Position and Size exactly, without normalization, tolerance or an overlap test. Operator != negates this comparison.