Add basic agdk-mainloop example

2026-07-18 12:38:58 +00:00 · 2022-05-09 00:39:55 +01:00
parent 32843ac726
commit 02dda282d0
41 changed files with 980 additions and 1 deletions
@@ -0,0 +1,85 @@
+
+use game_activity::{PollEvent, MainEvent};
+use log::Level;
+use log::trace;
+use std::time::Duration;
+use serde::{Serialize, Deserialize};
+
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AppState {
+    uri: String,
+}
+
+#[no_mangle]
+extern "C" fn android_main() {
+
+    android_logger::init_once(
+        android_logger::Config::default().with_min_level(Level::Trace)
+    );
+
+    let mut quit = false;
+    let mut redraw_pending = true;
+    let mut render_state: Option<()> = Default::default();
+
+    let app = game_activity::android_app();
+    while !quit {
+        app.poll_events(Some(Duration::from_millis(500)) /* timeout */, |event| {
+            match event {
+                PollEvent::Wake => { trace!("Early wake up"); },
+                PollEvent::Timeout => {
+                    trace!("Timed out");
+                    // Real app would probably rely on vblank sync via graphics API...
+                    redraw_pending = true;
+                },
+                PollEvent::Main(main_event) => {
+                    trace!("Main event: {:?}", main_event);
+                    match main_event {
+                        MainEvent::SaveState { saver, .. } => {
+                            let state = serde_json::to_vec(&AppState { uri: format!("foo://bar") }).unwrap();
+                            saver.store(&state);
+                        },
+                        MainEvent::Pause => {},
+                        MainEvent::Resume { loader, .. } => {
+                            if let Some(state) = loader.load() {
+                                let _state: AppState = serde_json::from_slice(&state).unwrap();
+                            }
+                        },
+                        MainEvent::InitWindow { .. } => {
+                            render_state = Some(());
+                            redraw_pending = true;
+                        },
+                        MainEvent::TerminateWindow { .. } => {
+                            render_state = None;
+                        }
+                        MainEvent::WindowResized { .. } => { redraw_pending = true; },
+                        MainEvent::RedrawNeeded { ..} => { redraw_pending = true; },
+                        MainEvent::LowMemory => {},
+
+                        MainEvent::Destroy => { quit = true },
+                        _ => { /* ... */}
+                    }
+                },
+                _ => {}
+            }
+
+            if redraw_pending {
+                if let Some(_rs) = render_state {
+                    redraw_pending = false;
+
+                    // Handle input
+                    if let Some(buf) = app.swap_input_buffers() {
+                        for motion in buf.motion_events_iter() {
+                            trace!("Motion Event: {motion:?}")
+                        }
+                        for key in buf.key_events_iter() {
+                            trace!("Key Event: {key:?}")
+                        }
+                    }
+
+                    // Render...
+                }
+            }
+        });
+    }
+}
@@ -0,0 +1,11 @@
+@vertex
+fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4<f32> {
+    let x = f32(i32(in_vertex_index) - 1);
+    let y = f32(i32(in_vertex_index & 1u) * 2 - 1);
+    return vec4<f32>(x, y, 0.0, 1.0);
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+}