Un rapide message pour vous présenter la version 1.1.0.
Cette nouvelle version contient en grande majorité des correctifs, quelques améliorations sur la qualité du code et/ou les performances (rien de folichon), mais elle a l'inconvénient d'avoir une API légèrement différente de celle de la version 1.0.0. Autrement dit : il faudra faire quelques ajustements mineurs sur votre code pour utiliser cette nouvelle version. En particulier, la classe gui::locale (qui s'occupait surtout de traduire les touches du clavier pour différents arrangements comme AZERTY ou QWERTY) a disparu, le travail étant maintenant délégué à la SFML. Cet petit changement induit une modification de l'initialisation du GUI, voici donc l'exemple modifié pour la 1.1.0 :
// On créé une fenêtre SFML
sf::Window mWindow(...);
// On créé un gestionnaire d'input (clavier, souris, ...)
utils::refptr<input::handler_impl> pSFMLHandler(new input::sfml_handler(mWindow));
// On initialise la classe principale gui::manager
gui::manager mManager(
// On lui donne un gestionnaire d'input
pSFMLHandler,
// La langue qui sera utilisée par l'interface (purement informatif : c'est aux addons de se traduire eux-même en utilisant cette valeur)
"frFR",
// Les dimensions de la fenêtre de rendu
mWindow.getSize().x, mWindow.getSize().y,
// L'implémentation OpenGL du rendu
utils::refptr<gui::manager_impl>(new gui::gl::manager())
);
// On lit ensuite les fichiers XML et Lua :
// - d'abord en précisant le dossier dans lequel se trouve le GUI
mManager.add_addon_directory("interface");
// - puis on créé un contexte Lua
mManager.create_lua([&mManager](){
// Ce code peut être appelé plus tard, par exemple quand l'utilisateur
// demande à recharger le GUI (le contexte lua est alors détruit, puis re-créé).
// - on spécifie les classes que l'on veut utiliser
mManager.register_region_type<gui::texture>("Texture");
mManager.register_region_type<gui::font_string>("FontString");
mManager.register_frame_type<gui::button>("Button");
mManager.register_frame_type<gui::slider>("Slider");
mManager.register_frame_type<gui::edit_box>("EditBox");
mManager.register_frame_type<gui::scroll_frame>("ScrollFrame");
mManager.register_frame_type<gui::status_bar>("StatusBar");
// - on référence dans Lua des fonctions C++ si nécessaire
// ...
});
// - puis enfin on charge le tout.
mManager.read_files();
// Dans la boucle principale
while (bRunning)
{
// On récupère les événements de la fenêtre
sf::Event mEvent;
while (mWindow.pollEvent(mEvent))
{
// ...
// On transmet ces événements au gestionnaire d'input
pSFMLHandler->on_sfml_event(mEvent);
}
// ...
// On met à jour le GUI
mManager.update(fDeltaTime);
// ...
// Puis on l'affiche à l'écran
mManager.render_ui();
// ...
}
Mis à part ce changement, tout fonctionne de la même façon.
Au menu des nouveautés, on notera en particulier :
- l'ajout de scripts CMake pour la compilation (facilite grandement l'installation sous linux)
- la mise à jour du gestionnaire d'input SFML pour coller aux derniers snapshots de la RC
- l'ajout d'un gestionnaire d'input pour GLFW (une bibliothèque de gestion de fenêtre pour OpenGL)
- il est maintenant possible d'utiliser des std::functions (ou des foncteurs, ou des lambdas) pour définir un "script".
Exemple simpliste qui imite bêtement les scripts Lua du premier post :
float update_time
= 0.5f, timer
= 1.0f;int frames
= 0;pFrame
->define_script
("OnUpdate", [&](gui
::frame* self
, gui
::event* event
) { float delta
= event
->get
(0)->get
<float
>(); timer
+= delta
; ++frames
; if (timer
> update_time
) { gui
::layered_region* reg
= self
->get_region
("FPSCounterText"); gui
::font_string* text
= dynamic_cast
<gui
::font_string*>(reg
); text
->set_text
("FPS : "+utils
::to_string(floor(frames
/timer
))); timer
= 0.0f; frames
= 0; } }); C'est un peu moins agréable à utiliser que le code Lua, moins flexible aussi puisqu'il faut re-compiler le programme pour modifier le script, mais ça sera toujours plus rapide et plus rigoureux (impossible par exemple d'appeler une méthode qui n'existe pas). L'avantage des std::functions, c'est qu'on peut vraiment mettre ce qu'on veut. Si à la place du code ci-dessous, vous voulez que l'événement "OnUpdate" appelle une certaine fonction my_on_update_function(), alors il suffit d'écrire :
pFrame->define_script("OnUpdate", &my_on_update_function, "main.cpp", 255);
... si cette fonction a le bon prototype (c'est à dire qu'elle attend un pointeur vers une gui::frame (l'objet qui émet l'événement) et un pointeur vers un gui::event (qui contient les informations additionnelles liées à l'événement)).
Pour des informations plus détaillées, je vous invite à lire le changelog.
