rayengine 0.0.1

A small Linux-first Rust game SDK over raylib
Documentation
use super::*;
use std::cell::Cell;

fn triangle() -> MeshData {
    MeshData::new(vec![
        Vec3::new(-1.0, -1.0, 0.0),
        Vec3::new(1.0, -1.0, 0.0),
        Vec3::new(0.0, 1.0, 0.0),
    ])
}
fn request(tag: u32, revision: u64) -> MeshUpload<u32> {
    MeshUpload {
        tag,
        revision,
        target: MeshUploadTarget::Create,
        data: triangle(),
    }
}
fn unlimited() -> UploadBudget {
    UploadBudget {
        max_requests: usize::MAX,
        max_bytes: usize::MAX,
        max_time: Duration::MAX,
    }
}
fn reject_upload(_: MeshUploadTarget, _: &MeshData) -> Result<MeshId, Error> {
    Err(Error::Asset("test upload failure".into()))
}

#[test]
fn admission_bounds_count_capacity_bytes_and_retains_rejected_payloads() {
    let mut queue = MeshUploadQueue::new(2, 72).unwrap();
    queue.try_push(request(1, 0)).unwrap();
    queue.try_push(request(2, 0)).unwrap();
    let rejected = queue.try_push(request(3, 0)).unwrap_err();
    assert_eq!(rejected.reason, MeshQueueError::Full);
    assert_eq!(rejected.request.tag, 3);
    assert_eq!(
        (
            queue.len(),
            queue.pending_bytes(),
            queue.front_upload_bytes()
        ),
        (2, 72, Some(60))
    );
    assert_eq!(queue.pop().unwrap().tag, 1);
    queue.try_push(rejected.request).unwrap();
    assert_eq!(queue.pop().unwrap().tag, 2);
    assert_eq!(queue.pop().unwrap().tag, 3);
    assert!(queue.is_empty());
    assert_eq!(queue.pending_bytes(), 0);

    let mut large = request(4, 0);
    large.data.positions.reserve(100);
    let rejected = queue.try_push(large).unwrap_err();
    assert_eq!(rejected.reason, MeshQueueError::MemoryLimit);
    assert_eq!(rejected.request.data.positions.len(), 3);
    let mut invalid = request(5, 0);
    invalid.data.positions.pop();
    assert!(matches!(
        queue.try_push(invalid).unwrap_err().reason,
        MeshQueueError::InvalidMesh(MeshError::IncompleteTriangle)
    ));
    assert!(MeshUploadQueue::<()>::new(0, 1).is_err());
    assert!(MeshUploadQueue::<()>::new(1, 0).is_err());
}

#[test]
fn stale_discards_and_failures_count_against_request_budget_and_bytes_include_uv_fallback() {
    let mut queue = MeshUploadQueue::new(3, 108).unwrap();
    for revision in 0..3 {
        queue.try_push(request(1, revision)).unwrap();
    }
    let mut outcomes = Vec::new();
    let first = queue.process_with_clock(
        UploadBudget {
            max_requests: 1,
            ..unlimited()
        },
        |_, revision| revision > 0,
        |_, _| panic!("stale request uploaded"),
        |result| outcomes.push(result),
        || Duration::ZERO,
    );
    assert_eq!(
        (
            first.processed,
            first.discarded,
            first.attempted,
            first.bytes,
            first.remaining
        ),
        (1, 1, 0, 0, 2)
    );
    assert!(matches!(outcomes[0].outcome, MeshUploadOutcome::Stale));
    let second = queue.process_with_clock(
        UploadBudget {
            max_bytes: 60,
            ..unlimited()
        },
        |_, _| true,
        reject_upload,
        |result| outcomes.push(result),
        || Duration::ZERO,
    );
    assert_eq!(
        (
            second.processed,
            second.attempted,
            second.failed,
            second.bytes,
            second.remaining,
            second.blocked_upload_bytes
        ),
        (1, 1, 1, 60, 1, Some(60))
    );
    assert!(matches!(outcomes[1].outcome, MeshUploadOutcome::Failed(_)));
    assert_eq!(queue.pending_bytes(), 36);
}

