Struct DirtyRegion 

pub struct DirtyRegion {
    pub rect: Rect,
    pub timestamp: Instant,
    pub priority: u8,
    pub component_id: Option<String>,
}

Represents a dirty region that needs re-rendering.

Dirty regions are rectangular areas marked for update due to content changes. The system automatically merges overlapping or adjacent regions to optimize rendering performance and reduce the number of draw calls.

Invariants

• rect.width > 0 && rect.height > 0 - region must have positive area
• priority <= 255 - priority is bounded by u8
• timestamp reflects when the region was created

Memory Layout

Designed to be memory-efficient with total size of ~40 bytes including optional component ID string.

Fields

rect: Rect

The rectangular area that needs updating

timestamp: Instant

When this region was marked dirty

priority: u8

Priority of this update (higher = more urgent)

component_id: Option<String>

Optional component ID that owns this region

Implementations

impl DirtyRegion

pub fn new(rect: Rect) -> Self

Create a new dirty region

pub fn with_priority(rect: Rect, priority: u8) -> Self

Create a dirty region with priority

pub fn with_component(rect: Rect, component_id: String) -> Self

Create a dirty region with component ID

pub fn intersects(&self, other: &Rect) -> bool

Check if this region intersects with another rectangle.

Uses the separating axis theorem: two rectangles intersect if and only if they overlap on both the X and Y axes.

Algorithm

Two rectangles DON’T intersect if:

• Rectangle A is completely to the left of B, OR
• Rectangle A is completely to the right of B, OR
• Rectangle A is completely above B, OR
• Rectangle A is completely below B

Time Complexity

O(1) - constant time with 4 comparisons

Example

use hojicha_rendering::differential::DirtyRegion;
use ratatui::layout::Rect;

let region = DirtyRegion::new(Rect::new(0, 0, 10, 10));
assert!(region.intersects(&Rect::new(5, 5, 10, 10)));  // overlapping
assert!(!region.intersects(&Rect::new(20, 20, 10, 10))); // separate

pub fn try_merge(&mut self, other: &DirtyRegion) -> bool

Merge with another dirty region if they overlap or are adjacent.

This implements the core region coalescing algorithm that reduces the number of separate render operations by combining nearby regions.

Algorithm

1. Check if regions intersect or are adjacent
2. If mergeable, compute bounding rectangle
3. Update metadata (priority, timestamp, component_id)
4. Validate the resulting region

Merge Policy

• Priority: Takes the maximum of both priorities
• Timestamp: Takes the more recent timestamp
• Component ID: Clears if components differ (becomes generic region)

Returns

true if merge occurred, false if regions are not mergeable.

Time Complexity

O(1) - constant time arithmetic operations

Panics

In debug builds, panics if the resulting region would have zero area or if coordinate arithmetic would overflow.

Trait Implementations

impl Clone for DirtyRegion

fn clone(&self) -> DirtyRegion

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DirtyRegion

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for DirtyRegion

fn eq(&self, other: &DirtyRegion) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for DirtyRegion

impl StructuralPartialEq for DirtyRegion