sfml 0.20.0

Rust binding for sfml
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#include "System/Vector3.h"
#include <SFML/Audio/SoundStream.hpp>
#include <cstddef>
#include <cstdint>

typedef struct
{
    int16_t *samples;         ///< Pointer to the audio samples
    unsigned int sampleCount; ///< Number of samples pointed by Samples
} sfSoundStreamChunk;

typedef bool (*sfSoundStreamGetDataCallback)(sfSoundStreamChunk *, void *); ///< Type of the callback used to get a sound stream data
typedef void (*sfSoundStreamSeekCallback)(int64_t, void *);                 ///< Type of the callback used to seek in a sound stream

// Helper class implementing the callback forwarding from
// C++ to C in sfSoundStream
class sfSoundStream : public sf::SoundStream {
  public:
    sfSoundStream(sfSoundStreamGetDataCallback onGetData,
                  sfSoundStreamSeekCallback onSeek,
                  unsigned int channelCount,
                  unsigned int sampleRate,
                  void *userData) : myGetDataCallback(onGetData),
                                    mySeekCallback(onSeek),
                                    myUserData(userData) {
        initialize(channelCount, sampleRate);
    }

  private:
    virtual bool onGetData(Chunk &data) {
        sfSoundStreamChunk chunk = {NULL, 0};
        bool ok = (myGetDataCallback(&chunk, myUserData));

        data.samples = chunk.samples;
        data.sampleCount = chunk.sampleCount;

        return ok;
    }

    virtual void onSeek(sf::Time timeOffset) {
        if (mySeekCallback) {
            int64_t time = {timeOffset.asMicroseconds()};
            mySeekCallback(time, myUserData);
        }
    }

    sfSoundStreamGetDataCallback myGetDataCallback;
    sfSoundStreamSeekCallback mySeekCallback;
    void *myUserData;
};

extern "C" sfSoundStream *sfSoundStream_create(sfSoundStreamGetDataCallback onGetData,
                                               sfSoundStreamSeekCallback onSeek,
                                               unsigned int channelCount,
                                               unsigned int sampleRate,
                                               void *userData) {
    return new sfSoundStream(onGetData, onSeek, channelCount, sampleRate, userData);
}

extern "C" void sfSoundStream_destroy(sfSoundStream *soundStream) {
    delete soundStream;
}

extern "C" void sfSoundStream_play(sfSoundStream *soundStream) {
    soundStream->play();
}

extern "C" void sfSoundStream_pause(sfSoundStream *soundStream) {
    soundStream->pause();
}

extern "C" void sfSoundStream_stop(sfSoundStream *soundStream) {
    soundStream->stop();
}

extern "C" sf::SoundStream::Status sfSoundStream_getStatus(const sfSoundStream *soundStream) {

    return soundStream->getStatus();
}

extern "C" unsigned int sfSoundStream_getChannelCount(const sfSoundStream *soundStream) {
    return soundStream->getChannelCount();
}

extern "C" unsigned int sfSoundStream_getSampleRate(const sfSoundStream *soundStream) {
    return soundStream->getSampleRate();
}

extern "C" void sfSoundStream_setPitch(sfSoundStream *soundStream, float pitch) {
    soundStream->setPitch(pitch);
}

extern "C" void sfSoundStream_setVolume(sfSoundStream *soundStream, float volume) {
    soundStream->setVolume(volume);
}

extern "C" void sfSoundStream_setPosition(sfSoundStream *soundStream, sfVector3f position) {
    soundStream->setPosition(position.x, position.y, position.z);
}

extern "C" void sfSoundStream_setRelativeToListener(sfSoundStream *soundStream, bool relative) {
    soundStream->setRelativeToListener(relative);
}

extern "C" void sfSoundStream_setMinDistance(sfSoundStream *soundStream, float distance) {
    soundStream->setMinDistance(distance);
}

extern "C" void sfSoundStream_setAttenuation(sfSoundStream *soundStream, float attenuation) {
    soundStream->setAttenuation(attenuation);
}

extern "C" void sfSoundStream_setPlayingOffset(sfSoundStream *soundStream, int64_t timeOffset) {
    soundStream->setPlayingOffset(sf::microseconds(timeOffset));
}

extern "C" void sfSoundStream_setLoop(sfSoundStream *soundStream, bool loop) {
    soundStream->setLoop(loop);
}

extern "C" float sfSoundStream_getPitch(const sfSoundStream *soundStream) {
    return soundStream->getPitch();
}

extern "C" float sfSoundStream_getVolume(const sfSoundStream *soundStream) {
    return soundStream->getVolume();
}

extern "C" sfVector3f sfSoundStream_getPosition(const sfSoundStream *soundStream) {
    sf::Vector3f pos = soundStream->getPosition();
    return {pos.x, pos.y, pos.z};
}

extern "C" bool sfSoundStream_isRelativeToListener(const sfSoundStream *soundStream) {
    return soundStream->isRelativeToListener();
}

extern "C" float sfSoundStream_getMinDistance(const sfSoundStream *soundStream) {
    return soundStream->getMinDistance();
}

extern "C" float sfSoundStream_getAttenuation(const sfSoundStream *soundStream) {
    return soundStream->getAttenuation();
}

extern "C" bool sfSoundStream_getLoop(const sfSoundStream *soundStream) {
    return soundStream->getLoop();
}

extern "C" int64_t sfSoundStream_getPlayingOffset(const sfSoundStream *soundStream) {
    return soundStream->getPlayingOffset().asMicroseconds();
}