cranpose-render-wgpu 0.1.164

WGPU renderer backend for Cranpose
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

use std::cell::Cell;

use super::*;

#[test]
fn resource_is_created_only_when_first_requested() {
    let resource = LazyGpuResource::new("test");
    let calls = Cell::new(0);
    assert!(resource.get().is_none());

    let first = resource.get_or_init(wgpu::Backend::Gl, || {
        calls.set(calls.get() + 1);
        41
    });
    let second = resource.get_or_init(wgpu::Backend::Gl, || {
        calls.set(calls.get() + 1);
        99
    });

    assert_eq!((*first, *second), (41, 41));
    assert_eq!(calls.get(), 1);
    assert!(resource.get().is_some());
}

#[cfg(not(target_arch = "wasm32"))]
#[test]
fn a_request_during_the_warm_up_waits_for_it_instead_of_creating_twice() {
    use std::{sync::mpsc, time::Duration};

    let compiler = PipelineCompiler::spawn();
    let resource = LazyGpuResource::new("warmed");
    let (started, observed) = mpsc::channel();
    let (release, blocked) = mpsc::channel::<()>();
    resource.warm(&compiler, wgpu::Backend::Gl, move || {
        started.send(()).unwrap();
        blocked.recv().unwrap();
        7
    });
    observed.recv_timeout(Duration::from_secs(5)).unwrap();
    assert!(resource.get().is_none(), "the warm-up is still running");
    let waiter = {
        let resource = resource.clone();
        std::thread::spawn(move || {
            *resource.get_or_init(wgpu::Backend::Gl, || {
                panic!("a second creation ran beside the warm-up")
            })
        })
    };
    std::thread::sleep(Duration::from_millis(50));
    assert!(
        !waiter.is_finished(),
        "the request must wait for the warm-up"
    );
    release.send(()).unwrap();
    assert_eq!(waiter.join().unwrap(), 7);
    assert_eq!(resource.get(), Some(&7));
}

#[test]
fn an_inactive_compiler_leaves_the_resource_to_its_first_use() {
    let compiler = PipelineCompiler::inactive();
    let resource = LazyGpuResource::new("lazy");
    resource.warm(&compiler, wgpu::Backend::Gl, || 3);
    assert!(resource.get().is_none());
    assert_eq!(*resource.get_or_init(wgpu::Backend::Gl, || 4), 4);
}