SFML
Bibliothèque Multimédia Simple et Rapide Recherche 3.0.1 11,2k 1,8k
Accueil Apprendre Tutoriels Documentation Télécharger Communauté Développement Faire un don
Tutoriels
Dessiner des trucs en 2D Table des matières
SFML 3.0 Introduction
Démarrage La fenêtre de dessin
Système Introduction Que puis-je dessiner maintenant
?
Fenêtre Comme vous l'avez appris dans les didacticiels précédents, le module de fenêtre de SFML o re un moyen
simple d'ouvrir une fenêtre OpenGL et de gérer ses événements, mais il n'aide pas lorsqu'il s'agit de dessiner Dessin hors écran
Graphiques
quelque chose. La seule option qui vous reste est d'utiliser l'API OpenGL puissante, mais complexe et de bas Dessin à partir de ls
Dessiner des trucs en 2D
niveau.
Sprites et textures
Heureusement, SFML fournit un module graphique qui vous aidera à dessiner des entités 2 D d'une manière
Texte et polices
beaucoup plus simple qu'avec OpenGL.
Formes
Concevoir vos propres
entités avec des tableaux de La fenêtre de dessin
sommets
Pour dessiner les entités fournies par le module graphique, vous devez utiliser une classe de fenêtre
Position, rotation, échelle :
spécialisée : sf::RenderWindow '. Cette classe est dérivée de sf:: Fenêtre &, et hérite de toutes ses
Transformer les entités
fonctions. Tout ce que vous avez appris sf:: Fenêtre (création, gestion des événements, contrôle du
Ajout d'e ets spéciaux avec framerate, mélange avec OpenGL, etc) est applicable à sf::RenderWindow ainsi.
des shaders
Contrôle de la caméra 2 D En plus de ça, sf::RenderWindow ajoute des fonctions de haut niveau pour vous aider à dessiner facilement
avec vues des choses. Dans ce didacticiel, nous nous concentrerons sur deux de ces fonctions : clair et dessiner '. Ils
sont aussi simples que leur nom l'indique clair e ace toute la fenêtre avec la couleur choisie, et dessiner
Audio
dessine n'importe quel objet que vous lui passez.
Réseau
Voici à quoi ressemble une boucle principale typique avec une fenêtre de rendu :
SFML 2.6
#include <SFML/[Link]>
int principal()
{
//créer la fenêtre
sf::RendreWindow fenêtre(sf::Mode vidéo({800, 600}), "Ma fenêtre");
//exécuter le programme tant que la fenêtre est ouverte
pendant que (fenêtre'.est Ouvert())
{
//vérifier tous les événements de la fenêtre qui ont été déclenchés depuis la dernière
pendant que (const std::facultatif événement = fenêtre'.pollEvent())
{
//événement « fermer demandé » : on ferme la fenêtre
si (événement->est<sf::Événement::Fermé>())
fenêtre'.fermer();
}
// effacer la fenêtre avec la couleur noire
fenêtre'.clair(sf::Couleur::Noir);
//dessinez tout ici...
//fenê[Link](...);
// terminer le cadre actuel
fenêtre'.affichage();
}
}
Appel clair avant de dessiner quoi que ce soit est obligatoire, sinon le contenu des images précédentes
sera présent derrière tout ce que vous dessinez. La seule exception est lorsque vous couvrez toute la fenêtre
avec ce que vous dessinez de telle sorte que chaque pixel soit dessiné. Dans ce cas, vous pouvez éviter
d'appeler clair (même si cela n’aura pas d’impact notable sur les performances).
Appel affichage est également obligatoire, il faut ce qui a été tiré depuis le dernier appel à affichage et
l'a che sur la fenêtre. En e et, les choses ne sont pas directement attirées vers la fenêtre, mais vers un
tampon caché. Ce tampon est ensuite copié dans la fenêtre lorsque vous appelez affichage -- cela s'appelle
double tampon'.
Ce cycle clair/dessin/a chage est le seul bon moyen de dessiner des choses. N'essayez pas d'autres
stratégies, telles que conserver les pixels de l'image précédente, « e acer » les pixels ou dessiner une fois et
appeler l'a chage plusieurs fois. Vous obtiendrez des résultats étranges à cause du double tampon.
Le matériel graphique moderne et les API le sont vraiment conçu pour les cycles répétés
d'e acement/tirage/a chage où tout est complètement rafraîchi à chaque itération de la boucle principale.
N'ayez pas peur de dessiner 1000 sprites 60 fois par seconde. Vous êtes bien en dessous des millions de
triangles que votre ordinateur peut gérer.
What can I draw now?
Now that you have a main loop which is ready to draw, let's see what, and how, you can actually draw there.
SFML provides four kinds of drawable entities: three of them are ready to be used (sprites, text and shapes),
the last one is the building block that will help you create your own drawable entities (vertex arrays).
Although they share some common properties, each of these entities come with their own nuances and are
therefore explained in dedicated tutorials:
Sprite tutorial
Text tutorial
Shape tutorial
Vertex array tutorial
O -screen drawing
SFML also provides a way to draw to a texture instead of directly to a window. To do so, use a
sf::RenderTexture instead of a sf::RenderWindow . It has the same functions for drawing, inherited from
their common base: sf::RenderTarget .
// create a 500x500 render-texture
sf::RenderTexture renderTexture({500, 500});
// drawing uses the same functions
[Link]();
[Link](sprite); // or any other drawable
[Link]();
// get the target texture (where the stuff has been drawn)
const sf::Texture& texture = [Link]();
// draw it to the window
sf::Sprite sprite(texture);
[Link](sprite);
The getTexture function returns a read-only texture, which means that you can only use it, not modify it. If
you need to modify it before using it, you can copy it to your own sf::Texture instance and modify that
instead.
sf::RenderTexture also has the same functions as sf::RenderWindow for handling views and OpenGL (see
the corresponding tutorials for more details).
Drawing from threads
SFML supports multi-threaded drawing, and you don't even have to do anything to make it work. The only
thing to remember is to deactivate a window before using it in another thread. That's because a window
(more precisely its OpenGL context) cannot be active in more than one thread at the same time.
void renderingThread(sf::RenderWindow* window)
{
// activate the window's context
window->setActive(true);
// the rendering loop
while (window->isOpen())
{
// draw...
// end the current frame
window->display();
}
}
int main()
{
// create the window (remember: it's safer to create it in the main thread due to OS limita
sf::RenderWindow window(sf::VideoMode({800, 600}), "OpenGL");
// deactivate its OpenGL context
[Link](false);
// launch the rendering thread
std::thread thread(&renderingThread, &window);
// the event/logic/whatever loop
while ([Link]())
{
...
}
[Link]();
}
As you can see, you don't even need to bother with the activation of the window in the rendering thread,
SFML does it automatically for you whenever it needs to be done.
Remember to always create the window and handle its events in the main thread for maximum portability.
This is explained in the window tutorial.
Previous Next
Using OpenGL in an SFML window Sprites and textures
Copyright © Laurent Gomila
