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

//! Hello agpu — minimal standalone application.
//!
//! Demonstrates the Elm-architecture Model/update/view loop with
//! direct painter-based rendering (no widget library needed).
//!
//! Run with: `cargo run --example hello_agpu`

use agpu::prelude::*;

struct App {
    count: i32,
}

#[derive(Debug)]
enum Msg {
    Increment,
    Decrement,
}

impl Model for App {
    type Msg = Msg;

    fn update(&mut self, msg: Msg) -> Command<Msg> {
        match msg {
            Msg::Increment => self.count += 1,
            Msg::Decrement => self.count -= 1,
        }
        Command::None
    }

    fn view(&self, frame: &mut Frame<'_>) {
        let area = frame.area;
        let btn_y = area.y + 50.0;
        let dec_rect = Rect::new(area.x + 10.0, btn_y, 80.0, 36.0);
        let inc_rect = Rect::new(area.x + 100.0, btn_y, 80.0, 36.0);

        // Paint everything first
        {
            let style = TextStyle {
                font_size: 24.0,
                color: Color::WHITE,
                ..Default::default()
            };
            let p = frame.painter();

            // Background
            p.fill_rect(area, Color::rgba(0.1, 0.1, 0.12, 1.0), 0.0);

            // Counter label
            p.text(
                Position::new(area.x + 10.0, area.y + 8.0),
                &format!("Count: {}", self.count),
                &style,
            );

            // Decrement button
            p.fill_rect(dec_rect, Color::rgba(0.8, 0.2, 0.2, 1.0), 4.0);
            p.text(
                Position::new(dec_rect.x + 30.0, dec_rect.y + 6.0),
                "−",
                &style,
            );

            // Increment button
            p.fill_rect(inc_rect, Color::rgba(0.2, 0.6, 0.2, 1.0), 4.0);
            p.text(
                Position::new(inc_rect.x + 30.0, inc_rect.y + 6.0),
                "+",
                &style,
            );
        }

        // Register hitboxes for event routing
        frame.register_hitbox("decrement_btn", dec_rect, 0);
        frame.register_hitbox("increment_btn", inc_rect, 0);
    }

    fn handle_event(&self, event: Event) -> Option<Msg> {
        if let Event::Mouse(me) = &event {
            if let agpu::MouseEventKind::Click(_) = me.kind {
                // Hit-testing handled by the runtime; here we just
                // demonstrate manual event mapping.
                if me.position.y > 50.0 {
                    return if me.position.x < 95.0 {
                        Some(Msg::Decrement)
                    } else {
                        Some(Msg::Increment)
                    };
                }
            }
        }
        None
    }

    fn title(&self) -> &str {
        "agpu — Counter"
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    AgpuApp::new(App { count: 0 })
        .with_options(ProgramOptions {
            width: 400.0,
            height: 200.0,
            ..Default::default()
        })
        .run()
}