nsi-ffi-wrap 0.9.0

FFI wrapper and macro for NSI-compliant renderers – ɴsɪ.
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

//! Test to verify the callback memory management fix

use nsi_ffi_wrap as nsi;
use std::sync::{Arc, Mutex};

#[test]
fn simple_callback() {
    let counter = Arc::new(Mutex::new(0));
    let counter_clone = Arc::clone(&counter);

    {
        let ctx =
            nsi::Context::new(None).expect("Could not create NSI context");

        // Minimal scene - need camera for valid output
        ctx.create("camera", nsi::PERSPECTIVE_CAMERA, None);
        ctx.connect("camera", None, nsi::ROOT, "objects", None);

        ctx.create("screen", nsi::SCREEN, None);
        ctx.connect("screen", None, "camera", "screens", None);
        ctx.set_attribute(
            "screen",
            &[nsi::i32_slice!("resolution", &[32, 32]).array_len(2)],
        );

        ctx.create("beauty", nsi::OUTPUT_LAYER, None);
        ctx.set_attribute(
            "beauty",
            &[
                nsi::string!("variablename", "Ci"),
                nsi::string!("scalarformat", "float"),
            ],
        );
        ctx.connect("beauty", None, "screen", "outputlayers", None);

        // Test finish callback - note: FnFinish no longer receives pixel data
        let finish = nsi::output::FinishCallback::new(
            move |_name: String,
                  _width: usize,
                  _height: usize,
                  _fmt: nsi::output::PixelFormat| {
                *counter_clone.lock().unwrap() += 1;
                println!("Finish callback called!");
                nsi::output::Error::None
            },
        );

        ctx.create("driver", nsi::OUTPUT_DRIVER, None);
        ctx.connect("driver", None, "beauty", "outputdrivers", None);
        ctx.set_attribute(
            "driver",
            &[
                nsi::string!("drivername", nsi::output::FERRIS_F32),
                nsi::string!("imagefilename", "test"),
                nsi::callback!("callback.finish", finish),
            ],
        );

        println!("Starting render...");
        ctx.render_control(nsi::Action::Start, None);
        ctx.render_control(nsi::Action::Wait, None);
        println!("Render complete");
    }

    // Check callback was called
    let count = *counter.lock().unwrap();
    println!("Callback was called {} times", count);
    assert!(count > 0, "Callback was not called");
}