raylib 6.0.0

Safe Rust bindings for Raylib.
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

//! Tier-2: `.log_to_rust()` end-to-end under the headless software renderer.
//! Builder installs the bridge BEFORE InitWindow, so raylib's init logging
//! must arrive through the `log` facade with target "raylib".
#![cfg(all(
    feature = "software_renderer",
    feature = "log",
    feature = "SUPPORT_TRACELOG"
))]

use std::sync::Mutex;

struct CaptureLogger {
    records: Mutex<Vec<(log::Level, String, String)>>,
}

impl log::Log for CaptureLogger {
    fn enabled(&self, _: &log::Metadata<'_>) -> bool {
        true
    }
    fn log(&self, record: &log::Record<'_>) {
        self.records.lock().unwrap().push((
            record.level(),
            record.target().to_string(),
            record.args().to_string(),
        ));
    }
    fn flush(&self) {}
}

static LOGGER: CaptureLogger = CaptureLogger {
    records: Mutex::new(Vec::new()),
};

// One #[test] per file: InitWindow is once-per-process (same rule as the
// other Tier-2 files; nextest gives per-test process isolation).
#[test]
fn builder_log_to_rust_bridges_init_logs() {
    log::set_logger(&LOGGER).expect(
        "another logger is already installed in this process — run via cargo nextest (per-test process isolation)"
    );
    log::set_max_level(log::LevelFilter::Trace);

    let (_rl, _thread) = raylib::init()
        .size(64, 64)
        .title("log-bridge")
        .log_to_rust()
        .build();

    let records = LOGGER.records.lock().unwrap();
    assert!(
        records
            .iter()
            .any(|(_, target, msg)| target == "raylib" && msg.contains("Initializing raylib")),
        "expected raylib's init log line via the bridge; got {} records: {:?}",
        records.len(),
        records.iter().take(5).collect::<Vec<_>>(),
    );
}