#[test]
fn byte_time_and_zero_budgets_retain_requests_without_oversized_uploads() {
    let mut queue = MeshUploadQueue::new(2, 72).unwrap();
    queue.try_push(request(1, 0)).unwrap();
    queue.try_push(request(2, 0)).unwrap();
    for budget in [
        UploadBudget {
            max_requests: 0,
            ..unlimited()
        },
        UploadBudget {
            max_time: Duration::ZERO,
            ..unlimited()
        },
        UploadBudget {
            max_bytes: 59,
            ..unlimited()
        },
    ] {
        let report = queue.process_with_clock(
            budget,
            |_, _| true,
            |_, _| panic!("budget exceeded"),
            |_| panic!("unexpected result"),
            || Duration::ZERO,
        );
        assert_eq!((report.processed, report.remaining), (0, 2));
    }
    let clock = Cell::new(Duration::ZERO);
    let report = queue.process_with_clock(
        UploadBudget {
            max_time: Duration::from_millis(2),
            ..unlimited()
        },
        |_, _| true,
        |target, data| {
            clock.set(Duration::from_millis(3));
            reject_upload(target, data)
        },
        |_| {},
        || clock.get(),
    );
    assert_eq!(
        (
            report.processed,
            report.failed,
            report.remaining,
            report.elapsed
        ),
        (1, 1, 1, Duration::from_millis(3))
    );
}

#[test]
fn gpu_accounting_includes_all_supplied_buffers() {
    let mut data = triangle();
    data.normals = Some(vec![Vec3::Z; 3]);
    data.texcoords = Some(vec![Vec2::ZERO; 3]);
    data.colors = Some(vec![[255; 4]; 3]);
    data.indices = Some(vec![0, 1, 2]);
    assert_eq!(byte_counts(&data), Ok((114, 114)));
}

