spout-rs 0.1.3

Rust bindings for Spout2 — GPU texture sharing on Windows
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

#include "spout_bridge.h"
#include <string>

// SpoutSenderBridge

void SpoutSenderBridge::set_sender_name(rust::Str name) {
    inner.SetSenderName(std::string(name).c_str());
}

bool SpoutSenderBridge::send_texture(uint32_t tex_id, uint32_t target,
                                     uint32_t width, uint32_t height,
                                     bool invert, uint32_t host_fbo) {
    return inner.SendTexture(
        static_cast<GLuint>(tex_id),
        static_cast<GLuint>(target),
        width, height, invert,
        static_cast<GLuint>(host_fbo)
    );
}

bool SpoutSenderBridge::send_image(rust::Slice<const uint8_t> pixels,
                                   uint32_t width, uint32_t height,
                                   uint32_t gl_format, bool invert, uint32_t host_fbo) {
    return inner.SendImage(
        pixels.data(), width, height,
        static_cast<GLenum>(gl_format), invert,
        static_cast<GLuint>(host_fbo)
    );
}

void SpoutSenderBridge::release_sender() {
    inner.ReleaseSender();
}

bool SpoutSenderBridge::is_initialized() {
    return inner.IsInitialized();
}

rust::String SpoutSenderBridge::get_name() {
    return rust::String(inner.GetName());
}

uint32_t SpoutSenderBridge::get_width() {
    return inner.GetWidth();
}

uint32_t SpoutSenderBridge::get_height() {
    return inner.GetHeight();
}

void SpoutSenderBridge::hold_fps(int32_t fps) {
    inner.HoldFps(fps);
}

// SpoutReceiverBridge

void SpoutReceiverBridge::set_receiver_name(rust::Str name) {
    inner.SetReceiverName(std::string(name).c_str());
}

bool SpoutReceiverBridge::receive_texture(uint32_t tex_id, uint32_t target,
                                          bool invert, uint32_t host_fbo) {
    return inner.ReceiveTexture(
        static_cast<GLuint>(tex_id),
        static_cast<GLuint>(target),
        invert,
        static_cast<GLuint>(host_fbo)
    );
}

bool SpoutReceiverBridge::receive_texture_connect() {
    return inner.ReceiveTexture();
}

void SpoutReceiverBridge::release_receiver() {
    inner.ReleaseReceiver();
}

bool SpoutReceiverBridge::is_updated() {
    return inner.IsUpdated();
}

bool SpoutReceiverBridge::is_connected() {
    return inner.IsConnected();
}

bool SpoutReceiverBridge::is_frame_new() {
    return inner.IsFrameNew();
}

rust::String SpoutReceiverBridge::get_sender_name() {
    return rust::String(inner.GetSenderName());
}

uint32_t SpoutReceiverBridge::get_sender_width() {
    return inner.GetSenderWidth();
}

uint32_t SpoutReceiverBridge::get_sender_height() {
    return inner.GetSenderHeight();
}

double SpoutReceiverBridge::get_sender_fps() {
    return inner.GetSenderFps();
}

long SpoutReceiverBridge::get_sender_frame() {
    return inner.GetSenderFrame();
}

// Directory

int32_t spout_sender_count() {
    SpoutSender s;
    return s.GetSenderCount();
}

rust::String spout_get_sender(int32_t index) {
    SpoutSender s;
    char name[256] = {};
    s.GetSender(index, name, sizeof(name));
    return rust::String(name);
}

// Factory functions

std::unique_ptr<SpoutSenderBridge> new_spout_sender() {
    return std::make_unique<SpoutSenderBridge>();
}

std::unique_ptr<SpoutReceiverBridge> new_spout_receiver() {
    return std::make_unique<SpoutReceiverBridge>();
}