aga 2.0.0

AgenticGraphicsAcceleration — standalone agentic-first GPU rendering backend; wgpu replacement with Vulkan, OpenGL, and complete ontology
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Grid layout — 2D grid with row/column spans and gap spacing.

use crate::core::Rect;
use crate::layout::{DesiredSize, Layout, SizeConstraints};

/// Span configuration for a grid item.
#[derive(Debug, Clone, Copy)]
pub struct GridSpan {
    pub col_span: usize,
    pub row_span: usize,
}

impl Default for GridSpan {
    fn default() -> Self {
        Self {
            col_span: 1,
            row_span: 1,
        }
    }
}

/// Per-child grid placement.
#[derive(Debug, Clone)]
pub struct GridItem {
    pub index: usize,
    pub span: GridSpan,
}

impl GridItem {
    pub fn new(index: usize) -> Self {
        Self {
            index,
            span: GridSpan::default(),
        }
    }

    pub fn col_span(mut self, span: usize) -> Self {
        self.span.col_span = span;
        self
    }

    pub fn row_span(mut self, span: usize) -> Self {
        self.span.row_span = span;
        self
    }
}

/// A 2D grid layout with configurable columns, rows, and gaps.
pub struct GridLayout {
    columns: usize,
    rows: usize,
    gap: f32,
    items: Vec<GridItem>,
}

impl GridLayout {
    pub fn new(columns: usize, rows: usize) -> Self {
        Self {
            columns: columns.max(1),
            rows: rows.max(1),
            gap: 0.0,
            items: Vec::new(),
        }
    }

    pub fn gap(mut self, gap: f32) -> Self {
        self.gap = gap;
        self
    }

    pub fn item(mut self, item: GridItem) -> Self {
        self.items.push(item);
        self
    }
}

impl Layout for GridLayout {
    fn measure(&self, children: &[DesiredSize], constraints: SizeConstraints) -> DesiredSize {
        if children.is_empty() {
            return DesiredSize::zero();
        }
        let max_child_w = children.iter().map(|c| c.width).fold(0.0f32, f32::max);
        let max_child_h = children.iter().map(|c| c.height).fold(0.0f32, f32::max);

        let total_w =
            max_child_w * self.columns as f32 + self.gap * (self.columns as f32 - 1.0).max(0.0);
        let total_h = max_child_h * self.rows as f32 + self.gap * (self.rows as f32 - 1.0).max(0.0);

        let (w, h) = constraints.clamp(total_w, total_h);
        DesiredSize::new(w, h)
    }

    fn arrange(&self, children: &[DesiredSize], area: Rect) -> Vec<Rect> {
        if children.is_empty() {
            return vec![];
        }

        let col_w =
            (area.width - self.gap * (self.columns as f32 - 1.0).max(0.0)) / self.columns as f32;
        let row_h = (area.height - self.gap * (self.rows as f32 - 1.0).max(0.0)) / self.rows as f32;

        // If we have explicit items, use them for span info
        if !self.items.is_empty() {
            return self.arrange_with_items(children, area, col_w, row_h);
        }

        // Default: fill row-by-row, each child gets one cell
        let mut rects = Vec::with_capacity(children.len());
        for (i, _child) in children.iter().enumerate() {
            let col = i % self.columns;
            let row = i / self.columns;
            let x = area.x + col as f32 * (col_w + self.gap);
            let y = area.y + row as f32 * (row_h + self.gap);
            rects.push(Rect::new(x, y, col_w, row_h));
        }
        rects
    }
}

impl GridLayout {
    fn arrange_with_items(
        &self,
        children: &[DesiredSize],
        area: Rect,
        col_w: f32,
        row_h: f32,
    ) -> Vec<Rect> {
        let mut rects = Vec::with_capacity(children.len());
        let mut col = 0usize;
        let mut row = 0usize;

        for (i, _child) in children.iter().enumerate() {
            let span = self
                .items
                .iter()
                .find(|it| it.index == i)
                .map(|it| it.span)
                .unwrap_or_default();

            let cs = span.col_span.min(self.columns - col);
            let rs = span.row_span.min(self.rows - row);

            let x = area.x + col as f32 * (col_w + self.gap);
            let y = area.y + row as f32 * (row_h + self.gap);
            let w = col_w * cs as f32 + self.gap * (cs as f32 - 1.0).max(0.0);
            let h = row_h * rs as f32 + self.gap * (rs as f32 - 1.0).max(0.0);

            rects.push(Rect::new(x, y, w, h));

            col += cs;
            if col >= self.columns {
                col = 0;
                row += 1;
            }
        }
        rects
    }
}