#[test]
#[ignore = "requires native OpenGL; scripts/native_smoke.sh runs serially"]
fn native_upload_budget_smoke() {
    use crate::{prelude::*, raylib::prelude::*};
    use rayengine_core::jobs::{JobOutcome, JobPool};
    struct Probe {
        mesh: Option<MeshId>,
        created: Option<MeshId>,
        queue: MeshUploadQueue<u32>,
    }
    fn camera() -> rayengine_core::camera::Camera3D {
        rayengine_core::camera::Camera3D {
            position: Vec3::new(0.0, 0.0, 6.0),
            target: Vec3::ZERO,
            up: Vec3::Y,
            vertical_fov: 60.0,
        }
    }
    fn pixel(frame: &Frame<'_, '_>, x: f32) -> Color {
        let mut image = frame.target.texture().load_image().unwrap();
        image.flip_vertical();
        let scale = image.height as f32 / (2.0 * 30_f32.to_radians().tan() * 6.0);
        image.get_color(
            (image.width as f32 * 0.5 + x * scale) as i32,
            image.height / 2,
        )
    }
    impl Game for Probe {
        fn init(&mut self, ctx: &mut InitContext<'_, '_>) -> Result<(), Error> {
            self.mesh = Some(ctx.mesh(&triangle())?);
            let pool = JobPool::new(2, 3).unwrap();
            for revision in 1..=3 {
                pool.try_submit(move |_| {
                    let mut data = triangle();
                    if revision == 2 {
                        for vertex in &mut data.positions {
                            vertex.x += 0.75;
                        }
                    }
                    if revision == 3 {
                        for vertex in &mut data.positions {
                            vertex.x += 3.0;
                        }
                    }
                    (revision, data)
                })
                .unwrap();
            }
            let deadline = Instant::now() + Duration::from_secs(3);
            let mut generated = Vec::new();
            while generated.len() < 3 {
                if let Some(completion) = pool.try_recv() {
                    if let JobOutcome::Ready(result) = completion.outcome {
                        generated.push(result);
                    } else {
                        panic!("CPU mesh generation failed");
                    }
                }
                assert!(Instant::now() < deadline, "CPU generation timed out");
                std::thread::yield_now();
            }
            generated.sort_unstable_by_key(|result| result.0);
            for (revision, data) in generated {
                self.queue
                    .try_push(MeshUpload {
                        tag: if revision == 3 { 1 } else { 0 },
                        revision,
                        target: if revision == 3 {
                            MeshUploadTarget::Create
                        } else {
                            MeshUploadTarget::Replace(self.mesh.unwrap())
                        },
                        data,
                    })
                    .unwrap();
            }
            Ok(())
        }
        fn fixed_update(&mut self, _: &mut Update<'_, '_>) {}
        fn draw(&mut self, frame: &mut Frame<'_, '_>) {
            let budget = UploadBudget {
                max_requests: 1,
                max_bytes: if frame.index == 1 { 59 } else { 60 },
                max_time: Duration::MAX,
            };
            let mut results = Vec::new();
            let report = frame.upload_meshes(
                &mut self.queue,
                budget,
                |tag, revision| *tag == 1 || revision == 2,
                |result| results.push(result),
            );
            match frame.index {
                0 => assert_eq!(
                    (report.discarded, report.attempted, report.remaining),
                    (1, 0, 2)
                ),
                1 => assert_eq!(
                    (
                        report.attempted,
                        report.blocked_upload_bytes,
                        report.remaining
                    ),
                    (0, Some(60), 2)
                ),
                2 => {
                    assert_eq!(
                        (report.uploaded, report.bytes, report.remaining),
                        (1, 60, 1)
                    );
                    let MeshUploadOutcome::Uploaded(id) = results[0].outcome else {
                        panic!("replacement failed")
                    };
                    assert_eq!(Some(id), self.mesh);
                }
                3 => {
                    assert_eq!((report.uploaded, report.remaining), (1, 0));
                    let MeshUploadOutcome::Uploaded(id) = results[0].outcome else {
                        panic!("creation failed")
                    };
                    self.created = Some(id);
                }
                4 => {
                    frame.assets.unload_mesh(self.created.unwrap());
                    self.queue
                        .try_push(MeshUpload {
                            tag: 1,
                            revision: 4,
                            target: MeshUploadTarget::Replace(self.created.unwrap()),
                            data: triangle(),
                        })
                        .unwrap();
                }
                5 => {
                    assert_eq!((report.failed, report.attempted, report.bytes), (1, 1, 60));
                    assert!(matches!(results[0].outcome, MeshUploadOutcome::Failed(_)));
                }
                _ => unreachable!(),
            }
            frame.clear(Color::BLACK);
            let index = frame.index;
            frame.world_3d(camera(), |canvas| {
                assert!(canvas.mesh(
                    self.mesh.unwrap(),
                    Transform3D::default(),
                    if index < 2 { Color::BLUE } else { Color::GREEN }
                ));
                if index == 3 {
                    assert!(canvas.mesh(self.created.unwrap(), Transform3D::default(), Color::RED));
                }
            });
            assert_eq!(
                pixel(frame, if index < 2 { 0.0 } else { 0.75 }),
                if frame.index < 2 {
                    Color::BLUE
                } else {
                    Color::GREEN
                }
            );
            if index >= 2 {
                assert_eq!(pixel(frame, 0.0), Color::BLACK);
            }
            if frame.index == 3 {
                assert_eq!(pixel(frame, 3.0), Color::RED);
            }
        }
    }
    let mut config = Config::new("budgeted CPU mesh uploads");
    config.window_size = (960, 540);
    config.vsync = false;
    App::new(config)
        .with_options(RunOptions {
            frames: Some(6),
            hidden: true,
            uncapped: true,
            ..RunOptions::default()
        })
        .run(Probe {
            mesh: None,
            created: None,
            queue: MeshUploadQueue::new(3, 1024).unwrap(),
        })
        .unwrap();
}