, et retourne
une instance de <?php
class_link("Http::Response", "Http_1_1Response");
?>
.
</p>
<p>
C'est tout pour ce qui est de l'interface de la classe <?php
class_link("Http");
?>
, seulement deux fonctions !
Il n'y a même pas besoin de se déconnecter du serveur, étant donné que c'est fait automatiquement après chaque
appel à <code>SendRequest</code>.
</p>
<?php
h2('Conclusion');
?>
<p>
La classe <?php
class_link("Http");
?>
est un outil puissant pour manipuler le protocole HTTP, et accéder à des pages web
ou à des fichiers via internet.<br/>
Jetons maintenant un oeil à son frère, le
<a class="internal" href="./network-ftp-fr.php" title="Aller au tutoriel suivant">protocole FTP</a>.
</p>
<?php
require "footer-fr.php";
</code></pre>
<p>
Puis, vous pouvez attendre les connexions sur ce port.
</p>
<pre><code class="cpp">sf::IPAddress ClientAddress;
sf::SocketTCP Client;
if (Listener.Accept(Client, &ClientAddress) != sf::Socket::Done)
{
// Erreur...
}
</code></pre>
<p>
La fonction <code>Accept</code> va attendre jusqu'à ce qu'une connexion arrive,
puis renvoyer un nouveau socket qui sera utilisé pour échanger les données avec l'ordinateur
connecté. Si vous passez une instance de <?php
class_link("IPAddress");
?>
à la fonction,
celle-ci sera initialisée avec l'adresse du client (pratique pour savoir qui vient de se connecter).<br/>
Si la socket est en mode non-bloquant, cette fonction rendra la main immédiatement si aucune connexion n'est en attente,
et renverra le code <code>sf::Socket::NotReady</code>.
</p>
<p>
Regardons maintenant comment ça se passe du côté du client. Tout ce que vous avez à faire est créer
un socket puis le connecter au serveur sur le port que ce dernier écoute.
</p>
<pre><code class="cpp">sf::SocketTCP Client;
if (Client.Connect(4567, "192.168.0.2") != sf::Socket::Done)
{
// Erreur...
}
DefaultVisual(Disp, Screen),
0, NULL);
// Et enfin on affiche nos fenêtres fraîchement créées
XMapWindow(Disp, Win);
XMapWindow(Disp, View);
XFlush(Disp);
</code></pre>
<?php
h2('Définition d\'une vue SFML');
?>
<p>
Une fois que tous les composants de l'interface ont été créés, nous pouvons définir notre vue SFML. Pour ce faire,
nous avons juste à construire une instance de <?php
class_link("RenderWindows");
?>
et à lui passer l'identificateur de
la fenêtre X11 :
</p>
<pre><code class="cpp">sf::RenderWindow SFMLView(View);
// Ou, si vous souhaitez le faire après la construction :
SFMLView.Create(View);
</code></pre>
<p>
Et voilà, vous avez une fenêtre de rendu SFML intégrée à votre interface X11.
</p>
<?php
</code></pre>
<p>
Mais revenons à nos moutons : comment une telle transformation peut-elle être appliquée à une entité graphique ? C'est facile : passez-la à la fonction <code>draw</code>.
</p>
<pre><code class="cpp">window.draw(entity, transform);
</code></pre>
<p>
... ce qui est en fait un raccourci pour :
</p>
<pre><code class="cpp">sf::RenderStates states;
states.transform = transform;
window.draw(entity, states);
</code></pre>
<p>
Si votre entité est un <?php
class_link('Transformable');
?>
(sprite, texte, forme), avec sa propre transformation interne, alors les deux sont combinées pour produire
la transformation finale.
</p>
<?php
h2('Boîtes englobantes');
?>
<p>
Après avoir transformé et dessiné vos entités, vous voudrez certainement effectuer certains calculs avec elles, comme par exemple détecter les collisions.
</p>
<p>
Les entités SFML peuvent vous donner leur boîte englobante. La boîte englobante est le rectangle minimal qui contient l'entité, et dont les côtés sont alignés sur
les axes X et Y.
</p>
L'autre solution est d'utiliser des sélecteurs. Les sélecteurs permettent de multiplexer un ensemble
de sockets, sans avoir à faire tourner un autre thread. Ils sont toujours bloquants, mais rendront
la main dès que l'un des sockets est prêt. Les sélecteurs peuvent aussi utiliser une valeur de
<em>timeout</em>, pour éviter d'attendre indéfiniment.
</p>
<?php
h2('Gérer plusieurs clients');
?>
<p>
Il existe deux types de sélecteurs dans la SFML : <?php
class_link("SelectorTCP", "Selector");
?>
(pour les sockets TCP) et
<?php
class_link("SelectorUDP", "Selector");
?>
(pour les sockets UDP). Cependant seul le type de socket diffère, les
fonctions et le comportement sont exactement les mêmes pour les deux classes.
</p>
<p>
Donc, tentons d'utiliser un sélecteur TCP. Ici nous allons construire un serveur qui sera
capable de gérer plusieurs clients à la fois, sans utiliser le moindre thread.
</p>
<pre><code class="cpp">#include <SFML/Network.hpp>
sf::SelectorTCP Selector;
</code></pre>
<p>
Les sélecteurs se comportent comme des tableaux : vous pouvez ajouter (<code>Add</code>) et retirer
(<code>Remove</code>) des sockets, ou encore les vider (<code>Clear</code>). Ici nous allons
</p>
<pre><code class="cpp">unsigned int Seed = 10;
sf::Randomizer::SetSeed(Seed);
</code></pre>
<p>
Vous pouvez également récupérer la graine courante :
</p>
<pre><code class="cpp">unsigned int Seed = sf::Randomizer::GetSeed();
</code></pre>
<?php
h2('Générer des nombres aléatoires dans des intervalles spécifiques');
?>
<p>
<?php
class_link("Randomizer");
?>
fournit deux fonctions pour générer des nombres aléatoires dans des intervalles donnés.
</p>
<p>
La première génère des nombres entiers :
</p>
<pre><code class="cpp">// Renvoie un nombre entier aléatoire entre 0 et 100
int Random = sf::Randomizer::Random(0, 100);
</code></pre>
<p>
Et la seconde génère des flottants :
</p>
<pre><code class="cpp">// Renvoie un nombre réel aléatoire entre -1 et 1
float Random = sf::Randomizer::Random(-1.f, 1.f);
</code></pre>
<p class="important">
Un son ne peut être spatialisé que s'il ne possède qu'un canal, i.e. si c'est un son mono.<br/>
La spatialisation est désactivée pour les sons qui possèdent plus de canaux, étant donné qu'ils donnent déjà explicitement leur utilisation des
haut-parleurs. Il est très important de garder cela en tête.
</p>
<?php
h2('L\'écouteur');
?>
<p>
Tous les sons et musiques de votre environnement audio seront entendus par un acteur unique : l'<em>écouteur</em>. Ce qui est restitué à travers
vos haut-parleurs, c'est ce que l'écouteur entend.
</p>
<p>
La classe qui définit les propriétés de l'écouteur est <?php
class_link("Listener");
?>
. Comme l'écouteur est unique dans l'environnement, cette classe ne
contient que des fonctions statiques et ne doit pas être instanciée.
</p>
<p>
Tout d'abord, vous pouvez modifier la position de l'écouteur dans la scène :
</p>
<pre><code class="cpp">sf::Listener::setPosition(10.f, 0.f, 5.f);
</code></pre>
<p>
Si votre monde est en 2D, vous pouvez utiliser la même valeur Y partout, typiquement 0.
</p>
<p>
En plus de sa position, vous pouvez définir l'orientation de l'écouteur :
</p>
</p>
<?php
h2('Joystick');
?>
<p>
The class that provides access to the joysticks' states is <?php
class_link("Joystick");
?>
. Like the other classes in this tutorial, it only contains static
functions.
</p>
<p>
Joysticks are identified by their index (0 to 7, since SFML supports up to 8 joysticks). Therefore, the first argument of every function of
<?php
class_link("Joystick");
?>
is the index of the joystick that you want to query.
</p>
<p>
You can check whether a joystick is connected or not:
</p>
<pre><code class="cpp">if (sf::Joystick::isConnected(0))
{
// joystick number 0 is connected
...
}
</code></pre>
<p>
You can also get the capabilities of a connected joystick:
</p>
if (response.isOk())
{
const std::vector<std::string>& listing = response.getListing();
for (std::vector<std::string>::const_iterator it = listing.begin(); it != listing.end(); ++it)
std::cout << "- " << *it << std::endl;
}
// you can also get the listing of a sub-directory of the current directory:
response = ftp.getDirectoryListing("subfolder");
</code></pre>
<p>
<?php
class_link("Ftp::ListingResponse");
?>
is a specialized <?php
class_link("Ftp::Response");
?>
that also contains the requested directory/file names.
</p>
<p>
Changing the current directory:
</p>
<pre><code class="cpp">ftp.changeDirectory("path/to/new_directory"); // the given path is relative to the current directory
</code></pre>
<p>
Going to the parent directory of the current one:
</p>
<pre><code class="cpp">ftp.parentDirectory();
</code></pre>
<p>
Creating a new directory (as a child of the current one):
The style parameter can be a combination of the <code>sf::Style</code> flags, which are
<code>None</code>, <code>Titlebar</code>, <code>Resize</code>, <code>Close</code> and <code>Fullscreen</code>. The default style is
<code>Resize | Close</code>.
</p>
<pre><code class="cpp">// This creates a fullscreen window
App.Create(sf::VideoMode(800, 600, 32), "SFML Window", sf::Style::Fullscreen);
</code></pre>
<?php
h2('Video modes');
?>
<p>
In the example above, we don't care about the video mode because we run in windowed mode ; any
size will be ok. But if we'd like to run in fullscreen mode, only a few modes would be allowed.
<?php
class_link("VideoMode");
?>
provides an interface for getting all supported video modes,
with the two static functions <code>GetModesCount</code> and <code>GetMode</code> :
</p>
<pre><code class="cpp">unsigned int VideoModesCount = sf::VideoMode::GetModesCount();
for (unsigned int i = 0; i < VideoModesCount; ++i)
{
sf::VideoMode Mode = sf::VideoMode::GetMode(i);
// Mode is a valid video mode
}
</code></pre>
<p>
Note that video modes are ordered from highest to lowest, so that
<code>sf::VideoMode::GetMode(0)</code> will always
</p>
<p>
It is also possible to get the current playing position, in seconds :
</p>
<pre><code class="cpp">float Position = Sound.GetPlayingOffset();
</code></pre>
<p>
As usual, no cleanup is needed : all audio classes will free their resources automatically.
</p>
<?php
h2('Sound buffers and sounds management');
?>
<p>
You have to be particularly careful when manipulating sound buffers. A <?php
class_link("SoundBuffer");
?>
instance is a resource which is slow to load, heavy to copy and uses a lot of memory.
</p>
<p>
For a good discussion about resource management, I suggest you read the <strong>"Images and sprites management"</strong>
part of the <a class="internal" href="./graphics-sprite.php" title="Sprites tutorial">sprites tutorial</a>, just
replacing the word "Image" with "SoundBuffer" and "Sprite" with "Sound".
</p>
<?php
h2('Conclusion');
?>
<p>
Now that you can play sounds, let's have a look at how to
<a class="internal" href="./audio-music.php" title="Go to the next tutorial">play musics</a>.
sf::Texture texture;
texture.loadFromStream(stream);
</code></pre>
<?php
h2('Common mistakes');
?>
<p>
Some resource classes are not loaded completely after <code>loadFromStream</code> has been called. Instead, they continue to read from their
data source as long as they are used. This is the case for <?php
class_link("Music");
?>
, which streams audio samples as they are played, and for
<?php
class_link("Font");
?>
, which loads glyphs on the fly depending on the text that is displayed.
</p>
<p>
As a consequence, the stream instance that you used to load a music or a font, as well as its data source, must remain alive as long as the resource
uses it. If it is destroyed while still being used, the behaviour is undefined (can be a crash, corrupt data, or nothing visible).
</p>
<p>
Another common mistake is to return whatever the internal functions return directly, but sometimes it doesn't match what SFML expects.
For example, in the FileStream example above, one might be tempted to write the <code>seek</code> function as follows:
</p>
<pre><code class="cpp">sf::Int64 FileStream::seek(sf::Int64 position)
{
return std::fseek(m_file, position, SEEK_SET);
}</code></pre>
<pre><code class="cpp">sf::Vertex line[] =
{
sf::Vertex(sf::Vector2f(10, 10)),
sf::Vertex(sf::Vector2f(150, 150))
};
window.draw(line, 2, sf::Lines);
</code></pre>
<img class="screenshot" src="./images/graphics-shape-line-primitive.png" alt="Une ligne sans épaisseur"/>
<?php
h2('Formes personnalisées');
?>
<p>
Vous pouvez étendre l'ensemble des classes de formes avec vos propres types de formes. Pour ce faire, vous devez dériver de <?php
class_link('Shape');
?>
et redéfinir
deux fonctions :
</p>
<ul>
<li><code>getPointCount</code>: renvoie le nombre de points de la forme</li>
<li><code>getPoint</code>: renvoie un point de la forme</li>
</ul>
<p>
Vous devez également appeler la fonction protégée <code>update()</code> à chaque fois que les points de la forme changent, de sorte que la classe de base en soit informée
et puisse recalculer ce dont elle a besoin.
</p>
<p>
Voici un exemple complet de classe de forme personnalisée : EllipseShape.
</p>
To modify or append special data to the buffer, you can then use the <code>Clear()</code> function
(to clear the internal buffer), <code>Append()</code> (to add raw data), or the << operator.
</p>
<p>
Custom packets can be useful in many situations : encryption, compression, adding checksums, filtering received
data, ...
You can even provide formatted packets using a fixed structure, or packets that
act like factories.
</p>
<?php
h2('Conclusion');
?>
<p>
The <?php
class_link("Packet");
?>
class wraps a lot of low-level network issues, and provides an easy way
to transfer data with sockets. I encourage you to extend packets to your needs, by overloading
<< and >> operators, and deriving your own packets classes if necessary.
</p>
<p>
It is important to remember that SFML packets use their own endianess and structure, so you cannot use
them to communicate with servers that are not using them. To send raw data, HTTP / FTP requests,
or whatever not built with SFML, use arrays of bytes instead of SFML packets.
</p>
<p>
You are now ready to jump to the last tutorial, about
<a class="internal" href="./network-selector.php" title="Go to the next tutorial">using selectors</a>.
</p>
<p>
Note: the <code>Download</code> and <code>Upload</code> function may take time to complete, depending on the size of
file to transfer. If you don't want to block your application it may be a good idea to execute them in a separate
thread.
</p>
<p>
<code>KeepAlive</code> is a special function that does nothing. Many FTP servers automatically disconnect clients
after several minutes of inactivity ; this function can be called when nothing happens, to prevent this
automatic disconnection.
</p>
<pre><code class="cpp">Server.KeepAlive();
</code></pre>
<p>
<code>Disconnect</code> disconnects the client from the server. Calling it is not mandatory (but recommended),
as it is done when the <?php
class_link("Ftp");
?>
instance gets destructed.
</p>
<pre><code class="cpp">Server.Disconnect();
</code></pre>
<?php
h2('Conclusion');
?>
<p>
This was the last tutorial about the network package. You can now
<a class="internal" href="./index.php" title="Back to the tutorial index">go to another section</a>,
and learn a new SFML package.
</p>
// ...
return 0;
}
</code></pre>
<p>
Les gens qui écrivent ce genre de code s'attendent à ce que la fonction <code>startThread()</code> démarre un thread qui va faire sa vie dans son
coin et sera détruit lorsque sa fonction se termine. Mais ce n'est pas ce qui se passe en réalité : la fonction threadée semble bloquer le thread
principal, comme si les threads ne fonctionnaient pas.
</p>
<p>
La raison ? L'instance de <?php
class_link("Thread");
?>
est locale à la fonction <code>startThread()</code> et est donc immédiatement détruite, quand
la fonction se termine. Le destructeur de <?php
class_link("Thread");
?>
est appelé automatiquement, et celui-ci appelle à son tour <code>wait()</code>
comme nous l'avons vu précédemment, et le résultat est que le thread principal bloque et attend que la fonction threadée se termine au lieu de
continuer à tourner en parallèle.
</p>
<p>
Donc n'oubliez jamais ceci : vous devez gérer vos instances de <?php
class_link("Thread");
?>
de manière à ce qu'elles vivent aussi longtemps que
le thread et sa fonction tournent.
</p>
<?php
require "footer-fr.php";
</code></pre>
<p>
SFML automatically fills mandatory header fields, such as "Host", "Content-Length", etc. You can send your requests without worrying about them. SFML will do its best
to make sure they are valid.
</p>
<?php
h2('Responses');
?>
<p>
If the <?php
class_link("Http");
?>
class could successfully connect to the host and send the request, a response is sent back and returned to the user, encapsulated in an
instance of the <?php
class_link("Http::Response");
?>
class. Responses contain the following members:
</p>
<ul>
<li>A status code which precisely indicates how the server processed the request (OK, redirected, not found, etc.)</li>
<li>The HTTP version of the server</li>
<li>The header: a set of fields with key and value</li>
<li>The body of the response</li>
</ul>
<pre><code class="cpp">sf::Http::Response response = http.sendRequest(request);
std::cout << "status: " << response.getStatus() << std::endl;
std::cout << "HTTP version: " << response.getMajorHttpVersion() << "." << response.getMinorHttpVersion() << std::endl;
std::cout << "Content-Type header:" << response.getField("Content-Type") << std::endl;
std::cout << "body: " << response.getBody() << std::endl;
</code></pre>
<pre><code class="cpp">if (event.type == sf::Event::MouseMoved)
{
std::cout << "new mouse x: " << event.mouseMove.x << std::endl;
std::cout << "new mouse y: " << event.mouseMove.y << std::endl;
}</code></pre>
<?php
h2('Les évènements MouseEntered et MouseLeft');
?>
<p>
Les évènements <code>sf::Event::MouseEntered</code> et <code>sf::Event::MouseLeft</code> sont déclenchés lorsque la souris entre ou quitte la
fenêtre.
</p>
<p>
Il n'y a pas de membre associé à ces évènements dans l'union <?php
class_link("Event");
?>
.
</p>
<pre><code class="cpp">if (event.type == sf::Event::MouseEntered)
std::cout << "the mouse cursor has entered the window" << std::endl;
if (event.type == sf::Event::MouseLeft)
std::cout << "the mouse cursor has left the window" << std::endl;
</code></pre>
<?php
h2('Les évènements JoystickButtonPressed et JoystickButtonReleased');
?>
<p>
Les évènements <code>sf::Event::JoystickButtonPressed</code> et <code>sf::Event::JoystickButtonReleased</code> sont déclenchés lorsqu'un bouton
</code></pre>
<p>
Of course, depending on the position of this line of code in the main loop, the captured image won't be the same.
It will capture the current contents of the screen at the time you call <code>Capture</code>.
</p>
<?php
h2('Mixing with OpenGL');
?>
<p>
It is of course still possible to use custom OpenGL commands with a
<?php
class_link("RenderWindow");
?>
, as you would do with a <?php
class_link("Window");
?>
.
You can even mix SFML drawing commands and your own OpenGL ones. However, SFML doesn't preserve OpenGL states
by default. If SFML messes up with your OpenGL states and you want it to take care of
saving / resetting / restoring them, you have to call the <code>PreserveOpenGLStates</code> function :
</p>
<pre><code class="cpp">App.PreserveOpenGLStates(true);
</code></pre>
<p>
Preserving OpenGL states is very CPU consuming and will degrade performances, use it only if you really need it. Also
consider using your own code to manage the states you need to preserve, as it will be more efficient than
the generic SFML code which takes care of every state, even the ones you don't care about.
</p>
<?php
<p>
These functions return <code>false</code> if anything failed during the loading. In this case, you get a detailed
GLSL compile log in the standard error output.
</p>
<p>
Before starting the rendering loop, you should initialize the variables defined in your effect. Remember, here we have a
texture called <code>framebuffer</code>, and a vector called <code>color</code>.
</p>
<pre><code class="cpp">Effect.SetTexture("framebuffer", NULL);
Effect.SetParameter("color", 1.f, 1.f, 1.f);
</code></pre>
<p>
The <code>SetTexture</code> function is used to bind a texture. The first parameter is the texture name in the effect,
the second one is a pointer to the texture, defined as a <?php
class_link("Image");
?>
. Passing <code>NULL</code> means you want
to use the contents of the screen.
</p>
<p>
To set any other type of parameter, you can use the <code>SetParameter</code> set of functions. The first parameter
is the parameter name in the effect, and then, depending on the parameter's type, you can pass 1, 2, 3 or 4
floats. Here we have a <code>vec3</code> variable, so we pass 3 values. Values for colors range from 0 to 1, so
here we have defined a white color.
</p>
<p>
You can then use these functions at any time to set the parameters values. For example, if we want to make the color
depend on the mouse position, we could write this piece of code into our rendering loop :
</p>
<pre><code class="cpp">// Get the mouse position in the range [0, 1]
Voici un exemple (factice) de paquet qui effectue de la compression/décompression automatique :
</p>
<pre><code class="cpp">class ZipPacket : public sf::Packet
{
virtual const void* onSend(std::size_t& size)
{
const void* srcData = getData();
std::size_t srcSize = getDataSize();
return compressTheData(srcData, srcSize, &size); // fonction factice, bien entendu :)
}
virtual void onReceive(const void* data, std::size_t size)
{
std::size_t dstSize;
const void* dstData = uncompressTheData(data, size, &dstSize); // fonction factice, bien entendu :)
append(dstData, dstSize);
}
};
</code></pre>
<p>
Un tel paquet peut être utilisé exactement comme <?php
class_link('Packet');
?>
. Et les surcharges d'opérateurs pour vos types persos s'appliquent toujours.
</p>
<pre><code class="cpp">ZipPacket packet;
packet << x << bob;
socket.send(packet);
</code></pre>
<?php
require "footer-fr.php";
contains source code and binaries, as well as samples and documentation.<br/>
The package can be found on the
<a class="internal" href="../../download.php" title="Go to the download page">download page</a>.
</p>
<p>
Once you have downloaded and extracted the files to your hard drive, you must install the SFML headers and library files
to the appropriate location. To do so, you just have to go to the SFML-x.y directory and type "sudo make install".
</p>
<?php
h2('Compiling your first SFML program');
?>
<p>
Create a new text file, and write a SFML program. For example, you can try the
<?php
class_link("Clock");
?>
class of the System package :
</p>
<pre><code class="cpp">#include <SFML/System.hpp>
#include <iostream>
int main()
{
sf::Clock Clock;
while (Clock.GetElapsedTime() < 5.f)
{
std::cout << Clock.GetElapsedTime() << std::endl;
sf::Sleep(0.5f);
}
Gardez bien cela en tête lorsque vous créez vos textures d'animation ou de tuiles (<em>sprite sheets</em> et <em>tilesets</em>) : utilisez si possible une seule texture.
</p>
<?php
h2('Utiliser sf::Texture dans du code OpenGL');
?>
<p>
Si vous utilisez OpenGL plutôt que les entités graphiques de SFML, vous pouvez toujours utiliser <?php
class_link("Texture");
?>
comme encapsulation d'une texture OpenGL,
et la faire intéragir avec vos entités OpenGL.
</p>
<p>
Afin d'activer une <?php
class_link("Texture");
?>
pour le rendu (l'équivalent de <code>glBindTexture</code>), vous devez appeler la fonction statique
<code>bind</code> :
</p>
<pre><code class="cpp">sf::Texture texture;
...
// activation de la texture
sf::Texture::bind(&texture);
// dessinez votre géometrie OpenGL ici...
// pas de texture
sf::Texture::bind(NULL);
</code></pre>
<p>
It is important to note that glyphs are added to the texture when they are requested. There are so many characters (remember, more than 100000) that they can't all
be generated when you load the font. Instead, they are rendered on the fly when you call the <code>getGlyph</code> function (see below).
</p>
<p>
To do something meaningful with the font texture, you must get the texture coordinates of glyphs that are contained in it:
</p>
<pre><code class="cpp">sf::Glyph glyph = font.getGlyph(character, characterSize, bold);
</code></pre>
<p>
<code>character</code> is the UTF-32 code of the character whose glyph that you want to get. You must also specify the character size, and whether you want the bold
or the regular version of the glyph.
</p>
<p>
The <?php
class_link('Glyph');
?>
structure contains three members:
</p>
<ul>
<li><code>textureRect</code> contains the texture coordinates of the glyph within the texture</li>
<li><code>bounds</code> contains the bounding rectangle of the glyph, which helps position it relative to the baseline of the text</li>
<li><code>advance</code> is the horizontal offset to apply to get the starting position of the next glyph in the text</li>
</ul>
<p>
You can also get some of the font's other metrics, such as the kerning between two characters or the line spacing (always for a certain character size):
</p>
<pre><code class="cpp">int lineSpacing = font.getLineSpacing(characterSize);
int kerning = font.getKerning(character1, character2, characterSize);
</code></pre>
virtual void onStop() // optionnelle
{
// nettoyez ce qui doit l'être après la fin de la capture
...
}
}
</code></pre>
<p>
Les fonctions <code>isAvailable</code>/<code>start</code>/<code>stop</code> sont définies dans la classe de base, <?php
class_link("SoundRecorder");
?>
,
et donc par conséquent dans toutes les classes dérivées. Cela signifie que vous pouvez utiliser n'importe quelle enregistreur exactement de la même
manière que la classe <?php
class_link("SoundBufferRecorder");
?>
ci-dessus.
</p>
<pre><code class="cpp">if (!MyRecorder::isAvailable())
{
// erreur...
}
MyRecorder recorder;
recorder.start();
...
recorder.stop();
</code></pre>
<?php
// mini-map (upper-right corner)
minimapView.setViewport(sf::FloatRect(0.75f, 0, 0.25f, 0.25f));
</code></pre>
<img class="screenshot" src="images/graphics-view-minimap.png" title="A minimap" />
<?php
h2('Using a view');
?>
<p>
To draw something using a view, you must draw it after calling the <code>setView</code> function of the target to which you are drawing
(<?php
class_link('RenderWindow');
?>
or <?php
class_link('RenderTexture');
?>
).
</p>
<pre><code class="cpp">// let's define a view
sf::View view(sf::FloatRect(0, 0, 1000, 600));
// activate it
window.setView(view);
// draw something to that view
window.draw(some_sprite);
// want to do visibility checks? retrieve the view
sf::View currentView = window.getView();
...
// we play it
sf::Music music;
music.openFromMemory(&fileData[0], fileData.size());
music.play();
// "ok, it seems that we don't need the source file any longer"
fileData.clear();
// ERROR: the music was still streaming the contents of fileData! The behavior is now undefined
</code></pre>
<h3>sf::Music is not copyable</h3>
<p>
The final "mistake" is a reminder: the <?php
class_link("Music");
?>
class is <em>not copyable</em>, so you won't be allowed to do that:
</p>
<pre><code class="cpp">sf::Music music;
sf::Music anotherMusic = music; // ERROR
void doSomething(sf::Music music)
{
...
}
sf::Music music;
doSomething(music); // ERROR (the function should take its argument by reference, not by value)
</code></pre>
<?php
threads.
</p>
<p>
Imaginez que votre flux audio lise un son reçu depuis le réseau. Les échantillons audio vont être joués pendant
que les suivants seront en train d'être reçus. Ainsi, le thread principal va remplir le tableau d'échantillons avec
les données provenant du réseau, pendant que le thread secondaire va lire depuis le tableau d'échantillons
pour alimenter le flux. Comme la lecture et l'écriture dans le tableau d'échantillons s'exécutent dans deux threads
différents, elles peuvent arriver au même moment, ce qui conduirait à des comportements indéfinis.
Dans ce cas précis, nous pouvons facilement protéger le tableau avec un mutex, et ainsi éviter les accès concurrents.<br/>
Pour en savoir plus à propos des threads et des mutexs, vous pouvez jeter un oeil au
<a class="internal" href="./system-threads-fr.php" title="Tutoriel sur les threads et mutexs">tutoriel correspondant</a>.
</p>
<?php
h2('Conclusion');
?>
<p>
<?php
class_link("SoundStream");
?>
fournit une interface simple pour réaliser des lectures en continu à partir de n'importe
quelles sources. Gardez toujours en tête qu'un flux tournera dans un nouveau thread, et préoccupez-vous des problèmes
de synchronisation.
</p>
<p>
Le prochain tutoriel vous montrera comment
<a class="internal" href="./audio-capture-fr.php" title="Aller au tutoriel suivant">réaliser des captures audio</a>.
</p>
<?php
require "footer-fr.php";
If you want to see nice examples of shaders in action, you can have a look at the Shader example in the SFML SDK.
</p>
<?php
h2('Using a sf::Shader with OpenGL code');
?>
<p>
If you're using OpenGL rather than the graphics entities of SFML, you can still use <?php
class_link("Shader");
?>
as a wrapper around an OpenGL program object and use it
within your OpenGL code.
</p>
<p>
To activate a <?php
class_link("Shader");
?>
for drawing (the equivalent of <code>glUseProgram</code>), you have to call the <code>bind</code> static function:
</p>
<pre><code class="cpp">sf::Shader shader;
...
// bind the shader
sf::Shader::bind(&shader);
// draw your OpenGL entity here...
// bind no shader
sf::Shader::bind(NULL);
</code></pre>
// Wait a while...
Recorder.Stop();
sf::SoundBuffer Buffer = Recorder.GetBuffer();
</code></pre>
<?php
h2('Multi-threading');
?>
<p>
For the same reasons as <?php
class_link("SoundStream");
?>
, <?php
class_link("SoundRecorder");
?>
runs the capture in a new thread,
so that the main thread is not blocked. So, once again, you have to take care of synchronization issues that can
arise if you share data between both threads.<br/>
For more detailed explanations, you can have a look at the
<a class="internal" href="./audio-streams.php" title="Go to the streams tutorial">SoundStream tutorial</a>.
</p>
<?php
h2('Conclusion');
?>
<p>
That's all for the basics of the audio package. You can play sounds and musics, stream audio from any source,
and capture sounds from your microphone.<br/>
Let's now explore a more advanced feature:
