Vous êtes sur la page 1sur 103

Documentation

The HTML documentation contains both tutorials, guides for different topics


and an API reference.

The FAQ answers many commonly asked questions about the design,


implementation and use of GLFW.

License

GLFW is under the zlib/libpng license, which permits modification, distribution


and use in closed source software.

Example code

Below is a short example of setting up a window and OpenGL context with


GLFW. There are many more functions than those used here. For a quick
introduction to GLFW, see Getting started in the HTML documentation.
#include <GLFW/glfw3.h>

int main(void)
{
GLFWwindow* window;

/* Initialize the library */


if (!glfwInit())
return -1;

/* Create a windowed mode window and its OpenGL context */


window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}

/* Make the window's context current */


glfwMakeContextCurrent(window);

/* Loop until the user closes the window */


while (!glfwWindowShouldClose(window))
{
/* Render here */
glClear(GL_COLOR_BUFFER_BIT);

/* Swap front and back buffers */


glfwSwapBuffers(window);

/* Poll for and process events */


glfwPollEvents();
}

glfwTerminate();
return 0;
}
Commencer
Table des matières
 Pas à pas

o Y compris l'en-tête GLFW


o Initialisation et fermeture de GLFW
o Définir un rappel d'erreur
o Création d'une fenêtre et d'un contexte
o Rendre le contexte OpenGL actuel
o Vérification de l'indicateur de fermeture de fenêtre
o Réception d'événements d'entrée
o Rendu avec OpenGL
o Lecture de la minuterie
o Échanger des tampons
o Traitement des événements
 Mettre ensemble

Ce guide vous guide tout au long de l'écriture d'une application simple à l'aide de GLFW 3.
L'application créera une fenêtre et un contexte OpenGL, affichera un triangle en rotation et se
fermera lorsque l'utilisateur fermera la fenêtre ou appuiera sur Échap . Ce guide présentera
quelques-unes des fonctions les plus couramment utilisées, mais il y en a bien d'autres.

Ce guide ne suppose aucune expérience avec les versions antérieures de GLFW. Si vous avez
utilisé GLFW 2 dans le passé, lisez Passer de GLFW 2 à 3 , car certaines fonctions se
comportent différemment dans GLFW 3.

Pas à pas
Y compris l'en-tête GLFW

Dans les fichiers sources de votre application où vous utilisez GLFW, vous devez inclure son
fichier d'en-tête.

#include < GLFW/glfw3.h >

Cet en-tête fournit toutes les constantes, types et prototypes de fonction de l'API GLFW.

Par défaut, il inclut également l'en-tête OpenGL de votre environnement de développement. Sur


certaines plates-formes, cet en-tête ne prend en charge que les anciennes versions
d'OpenGL. Le cas le plus extrême est Windows, où il ne prend généralement en charge que
OpenGL 1.2.
La plupart des programmes utiliseront à la place une bibliothèque de chargeur d'extension et
incluront son en-tête. Cet exemple utilise des fichiers générés par glad . L'en-tête GLFW peut
détecter la plupart de ces en-têtes s'ils sont inclus en premier et n'inclura alors pas celui de votre
environnement de développement.

#include <glad/gl.h>
#include < GLFW/glfw3.h >

Pour vous assurer qu'il n'y aura pas de conflits d'en-tête, vous pouvez
définir GLFW_INCLUDE_NONE avant l'en-tête GLFW pour désactiver explicitement l'inclusion
de l'en-tête de l'environnement de développement. Cela permet également d'inclure les deux en-
têtes dans n'importe quel ordre.

#define GLFW_INCLUDE_NONE
#include < GLFW/glfw3.h >
#include <glad/gl.h>

Initialisation et fermeture de GLFW

Avant de pouvoir utiliser la plupart des fonctions GLFW, la bibliothèque doit être initialisée. En
cas d'initialisation réussie, GLFW_TRUEest renvoyé. Si une erreur s'est produite, GLFW_FALSEest
renvoyé.

si (! glfwInit ())
{
// Initialisation échouée
}

Notez que GLFW_TRUEet GLFW_FALSEsont et seront toujours un et zéro.

Lorsque vous avez fini d'utiliser GLFW, généralement juste avant la fermeture de l'application,
vous devez arrêter GLFW.

glfwTerminer ();

Cela détruit toutes les fenêtres restantes et libère toutes les autres ressources allouées par
GLFW. Après cet appel, vous devez réinitialiser GLFW avant d'utiliser les fonctions GLFW qui le
nécessitent.

Définir un rappel d'erreur

La plupart des événements sont signalés via des rappels, qu'il s'agisse d'une touche enfoncée,
d'une fenêtre GLFW déplacée ou d'une erreur. Les rappels sont des fonctions C (ou des
méthodes statiques C++) qui sont appelées par GLFW avec des arguments décrivant
l'événement.

En cas d'échec d'une fonction GLFW, une erreur est signalée au rappel d'erreur GLFW. Vous
pouvez recevoir ces rapports avec un rappel d'erreur. Cette fonction doit avoir la signature ci-
dessous mais peut faire tout ce qui est permis dans d'autres rappels.

void error_callback( int error, const char * description)


{
fprintf(stderr, "Erreur : %s\n" , description);
}

Les fonctions de rappel doivent être définies, afin que GLFW sache les appeler. La fonction pour
définir le rappel d'erreur est l'une des rares fonctions GLFW qui peuvent être appelées avant
l'initialisation, ce qui vous permet d'être averti des erreurs à la fois pendant et après l'initialisation.

glfwSetErrorCallback (rappel_erreur);

Création d'une fenêtre et d'un contexte

La fenêtre et son contexte OpenGL sont créés avec un seul appel à glfwCreateWindow , qui
renvoie un handle vers l'objet combiné fenêtre et contexte créé

GLFWwindow * window = glfwCreateWindow (640, 480, "Mon titre" , NULL, NULL);


si (!fenêtre)
{
// La création de la fenêtre ou du contexte OpenGL a échoué
}

Cela crée une fenêtre en mode fenêtré de 640 x 480 avec un contexte OpenGL. Si la création de
la fenêtre ou du contexte OpenGL échoue, NULLsera renvoyé. Vous devez toujours vérifier la
valeur de retour. Alors que la création de fenêtre échoue rarement, la création de contexte
dépend de pilotes correctement installés et peut échouer même sur des machines dotées du
matériel nécessaire.

Par défaut, le contexte OpenGL créé par GLFW peut avoir n'importe quelle version. Vous pouvez
exiger une version minimale d'OpenGL en définissant
les astuces GLFW_CONTEXT_VERSION_MAJORet avant la création. Si la version minimale requise
n'est pas prise en charge sur la machine, la création du contexte (et de la fenêtre)
échoue.GLFW_CONTEXT_VERSION_MINOR

glfwWindowHint ( GLFW_CONTEXT_VERSION_MAJOR , 2);


glfwWindowHint ( GLFW_CONTEXT_VERSION_MINOR , 0);
GLFWwindow * window = glfwCreateWindow (640, 480, "Mon titre" , NULL, NULL);
si (!fenêtre)
{
// La création de la fenêtre ou du contexte a échoué
}

Le handle de fenêtre est transmis à toutes les fonctions liées à la fenêtre et est fourni avec tous
les rappels liés à la fenêtre, afin qu'ils puissent dire quelle fenêtre a reçu l'événement.

Lorsqu'une fenêtre et un contexte ne sont plus nécessaires, détruisez-les.

glfwDestroyWindow (fenêtre);

Une fois cette fonction appelée, plus aucun événement ne sera délivré pour cette fenêtre et son
handle devient invalide.

Rendre le contexte OpenGL actuel

Avant de pouvoir utiliser l'API OpenGL, vous devez disposer d'un contexte OpenGL actuel.

glfwMakeContextCurrent (fenêtre);

Le contexte restera actuel jusqu'à ce que vous rendiez un autre contexte actuel ou jusqu'à ce que
la fenêtre possédant le contexte actuel soit détruite.

Si vous utilisez une bibliothèque de chargeur d'extension pour accéder à OpenGL moderne,


c'est à ce moment-là de l'initialiser, car le chargeur a besoin d'un contexte actuel à partir duquel
se charger. Cet exemple utilise glad , mais la même règle s'applique à toutes ces bibliothèques.

gladLoadGL( glfwGetProcAddress );

Vérification de l'indicateur de fermeture de fenêtre

Chaque fenêtre a un drapeau indiquant si la fenêtre doit être fermée.

Lorsque l'utilisateur tente de fermer la fenêtre, soit en appuyant sur le widget de fermeture dans
la barre de titre, soit en utilisant une combinaison de touches comme Alt+F4, cet indicateur est
défini sur 1. Notez que la fenêtre n'est pas réellement fermée , vous êtes donc attendu pour
surveiller ce drapeau et soit détruire la fenêtre, soit donner une sorte de retour à l'utilisateur.

while (! glfwWindowShouldClose (fenêtre))


{
// Continuer à courir
}
Vous pouvez être averti lorsque l'utilisateur tente de fermer la fenêtre en définissant un rappel
de fermeture avec glfwSetWindowCloseCallback . Le rappel sera appelé immédiatement
après que l'indicateur de fermeture ait été défini.

Vous pouvez également le définir vous-même avec glfwSetWindowShouldClose . Cela peut


être utile si vous souhaitez interpréter d'autres types de saisie comme la fermeture de la fenêtre,
comme par exemple appuyer sur la touche Échap .

Réception d'événements d'entrée

Chaque fenêtre dispose d'un grand nombre de rappels qui peuvent être configurés pour recevoir
tous les types d'événements. Pour recevoir des événements d'appui et de relâchement de
touche, créez une fonction de rappel de touche.

statique vide key_callback ( GLFWwindow * fenêtre, int clé, int scancode, int
action int mods)
{
si (clé == GLFW_KEY_ESCAPE && action == GLFW_PRESS )
glfwSetWindowShouldClose (fenêtre, GLFW_TRUE );
}

Le rappel de touche, comme les autres rappels liés aux fenêtres, est défini par fenêtre.

glfwSetKeyCallback (fenêtre, key_callback);

Pour que les rappels d'événements soient appelés lorsque des événements se produisent, vous
devez traiter les événements comme décrit ci-dessous.

Rendu avec OpenGL

Une fois que vous avez un contexte OpenGL actuel, vous pouvez utiliser OpenGL
normalement. Dans ce didacticiel, un triangle rotatif multicolore sera rendu. La taille du
framebuffer doit être récupérée pour glViewport.

int largeur, hauteur;


glfwGetFramebufferSize (fenêtre, &largeur, &hauteur);
glViewport(0, 0, largeur, hauteur);

Vous pouvez également définir un rappel de taille de framebuffer à l'aide


de glfwSetFramebufferSizeCallback et être averti lorsque la taille change.

Les détails sur la façon de rendre avec OpenGL sortent du cadre de ce didacticiel, mais il existe
de nombreuses excellentes ressources pour apprendre l'OpenGL moderne. En voici quelques-
uns :
 Tutoriels OpenGL 4 d'Anton
 Apprendre OpenGL
 Ouvrir.GL

Tout cela utilise GLFW, mais OpenGL lui-même fonctionne de la même manière quelle que soit
l'API que vous utilisez pour créer la fenêtre et le contexte.

Lecture de la minuterie

Pour créer une animation fluide, une source de temps est nécessaire. GLFW fournit une
minuterie qui renvoie le nombre de secondes depuis l'initialisation. La source de temps utilisée
est la plus précise sur chaque plate-forme et a généralement une résolution de la micro ou
nanoseconde.

temps double = glfwGetTime ();

Échanger des tampons

Les fenêtres GLFW utilisent par défaut la double mise en mémoire tampon. Cela signifie que
chaque fenêtre a deux tampons de rendu ; un tampon avant et un tampon arrière. Le tampon
avant est celui qui est affiché et le tampon arrière celui vers lequel vous effectuez le rendu.

Lorsque l'ensemble de l'image a été rendu, les tampons doivent être échangés les uns avec les
autres, de sorte que le tampon arrière devient le tampon avant et vice versa.

glfwSwapBuffers (fenêtre);

L'intervalle d'échange indique le nombre de trames à attendre avant d'échanger les tampons,
communément appelé vsync . Par défaut, l'intervalle d'échange est de zéro, ce qui signifie que
l'échange de tampon se produira immédiatement. Sur les machines rapides, bon nombre de ces
images ne seront jamais vues, car l'écran n'est toujours mis à jour généralement que 60 à 75 fois
par seconde, ce qui gaspille beaucoup de cycles CPU et GPU.

De plus, parce que les tampons seront échangés au milieu de la mise à jour de l'écran, ce qui
entraînera un déchirement de l'écran .

Pour ces raisons, les applications voudront généralement définir l'intervalle d'échange sur un. Il
peut être défini sur des valeurs plus élevées, mais ce n'est généralement pas recommandé, en
raison de la latence d'entrée qu'il entraîne.

glfwIntervalle d'échange (1) ;

Cette fonction agit sur le contexte actuel et échouera à moins qu'un contexte ne soit actuel.
Traitement des événements

GLFW a besoin de communiquer régulièrement avec le système de fenêtres à la fois pour


recevoir des événements et pour montrer que l'application ne s'est pas verrouillée. Le traitement
des événements doit être effectué régulièrement tant que vous avez des fenêtres visibles et est
normalement effectué à chaque image après l'échange de tampon.

Il existe deux méthodes pour traiter les événements en attente ; sondage et attente. Cet exemple
utilisera l'interrogation d'événements, qui ne traite que les événements qui ont déjà été reçus,
puis les renvoie immédiatement.

glfwPollEvents ();

C'est le meilleur choix lors du rendu en continu, comme le font la plupart des jeux. Si au contraire
vous n'avez besoin de mettre à jour votre rendu qu'une fois que vous avez reçu une nouvelle
entrée, glfwWaitEvents est un meilleur choix. Il attend qu'au moins un événement ait été reçu,
mettant le thread en veille entre-temps, puis traite tous les événements reçus. Cela permet
d'économiser beaucoup de cycles CPU et est utile, par exemple, pour de nombreux types d'outils
d'édition.

Mettre ensemble
Maintenant que vous savez comment initialiser GLFW, créer une fenêtre et un sondage pour la
saisie au clavier, il est possible de créer un programme simple.

Ce programme crée une fenêtre en mode fenêtré de 640 x 480 et démarre une boucle qui efface
l'écran, affiche un triangle et traite les événements jusqu'à ce que l'utilisateur appuie
sur Échap ou ferme la fenêtre.

#include <glad/gl.h>
#define GLFW_INCLUDE_NONE
#include < GLFW/glfw3.h >
#include "linmath.h"
#include <stdlib.h>
#include <stdio.h>
statique const struct
{
flotter x, y ;
flotteur r, g, b;
} sommets[3] =
{
{ -0.6f, -0.4f, 1.f, 0.f, 0.f },
{ 0.6f, -0.4f, 0.f, 1.f, 0.f },
{ 0.f, 0.6f, 0.f, 0.f, 1.f }
} ;
static const char * vertex_shader_text =
"#version 110\n"
"uniform mat4 MVP ;\n"
"attribut vec3 vCol;\n"
"attribut vec2 vPos;\n"
"couleur vec3 variable ;\n"
"void main()\n"
"{\n"
" gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
" couleur = vCol;\n"
"}\n" ;
static const char * fragment_shader_text =
"#version 110\n"
"couleur vec3 variable ;\n"
"void main()\n"
"{\n"
" gl_FragColor = vec4(couleur, 1.0);\n"
"}\n" ;
static void error_callback( int error, const char * description)
{
fprintf(stderr, "Erreur : %s\n" , description);
}
statique vide key_callback ( GLFWwindow * fenêtre, int clé, int scancode, int
action int mods)
{
si (clé == GLFW_KEY_ESCAPE && action == GLFW_PRESS )
glfwSetWindowShouldClose (fenêtre, GLFW_TRUE );
}
int main( void )
{
GLFWfenêtre * fenêtre ;
GLuint vertex_buffer, vertex_shader, fragment_shader, programme ;
GLint mvp_location, vpos_location, vcol_location ;
glfwSetErrorCallback (rappel_erreur);
si (! glfwInit ())
exit(EXIT_FAILURE);
glfwWindowHint ( GLFW_CONTEXT_VERSION_MAJOR , 2);
glfwWindowHint ( GLFW_CONTEXT_VERSION_MINOR , 0);
window = glfwCreateWindow (640, 480, "Exemple simple" , NULL, NULL);
si (!fenêtre)
{
glfwTerminer ();
exit(EXIT_FAILURE);
}
glfwSetKeyCallback (fenêtre, key_callback);
glfwMakeContextCurrent (fenêtre);
gladLoadGL( glfwGetProcAddress );
glfwIntervalle d'échange (1) ;
// REMARQUE : les contrôles d'erreur OpenGL ont été omis par souci de concision
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData (GL_ARRAY_BUFFER, sizeof (sommets), les sommets, GL_STATIC_DRAW);
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
glCompileShader(vertex_shader);
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
glCompileShader(fragment_shader);
programme = glCréerProgramme();
glAttachShader(programme, vertex_shader);
glAttachShader(programme, fragment_shader);
glLinkProgram(programme);
mvp_location = glGetUniformLocation(programme, "MVP" );
vpos_location = glGetAttribLocation(programme, "vPos" );
vcol_location = glGetAttribLocation(programme, "vCol" );
glEnableVertexAttribArray(vpos_location);
glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
sizeof (sommets[0]), ( void *) 0);
glEnableVertexAttribArray(vcol_location);
glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE,
sizeof (vertices[0]), ( void *) ( sizeof ( float ) * 2));
while (! glfwWindowShouldClose (fenêtre))
{
taux de flottement ;
int largeur, hauteur;
mat4x4 m, p, mvp;
glfwGetFramebufferSize (fenêtre, &largeur, &hauteur);
rapport = largeur / hauteur (flottante) ;
glViewport(0, 0, largeur, hauteur);
glClear(GL_COLOR_BUFFER_BIT);
mat4x4_identity(m);
mat4x4_rotate_Z(m, m, ( float ) glfwGetTime ());
mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
mat4x4_mul(mvp, p, m);
glUtiliserProgramme(programme);
glUniformMatrix4fv(mvp_location, 1, GL_FALSE, ( const GLfloat*) mvp);
glDrawArrays(GL_TRIANGLES, 0, 3);
glfwSwapBuffers (fenêtre);
glfwPollEvents ();
}
glfwDestroyWindow (fenêtre);
glfwTerminer ();
exit(EXIT_SUCCESS);
}

Le programme ci - dessus se trouve dans le paquet source comme examples/simple.cet est


compilé avec tous les autres exemples lorsque vous construisez GLFW. Si vous avez construit
GLFW à partir du package source, vous l'avez déjà sous simple.exeWindows, simpleLinux
ou simple.appmacOS.

Ce didacticiel n'a utilisé que quelques-unes des nombreuses fonctions fournies par GLFW. Il
existe des guides pour chacun des domaines couverts par GLFW. Chaque guide présentera
toutes les fonctions de cette catégorie.

 Présentation de l'API
 Guide de fenêtre
 Guide contextuel
 Guide du moniteur
 Guide de saisie

Vous pouvez accéder à la documentation de référence pour n'importe quelle fonction GLFW en
cliquant dessus et la référence de chaque fonction renvoie aux fonctions et aux sections de guide
associées.

Le tutoriel se termine ici. Une fois que vous avez écrit un programme qui utilise GLFW, vous
devrez le compiler et le lier. La procédure à suivre dépend de l'environnement de développement
que vous utilisez et est mieux expliquée par la documentation de cet environnement. Pour en
savoir plus sur les détails spécifiques à GLFW, consultez Création d'applications .
Présentation de l'API
Table des matières
 Initialisation et résiliation

o Initialisation de GLFW
o Conseils d'initialisation

 Conseils d'initialisation partagés


 Conseils d'initialisation spécifiques à macOS
 Valeurs prises en charge et valeurs par défaut
 Mettre fin à GLFW
 La gestion des erreurs
 Systèmes de coordonnées
 Garanties et limitations
 Durées de vie des pointeurs
 Rentrée
 Sécurité du fil
 Compatibilité des versions
 Ordre de l'événement
 Gestion des versions
 Version au moment de la compilation
 Version d'exécution
 Chaîne de version

Ce guide présente les concepts de base de GLFW et décrit l'initialisation, la gestion des erreurs
et les garanties et limitations de l'API. Pour un didacticiel large mais superficiel, consultez la
rubrique Mise en route à la place. Pour plus de détails sur une fonction spécifique de cette
catégorie, consultez la référence d'initialisation, de version et d'erreur .

Il existe également des guides pour les autres domaines de GLFW.

 Guide de fenêtre
 Guide contextuel
 Guide de Vulkan
 Guide du moniteur
 Guide de saisie

Initialisation et résiliation
Avant que la plupart des fonctions GLFW puissent être appelées, la bibliothèque doit être
initialisée. Cette initialisation vérifie quelles fonctionnalités sont disponibles sur la machine,
énumère les moniteurs et les joysticks, initialise la minuterie et effectue toute initialisation requise
spécifique à la plate-forme.

Seules les fonctions suivantes peuvent être appelées avant que la bibliothèque n'ait été initialisée
avec succès, et uniquement à partir du thread principal.

 glfwObtenirVersion
 glfwGetVersionString
 glfwGetError
 glfwSetErrorCallback
 glfwInitIndice
 glfwInit
 glfwTerminer

L'appel de toute autre fonction avant une initialisation réussie provoquera


une erreur GLFW_NOT_INITIALIZED .

Initialisation de GLFW

La bibliothèque est initialisée avec glfwInit , qui renvoie GLFW_FALSEsi une erreur s'est produite.

si (! glfwInit ())
{
// Gérer l'échec de l'initialisation
}

Si une partie de l'initialisation échoue, toutes les parties qui ont réussi sont terminées comme
si glfwTerminate avait été appelé. La bibliothèque n'a besoin d'être initialisée qu'une seule fois
et les appels supplémentaires à une bibliothèque déjà initialisée seront
renvoyés GLFW_TRUEimmédiatement.

Une fois que la bibliothèque a été initialisée avec succès, elle doit être arrêtée avant la fermeture
de l'application. Les systèmes modernes sont très efficaces pour libérer les ressources allouées
par les programmes qui se terminent, mais GLFW doit parfois modifier les paramètres système
globaux et ceux-ci peuvent ne pas être restaurés sans interruption.

Conseils d'initialisation

Les conseils d'initialisation sont définis avant glfwInit et affectent le comportement de la


bibliothèque jusqu'à la fin. Les conseils sont définis avec glfwInitHint .

glfwInitHint ( GLFW_JOYSTICK_HAT_BUTTONS , GLFW_FALSE );


Les valeurs que vous définissez pour les conseils ne sont jamais réinitialisées par GLFW, mais
elles ne prennent effet que lors de l'initialisation. Une fois que GLFW a été initialisé, toutes les
valeurs que vous définissez seront ignorées jusqu'à ce que la bibliothèque soit terminée et
réinitialisée.

Certaines astuces sont spécifiques à la plate-forme. Ceux-ci peuvent être définis sur n'importe
quelle plate-forme, mais ils n'affecteront que leur plate-forme spécifique. Les autres plateformes
les ignoreront. La définition de ces conseils ne nécessite aucun en-tête ou fonction spécifique à
la plate-forme.

Conseils d'initialisation partagés

GLFW_JOYSTICK_HAT_BUTTONS spécifie s'il faut également exposer les chapeaux de


joystick en tant que boutons, pour la compatibilité avec les versions antérieures de GLFW qui
n'avaient pas glfwGetJoystickHats . Définissez cela avec glfwInitHint .

Conseils d'initialisation spécifiques à macOS

GLFW_COCOA_CHDIR_RESOURCES spécifie s'il faut définir le répertoire courant de


l'application dans le Contents/Resourcessous - répertoire du bundle de l'application, s'il est
présent. Définissez cela avec glfwInitHint .

GLFW_COCOA_MENUBAR spécifie s'il faut créer une barre de menus de base, soit à partir d'un
nib, soit manuellement, lors de la création de la première fenêtre, c'est-à-dire lors de l'initialisation
d'AppKit. Définissez cela avec glfwInitHint .

Valeurs prises en charge et valeurs par défaut


Valeur par
Conseil d'initialisation Valeurs prises en charge
défaut

GLFW_TRUE ou
GLFW_JOYSTICK_HAT_BUTTONS GLFW_TRUE
alors GLFW_FALSE

GLFW_TRUE ou
GLFW_COCOA_CHDIR_RESOURCES GLFW_TRUE
alors GLFW_FALSE

GLFW_TRUE ou
GLFW_COCOA_MENUBAR GLFW_TRUE
alors GLFW_FALSE

Mettre fin à GLFW

Avant la fermeture de votre application, vous devez terminer la bibliothèque GLFW si elle a été
initialisée. Cela se fait avec glfwTerminate .
glfwTerminer ();

Cela détruira tous les objets fenêtre, moniteur et curseur restants, restaurera toutes les rampes
gamma modifiées, réactivera l'économiseur d'écran s'il avait été désactivé et libérera toutes les
autres ressources allouées par GLFW.

Une fois la bibliothèque terminée, c'est comme si elle n'avait jamais été initialisée et vous devrez
l'initialiser à nouveau avant de pouvoir utiliser GLFW. Si la bibliothèque n'a pas été initialisée ou a
déjà été arrêtée, elle revient immédiatement.

La gestion des erreurs


Certaines fonctions GLFW ont des valeurs de retour qui indiquent une erreur, mais cela n'est
souvent pas très utile pour essayer de comprendre ce qui s'est passé ou pourquoi cela s'est
produit. D'autres fonctions n'ont pas de valeur de retour réservée aux erreurs, la notification
d'erreur nécessite donc un canal séparé. Enfin, loin de toutes les fonctions GLFW ont des valeurs
de retour.

Le dernier code d'erreur du thread appelant peut être interrogé à tout moment


avec glfwGetError .

code int = glfwGetError (NULL);


si (code != GLFW_NO_ERROR )
handle_error(code);

Si aucune erreur ne s'est produite depuis le dernier appel, GLFW_NO_ERROR (zéro) est


renvoyé. L'erreur est effacée avant le retour de la fonction.

Le code d'erreur indique la catégorie générale de l'erreur. Certains codes d'erreur, tels


que GLFW_NOT_INITIALIZED n'ont qu'une seule signification, tandis que d'autres
comme GLFW_PLATFORM_ERROR sont utilisés pour de nombreuses erreurs différentes.

GLFW a souvent plus d'informations sur une erreur que sa catégorie générale. Vous pouvez
récupérer une description lisible par l'homme codée en UTF-8 avec le code d'erreur. Si aucune
erreur ne s'est produite depuis le dernier appel, la description est définie sur NULL.

const char * description;


code int = glfwGetError (&description);
si (description)
display_error_message(code, description);

La chaîne de description récupérée n'est valide que jusqu'à ce que l'erreur suivante se
produise. Cela signifie que vous devez en faire une copie si vous souhaitez le conserver.
Vous pouvez également définir un rappel d'erreur, qui sera appelé à chaque fois qu'une erreur se
produit. Il est défini avec glfwSetErrorCallback .

glfwSetErrorCallback (rappel_erreur);

Le rappel d'erreur reçoit le même code d'erreur et la même description lisible que ceux renvoyés
par glfwGetError .

void error_callback( int code, const char * description)


{
display_error_message(code, description);
}

Le rappel d'erreur est appelé après le stockage de l'erreur, donc l'appel de glfwGetError à partir
du rappel d'erreur renvoie les mêmes valeurs que l'argument de rappel.

La chaîne de description transmise au rappel n'est valide que jusqu'au retour du rappel
d'erreur. Cela signifie que vous devez en faire une copie si vous souhaitez le conserver.

Les erreurs signalées ne sont jamais fatales. Tant que GLFW a été initialisé avec succès, il
restera initialisé et dans un état sûr jusqu'à ce qu'il soit terminé, quel que soit le nombre d'erreurs
qui se produisent. Si une erreur se produit lors de l'initialisation qui provoque
l' échec de glfwInit , toute partie de la bibliothèque qui a été initialisée sera arrêtée en toute
sécurité.

Ne comptez pas sur un appel actuellement invalide pour générer une erreur spécifique, car à
l'avenir ce même appel peut générer une erreur différente ou devenir valide.

Systèmes de coordonnées
GLFW a deux systèmes de coordonnées principaux : l' écran virtuel et la zone de contenu de la
fenêtre ou zone de contenu . Les deux utilisent la même unité : les coordonnées de l'écran
virtuel , ou simplement les coordonnées de l'écran , qui ne correspondent pas nécessairement
aux pixels.
Les systèmes de coordonnées de l'écran virtuel et de la zone de contenu ont tous deux l'axe X
pointant vers la droite et l'axe Y pointant vers le bas.

Les positions de la fenêtre et du moniteur sont spécifiées comme la position des coins supérieurs
gauches de leurs zones de contenu par rapport à l'écran virtuel, tandis que les positions du
curseur sont spécifiées par rapport à la zone de contenu d'une fenêtre.

Étant donné que l'origine du système de coordonnées de la zone de contenu de la fenêtre est
également le point à partir duquel la position de la fenêtre est spécifiée, vous pouvez traduire les
coordonnées de la zone de contenu vers l'écran virtuel en ajoutant la position de la fenêtre. Le
cadre de la fenêtre, lorsqu'il est présent, s'étend hors de la zone de contenu mais n'affecte pas la
position de la fenêtre.

Presque toutes les positions et tailles dans GLFW sont mesurées en coordonnées d'écran par
rapport à l'une des deux origines ci-dessus. Cela inclut les positions du curseur, les positions et
les tailles de fenêtre, les tailles de cadre de fenêtre, les positions de moniteur et les résolutions
de mode vidéo.

Deux exceptions sont la taille physique du moniteur , qui est mesurée en millimètres, et la taille
du framebuffer , qui est mesurée en pixels.

Les pixels et les coordonnées d'écran peuvent correspondre à 1:1 sur votre machine, mais ils ne
le seront pas sur toutes les autres machines, par exemple sur un Mac avec un écran Retina. Le
rapport entre les coordonnées de l'écran et les pixels peut également changer au moment de
l'exécution en fonction du moniteur sur lequel la fenêtre est actuellement considérée comme
étant.

Garanties et limitations
Cette section décrit les conditions dans lesquelles GLFW peut fonctionner, sauf bogues dans le
système d'exploitation ou les pilotes. L'utilisation de GLFW en dehors de ces limites peut
fonctionner sur certaines plates-formes, ou sur certaines machines, ou de temps en temps, ou
sur certaines versions de GLFW, mais elle peut casser à tout moment et cela ne sera pas
considéré comme un bogue.

Durées de vie des pointeurs

GLFW ne libérera jamais aucun pointeur que vous lui fournissez et vous ne devez jamais libérer
aucun pointeur qu'il vous fournit.

De nombreuses fonctions GLFW renvoient des pointeurs vers des structures, des chaînes ou des
tableaux alloués dynamiquement, et certains rappels sont fournis avec des chaînes ou des
tableaux. Ceux-ci sont toujours gérés par GLFW et ne doivent jamais être libérés par
l'application. La durée de vie de ces pointeurs est documentée pour chaque fonction et rappel
GLFW. Si vous devez conserver ces données, vous devez les copier avant l'expiration de leur
durée de vie.

De nombreuses fonctions GLFW acceptent des pointeurs vers des structures ou des chaînes
allouées par l'application. Ceux-ci ne sont jamais libérés par GLFW et sont toujours sous la
responsabilité de l'application. Si GLFW doit conserver les données dans ces structures ou
chaînes, elles sont copiées avant le retour de la fonction.

La durée de vie des pointeurs est garantie de ne pas être raccourcie dans les futures versions
mineures ou de correctif.

Rentrée

Le traitement des événements GLFW et la destruction d'objets ne sont pas réentrants. Cela


signifie que les fonctions suivantes ne doivent être appelées à partir d'aucune fonction de rappel :

 glfwDétruireFenêtre
 glfwDestroyCurseur
 glfwPollEvents
 glfwAttenteÉvénements
 glfwWaitEventsTimeout
 glfwTerminer

Ces fonctions peuvent être rendues réentrantes dans les futures versions mineures ou correctifs,
mais les fonctions ne figurant pas sur cette liste ne seront pas rendues non réentrantes.

Sécurité du fil

La plupart des fonctions GLFW ne doivent être appelées que depuis le thread principal (le thread
qui appelle main), mais certaines peuvent être appelées depuis n'importe quel thread une fois la
bibliothèque initialisée. Avant l'initialisation, toute la bibliothèque est thread-unsafe.

La documentation de référence pour chaque fonction GLFW indique si elle est limitée au thread
principal.

L'initialisation, la terminaison, le traitement des événements et la création et la destruction de


fenêtres, de curseurs et de contextes OpenGL et OpenGL ES sont tous limités au thread
principal en raison des limitations d'une ou plusieurs plates-formes.

Étant donné que le traitement des événements doit être effectué sur le thread principal, tous les
rappels, à l'exception du rappel d'erreur, ne seront appelés que sur ce thread. Le rappel d'erreur
peut être appelé sur n'importe quel thread, car toute fonction GLFW peut générer des erreurs.
Le code d'erreur et la description peuvent être interrogés à partir de n'importe quel thread.

 glfwGetError

Les événements vides peuvent être publiés à partir de n'importe quel fil.

 glfwPostEmptyEvent

Le pointeur utilisateur de fenêtre et l'indicateur de fermeture peuvent être lus et écrits à partir de
n'importe quel thread, mais cela n'est pas synchronisé par GLFW.

 glfwGetWindowUserPointer
 glfwSetWindowUserPointer
 glfwFenêtre devraitFermer
 glfwDéfinirFenêtreDevraitFermer

Ces fonctions pour travailler avec les contextes OpenGL et OpenGL ES peuvent être appelées
depuis n'importe quel thread, mais l'objet window n'est pas synchronisé par GLFW.

 glfwMakeContextCurrent
 glfwGetCurrentContext
 glfwSwapBuffers
 glfwIntervalleSwap
 glfwExtensionPrise en charge
 glfwGetProcAddress

Les fonctions de minuterie brutes peuvent être appelées à partir de n'importe quel thread.

 glfwGetTimerFrequency
 glfwGetTimerValue

Le temporisateur normal peut être utilisé à partir de n'importe quel thread, mais la lecture et
l'écriture du décalage du temporisateur ne sont pas synchronisées par GLFW.

 glfwGetTime
 glfwDéfinirHeure

Les informations sur la version de la bibliothèque peuvent être interrogées à partir de n'importe
quel thread.

 glfwObtenirVersion
 glfwGetVersionString

Toutes les fonctions liées à Vulkan peuvent être appelées à partir de n'importe quel thread.
 glfwVulkanSupporté
 glfwGetRequiredInstanceExtensions
 glfwGetInstanceProcAddress
 glfwGetPhysicalDevicePrésentationSupport
 glfwCréerFenêtreSurface

GLFW utilise des objets de synchronisation en interne uniquement pour gérer le contexte par
thread et les états d'erreur. La synchronisation supplémentaire est laissée à l'application.

Les fonctions qui peuvent actuellement être appelées à partir de n'importe quel thread le
resteront toujours, mais les fonctions actuellement limitées au thread principal pourront être
mises à jour pour autoriser les appels à partir de n'importe quel thread dans les versions futures.

Compatibilité des versions

GLFW utilise la gestion des versions sémantique . Cela garantit la compatibilité ascendante


source et binaire avec les versions mineures antérieures de l'API. Cela signifie que vous pouvez
déposer une version plus récente de la bibliothèque et que les programmes existants
continueront à se compiler et que les binaires existants continueront à s'exécuter.

Une fois qu'une fonction ou une constante a été ajoutée, la signature de cette fonction ou la
valeur de cette constante restera inchangée jusqu'à la prochaine version majeure de
GLFW. Aucune compatibilité d'aucune sorte n'est garantie entre les versions majeures.

Un comportement non documenté, c'est-à-dire un comportement qui n'est pas décrit dans la
documentation, peut changer à tout moment jusqu'à ce qu'il soit documenté.

Si la documentation de référence et l'implémentation diffèrent, la documentation de référence


aura presque toujours la priorité et l'implémentation sera corrigée dans la prochaine version. La
documentation de référence aura également préséance sur tout ce qui est indiqué dans un guide.

Ordre de l'événement

Il n'est pas garanti que l'ordre d'arrivée des événements associés soit cohérent sur toutes les
plateformes. L'exception concerne les événements de relâchement des touches synthétiques et
des boutons de la souris, qui sont toujours fournis après l'événement de défocalisation de la
fenêtre.

Gestion des versions


GLFW fournit des mécanismes pour identifier la version de GLFW avec laquelle votre application
a été compilée ainsi que la version avec laquelle elle s'exécute actuellement. Si vous chargez
GLFW de manière dynamique (pas seulement en créant une liaison dynamique), vous pouvez
l'utiliser pour vérifier que le binaire de la bibliothèque est compatible avec votre application.

Version au moment de la compilation

La version au moment de la compilation de GLFW est fournie par l'en-tête GLFW avec
les macros GLFW_VERSION_MAJOR, GLFW_VERSION_MINORet GLFW_VERSION_REVISION.

printf( "Compilé avec GLFW %i.%i.%i\n" ,


GLFW_VERSION_MAJOR ,
GLFW_VERSION_MINOR ,
GLFW_VERSION_REVISION );

Version d'exécution

La version d'exécution peut être récupérée avec glfwGetVersion , une fonction qui peut être
appelée, que GLFW soit ou non initialisé.

int majeur, mineur, révision;


glfwGetVersion (&majeure, &mineure, &révision);
printf( "Exécution contre GLFW %i.%i.%i\n" , majeur, mineur, révision);

Chaîne de version

GLFW 3 fournit également une chaîne de version générée à la compilation qui décrit la version,
la plate-forme, le compilateur et toutes les options de compilation spécifiques à la plate-
forme. Ceci est principalement destiné à soumettre des rapports de bogues, pour permettre aux
développeurs de voir quels chemins de code sont activés dans un binaire.

La chaîne de version est renvoyée par glfwGetVersionString , une fonction qui peut être
appelée, que GLFW soit ou non initialisé.

N'utilisez pas la chaîne de version pour analyser la version de la bibliothèque


GLFW. La fonction glfwGetVersion fournit déjà la version du binaire de la bibliothèque en cours
d'exécution.

Le format de la chaîne est le suivant :

 La version de GLFW
 Le nom de l'API du système de fenêtres
 Le nom de l'API de création de contexte
 Toutes les options ou API supplémentaires
Par exemple, lors de la compilation de GLFW 3.0 avec MinGW en utilisant les backends Win32 et
WGL, la chaîne de version peut ressembler à ceci :

3.0.0 Win32 WGL MinGW


Guide de fenêtre
Table des matières
 Objets fenêtre

o Création de fenêtre

 Fenêtres plein écran


 Fenêtres "plein écran fenêtré"
 Destruction de vitres
 Conseils pour la création de fenêtres
 Contraintes dures et douces
 Conseils relatifs aux fenêtres
 Conseils relatifs au framebuffer
 Surveiller les astuces liées
 Conseils liés au contexte
 Conseils de fenêtre spécifiques à macOS
 Conseils de fenêtre spécifiques à X11
 Valeurs prises en charge et valeurs par défaut
 Traitement des événements de fenêtre
 Propriétés et événements de la fenêtre
 Pointeur utilisateur
 Indicateur de fermeture et de fermeture de fenêtre
 La taille de la fenêtre
 Taille du tampon d'images
 Échelle du contenu de la fenêtre
 Limites de taille de fenêtre
 Position de la fenêtre
 Titre de la fenêtre
 Icône de fenêtre
 Moniteur de fenêtre
 Iconification de la fenêtre
 Maximisation de la fenêtre
 Visibilité de la fenêtre
 Focus d'entrée de fenêtre
 Demande d'attention de fenêtre
 Dégâts et rafraîchissement des fenêtres
 Transparence de la fenêtre
 Attributs de fenêtre
 Attributs liés à la fenêtre
 Attributs liés au contexte
 Attributs liés au framebuffer
 Échange de tampon
Ce guide présente les fonctions liées aux fenêtres de GLFW. Pour plus de détails sur une
fonction spécifique de cette catégorie, consultez la référence de la fenêtre . Il existe également
des guides pour les autres domaines de GLFW.

 Présentation de l'API
 Guide contextuel
 Guide de Vulkan
 Guide du moniteur
 Guide de saisie

Objets fenêtre
L' objet GLFWwindow encapsule à la fois une fenêtre et un contexte. Ils sont créés
avec glfwCreateWindow et détruits avec glfwDestroyWindow , ou glfwTerminate , s'il en
reste. Comme la fenêtre et le contexte sont inséparablement liés, le pointeur d'objet est utilisé à
la fois comme contexte et comme handle de fenêtre.

Pour voir le flux d'événements fourni aux différents rappels liés aux fenêtres, exécutez
le eventsprogramme de test.

Création de fenêtre

Une fenêtre et son contexte OpenGL ou OpenGL ES sont créés avec glfwCreateWindow , qui
renvoie un handle vers l'objet window créé. Par exemple, cela crée une fenêtre en mode fenêtré
de 640 x 480 :

GLFWwindow * window = glfwCreateWindow (640, 480, "Mon titre" , NULL, NULL);

Si la création de la fenêtre échoue, NULLsera renvoyé, il est donc nécessaire de vérifier la valeur


de retour.

Le handle de fenêtre est transmis à toutes les fonctions liées à la fenêtre et est fourni avec tous
les événements d'entrée, de sorte que les gestionnaires d'événements peuvent indiquer quelle
fenêtre a reçu l'événement.

Fenêtres plein écran

Pour créer une fenêtre plein écran, vous devez spécifier quel moniteur la fenêtre doit
utiliser. Dans la plupart des cas, le moniteur principal de l'utilisateur est un bon choix. Pour plus
d'informations sur la récupération des moniteurs, consultez Récupération des moniteurs .

GLFWwindow * window = glfwCreateWindow (640, 480, "Mon titre" ,


glfwGetPrimaryMonitor (), NULL);
Les fenêtres plein écran couvrent toute la zone d'affichage d'un moniteur, sans bordure ni
décoration.

Les fenêtres en mode fenêtré peuvent être rendues plein écran en définissant un moniteur
avec glfwSetWindowMonitor , et celles en plein écran peuvent être fenêtrées en le désactivant
avec la même fonction.

Chaque champ de la structure GLFWvidmode correspond à un paramètre de fonction ou à un


indice de fenêtre et se combine pour former le mode vidéo souhaité pour cette fenêtre. Le mode
vidéo pris en charge correspondant le plus au mode vidéo souhaité sera défini pour le moniteur
choisi tant que la fenêtre a le focus d'entrée. Pour plus d'informations sur la récupération des
modes vidéo, consultez Modes vidéo .

Champ du mode vidéo Correspond à

GLFWvidmode.width widthparamètre de glfwCreateWindow

GLFWvidmode.height heightparamètre de glfwCreateWindow

GLFWvidmode.redBits GLFW_RED_BITS indice

GLFWvidmode.greenBits GLFW_GREEN_BITS indice

GLFWvidmode.blueBits GLFW_BLUE_BITS indice

GLFWvidmode.refreshRate GLFW_REFRESH_RATE indice

Une fois que vous avez une fenêtre plein écran, vous pouvez modifier sa résolution, sa
fréquence de rafraîchissement et son moniteur avec glfwSetWindowMonitor . Si vous avez
seulement besoin de changer sa résolution, vous pouvez également
appeler glfwSetWindowSize . Dans tous les cas, le nouveau mode vidéo sera sélectionné de la
même manière que le mode vidéo choisi par glfwCreateWindow . Si la fenêtre a un contexte
OpenGL ou OpenGL ES, il ne sera pas affecté.

Par défaut, le mode vidéo d'origine du moniteur sera restauré et la fenêtre iconifiée s'il perd le
focus d'entrée, pour permettre à l'utilisateur de revenir au bureau. Ce comportement peut être
désactivé avec l' indicateur de fenêtre GLFW_AUTO_ICONIFY , par exemple si vous souhaitez
couvrir simultanément plusieurs moniteurs avec des fenêtres plein écran.

Si un moniteur est déconnecté, toutes les fenêtres en plein écran sur ce moniteur passeront en
mode fenêtré. Voir Surveiller les modifications de configuration pour plus d'informations.

Fenêtres "plein écran fenêtré"


Si la correspondance la plus proche pour le mode vidéo souhaité est le mode actuel, le mode
vidéo ne sera pas modifié, ce qui rendra la création de la fenêtre plus rapide et le changement
d'application beaucoup plus fluide. Ceci est parfois appelé plein écran fenêtré ou fenêtre plein
écran sans bordure et compte comme une fenêtre plein écran. Pour créer une telle fenêtre,
demandez le mode vidéo actuel.

const GLFWvidmode * mode = glfwGetVideoMode (moniteur);


glfwWindowHint ( GLFW_RED_BITS , mode- > redBits );
glfwWindowHint ( GLFW_GREEN_BITS , mode- > greenBits );
glfwWindowHint ( GLFW_BLUE_BITS , mode- > blueBits );
glfwWindowHint ( GLFW_REFRESH_RATE , mode- > refreshRate );
GLFWwindow * window = glfwCreateWindow ( mode- > width , mode-> height , "My
Title" , monitor, NULL);

Cela fonctionne également pour les fenêtres en mode fenêtré qui sont affichées en plein écran.

const GLFWvidmode * mode = glfwGetVideoMode (moniteur);


glfwSetWindowMonitor (window, monitor, 0, 0, mode-> width , mode-> height , mode-
> refreshRate );

Notez que glfwGetVideoMode renvoie le mode vidéo actuel d'un moniteur, donc si vous avez


déjà une fenêtre plein écran sur ce moniteur que vous souhaitez faire en plein écran fenêtré,
vous devez avoir enregistré la résolution du bureau auparavant.

Destruction de vitres

Lorsqu'une fenêtre n'est plus nécessaire, détruisez-la avec glfwDestroyWindow .

glfwDestroyWindow (fenêtre);

La destruction des fenêtres réussit toujours. Avant la destruction réelle, tous les rappels sont
supprimés afin qu'aucun autre événement ne soit livré pour la fenêtre. Toutes les fenêtres
restantes lorsque glfwTerminate est appelé sont également détruites.

Lorsqu'une fenêtre plein écran est détruite, le mode vidéo d'origine de son moniteur est restauré,
mais la rampe gamma n'est pas modifiée.

Conseils pour la création de fenêtres

Il existe un certain nombre d'indices qui peuvent être définis avant la création d'une fenêtre et
d'un contexte. Certains affectent la fenêtre elle-même, d'autres affectent le framebuffer ou le
contexte. Ces conseils sont définis sur leurs valeurs par défaut chaque fois que la bibliothèque
est initialisée avec glfwInit . Les conseils de valeur entière peuvent être définis individuellement
avec glfwWindowHint et les conseils de valeur de chaîne avec glfwWindowHintString . Vous
pouvez réinitialiser tous à la fois leurs valeurs par défaut avec glfwDefaultWindowHints .

Certaines astuces sont spécifiques à la plate-forme. Ceux-ci sont toujours valables pour être
définis sur n'importe quelle plate-forme, mais ils n'affecteront que leur plate-forme spécifique. Les
autres plateformes les ignoreront. La définition de ces conseils ne nécessite aucun en-tête ou
appel spécifique à la plate-forme.

Noter

Les indicateurs de fenêtre doivent être définis avant la création de la fenêtre et du


contexte pour lesquels vous souhaitez avoir les attributs spécifiés. Ils fonctionnent
comme des arguments supplémentaires pour glfwCreateWindow .

Contraintes dures et douces

Certains indices de fenêtre sont des contraintes strictes. Ceux-ci doivent


correspondre exactement aux capacités disponibles pour que la création de fenêtres et de
contextes réussisse. Les conseils qui ne sont pas des contraintes strictes sont mis en
correspondance aussi étroitement que possible, mais le contexte et le framebuffer résultants
peuvent différer de ce que ces conseils ont demandé.

Les conseils suivants sont toujours des contraintes strictes :

 GLFW_STEREO
 GLFW_DOUBLEBUFFER
 GLFW_CLIENT_API
 GLFW_CONTEXT_CREATION_API

Les conseils supplémentaires suivants sont des contraintes strictes lors de la demande d'un
contexte OpenGL, mais sont ignorés lors de la demande d'un contexte OpenGL ES :

 GLFW_OPENGL_FORWARD_COMPAT
 GLFW_OPENGL_PROFILE

Conseils relatifs aux fenêtres

GLFW_RESIZABLE spécifie si la fenêtre en mode fenêtré sera redimensionnable par


l'utilisateur . La fenêtre sera toujours redimensionnable à l'aide de
la fonction glfwSetWindowSize . Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Cet
indice est ignoré pour le plein écran et les fenêtres non décorées.
GLFW_VISIBLE spécifie si la fenêtre du mode fenêtré sera initialement visible. Les valeurs
possibles sont GLFW_TRUEet GLFW_FALSE. Ce conseil est ignoré pour les fenêtres plein écran.

GLFW_DECORATED spécifie si la fenêtre en mode fenêtré aura des décorations de fenêtre


telles qu'une bordure, un widget de fermeture, etc. Une fenêtre non décorée ne sera pas
redimensionnable par l'utilisateur mais permettra toujours à l'utilisateur de générer des
événements de fermeture sur certaines plateformes. Les valeurs possibles
sont GLFW_TRUEet GLFW_FALSE. Ce conseil est ignoré pour les fenêtres plein écran.

GLFW_FOCUSED spécifie si la fenêtre en mode fenêtré recevra le focus d'entrée lors de sa


création. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Cet indice est ignoré pour le
plein écran et les fenêtres initialement masquées.

GLFW_AUTO_ICONIFY spécifie si la fenêtre plein écran s'icône automatiquement et restaure le


mode vidéo précédent en cas de perte de mise au point d'entrée. Les valeurs possibles
sont GLFW_TRUEet GLFW_FALSE. Ce conseil est ignoré pour les fenêtres en mode fenêtré.

GLFW_FLOATING spécifie si la fenêtre en mode fenêtré flottera au-dessus d'autres fenêtres


normales, également appelées la plus haute ou toujours au-dessus. Ceci est principalement
destiné à des fins de débogage et ne peut pas être utilisé pour implémenter des fenêtres plein
écran appropriées. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Ce conseil est ignoré
pour les fenêtres plein écran.

GLFW_MAXIMIZED spécifie si la fenêtre en mode fenêtré sera agrandie lors de sa création. Les


valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Ce conseil est ignoré pour les fenêtres plein
écran.

GLFW_CENTER_CURSOR spécifie si le curseur doit être centré sur les fenêtres plein écran
nouvellement créées. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Ce conseil est
ignoré pour les fenêtres en mode fenêtré.

GLFW_TRANSPARENT_FRAMEBUFFER spécifie si le framebuffer de la fenêtre sera


transparent. S'il est activé et pris en charge par le système, le canal alpha du framebuffer de la
fenêtre sera utilisé pour combiner le framebuffer avec l'arrière-plan. Cela n'affecte pas les
décorations de fenêtre. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE.

GLFW_FOCUS_ON_SHOW spécifie si la fenêtre recevra le focus d'entrée


lorsque glfwShowWindow est appelé. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE.

GLFW_SCALE_TO_MONITOR spécifie si la zone de contenu de la fenêtre doit être


redimensionnée en fonction de l' échelle du contenu du moniteur de tout moniteur sur lequel elle
est placée. Cela inclut le placement initial lors de la création de la fenêtre. Les valeurs possibles
sont GLFW_TRUEet GLFW_FALSE.
Cet indice n'a d'effet que sur les plates-formes où les coordonnées d'écran et les pixels
correspondent toujours à 1:1, comme Windows et X11. Sur les plateformes comme macOS, la
résolution du framebuffer est modifiée indépendamment de la taille de la fenêtre.

Conseils relatifs au framebuffer

GLFW_RED_BITS , GLFW_GREEN_BITS , GLFW_BLUE_BITS , GLFW_ALPHA_BITS , GLF
W_DEPTH_BITS et GLFW_STENCIL_BITS spécifient les profondeurs de bits souhaitées des
différents composants du framebuffer par défaut. Une valeur de GLFW_DONT_CAREsignifie que
l'application n'a pas de préférence.

GLFW_ACCUM_RED_BITS , GLFW_ACCUM_GREEN_BITS , GLFW_ACCUM_BLUE_BITS et 
GLFW_ACCUM_ALPHA_BITS spécifient les profondeurs de bits souhaitées des différents
composants du tampon d'accumulation. Une valeur de GLFW_DONT_CAREsignifie que l'application
n'a pas de préférence.

Les tampons d'accumulation sont une fonctionnalité OpenGL héritée et ne doivent pas
être utilisés dans le nouveau code.

GLFW_AUX_BUFFERS spécifie le nombre souhaité de tampons auxiliaires. Une valeur


de GLFW_DONT_CAREsignifie que l'application n'a pas de préférence.

Les tampons auxiliaires sont une fonctionnalité OpenGL héritée et ne doivent pas être
utilisés dans le nouveau code.

GLFW_STEREO spécifie s'il faut utiliser le rendu stéréoscopique OpenGL. Les valeurs possibles


sont GLFW_TRUEet GLFW_FALSE. C'est une contrainte difficile.

GLFW_SAMPLES spécifie le nombre souhaité d'échantillons à utiliser pour le multi-


échantillonnage. Zero désactive le multi-échantillonnage. Une valeur de GLFW_DONT_CAREsignifie
que l'application n'a pas de préférence.

GLFW_SRGB_CAPABLE spécifie si le framebuffer doit être compatible sRGB. Les valeurs


possibles sont GLFW_TRUEet GLFW_FALSE.

OpenGL : s'il est activé et pris en charge par le système,


l' GL_FRAMEBUFFER_SRGBactivation contrôlera le rendu sRGB. Par défaut, le rendu sRGB
sera désactivé.

OpenGL ES : s'il est activé et pris en charge par le système, le contexte aura toujours le
rendu sRGB activé.
GLFW_DOUBLEBUFFER spécifie si le framebuffer doit être mis en double tampon. Vous
souhaitez presque toujours utiliser la double mise en mémoire tampon. C'est une contrainte
difficile. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE.

Surveiller les astuces liées

GLFW_REFRESH_RATE spécifie le taux de rafraîchissement souhaité pour les fenêtres plein


écran. Une valeur de GLFW_DONT_CAREsignifie que le taux de rafraîchissement disponible le plus
élevé sera utilisé. Ce conseil est ignoré pour les fenêtres en mode fenêtré.

Conseils liés au contexte

GLFW_CLIENT_API spécifie pour quelle API client créer le contexte. Les valeurs possibles


sont GLFW_OPENGL_API, GLFW_OPENGL_ES_APIet GLFW_NO_API. C'est une contrainte difficile.

GLFW_CONTEXT_CREATION_API spécifie l'API de création de contexte à utiliser pour créer le


contexte. Les valeurs possibles
sont GLFW_NATIVE_CONTEXT_API, GLFW_EGL_CONTEXT_APIet GLFW_OSMESA_CONTEXT_API. C'
est une contrainte difficile. Si aucune API client n'est demandée, cet indice est ignoré.

macOS : l' API EGL n'est pas disponible sur cette plate-forme et les demandes
d'utilisation échoueront.

Wayland : L'API EGL est l'API de création de contexte natif, donc cet indice n'aura aucun
effet.

OSMesa : Comme son nom l'indique, un contexte OpenGL créé avec OSMesa ne met
pas à jour le contenu de la fenêtre lorsque ses buffers sont permutés. Utilisez les
fonctions OpenGL ou les fonctions d'accès natives
OSMesa glfwGetOSMesaColorBuffer et glfwGetOSMesaDepthBuffer pour récupérer
le contenu du framebuffer.

Noter

Une bibliothèque de chargeur d'extension OpenGL qui suppose qu'elle sait quelle API de
création de contexte est utilisée sur une plate-forme donnée peut échouer si vous
modifiez cet indice. Cela peut être résolu en le chargeant via glfwGetProcAddress , qui
utilise toujours l'API sélectionnée.

Bogue:
Sur certains systèmes Linux, la création de contextes via les API natives et EGL en un
seul processus entraînera une erreur de segmentation de l'application. Tenez-vous en à
une API ou à l'autre sur Linux pour le moment.

GLFW_CONTEXT_VERSION_MAJOR et GLFW_CONTEXT_VERSION_MINOR spécifient la
version de l'API client avec laquelle le contexte créé doit être compatible. Le comportement exact
de ces conseils dépend de l'API client demandée.

Noter

Ne confondez pas ces conseils avec GLFW_VERSION_MAJORet GLFW_VERSION_MINOR,


qui fournissent la version API de l'en-tête GLFW.

OpenGL : ces conseils ne sont pas des contraintes strictes, mais la création échouera si
la version OpenGL du contexte créé est inférieure à celle demandée. Il est donc
parfaitement sûr d'utiliser la valeur par défaut de la version 1.0 pour le code hérité et vous
obtiendrez toujours les contextes rétrocompatibles de la version 3.0 et supérieure
lorsqu'ils seront disponibles.

Bien qu'il n'y ait aucun moyen de demander au pilote un contexte de la version la plus
élevée prise en charge, GLFW tentera de le fournir lorsque vous demanderez un contexte
de version 1.0, qui est la valeur par défaut pour ces conseils.

OpenGL ES : ces conseils ne sont pas des contraintes strictes, mais la création
échouera si la version OpenGL ES du contexte créé est inférieure à celle demandée. De
plus, OpenGL ES 1.x ne peut pas être renvoyé si la version 2.0 ou ultérieure a été
demandée, et vice versa. En effet, OpenGL ES 3.x est rétrocompatible avec 2.0, mais
OpenGL ES 2.0 n'est pas rétrocompatible avec 1.x.

Noter

macOS : le système d'exploitation ne prend en charge que les contextes de profil de
base à compatibilité ascendante pour les versions 3.2 et ultérieures d'OpenGL. Avant de
créer un contexte OpenGL de version 3.2 ou ultérieure, vous devez définir les conseils
GLFW_OPENGL_FORWARD_COMPAT et GLFW_OPENGL_PROFILE
en conséquence. Les contextes OpenGL 3.0 et 3.1 ne sont pas du tout pris en charge sur
macOS.
GLFW_OPENGL_FORWARD_COMPAT spécifie si le contexte OpenGL doit être compatible
vers l'avant, c'est-à-dire un contexte où toutes les fonctionnalités obsolètes dans la version
demandée d'OpenGL sont supprimées. Cela ne doit être utilisé que si la version OpenGL
demandée est 3.0 ou supérieure. Si OpenGL ES est demandé, cet indice est ignoré.

La compatibilité ascendante est décrite en détail dans le manuel de référence OpenGL .

GLFW_OPENGL_DEBUG_CONTEXT spécifie si le contexte doit être créé en mode débogage,


ce qui peut fournir des fonctionnalités supplémentaires de rapport d'erreur et de diagnostic. Les
valeurs possibles sont GLFW_TRUEet GLFW_FALSE.

Les contextes de débogage pour OpenGL et OpenGL ES sont décrits en détail par
l' extension GL_KHR_debug .

GLFW_OPENGL_PROFILE spécifie pour quel profil OpenGL créer le contexte. Les valeurs


possibles sont l'une de GLFW_OPENGL_CORE_PROFILEou GLFW_OPENGL_COMPAT_PROFILE,
ou GLFW_OPENGL_ANY_PROFILEpour ne pas demander un profil spécifique. Si vous demandez
une version OpenGL inférieure à 3.2, GLFW_OPENGL_ANY_PROFILEdoit être utilisé. Si OpenGL
ES est demandé, cet indice est ignoré.

Les profils OpenGL sont décrits en détail dans le manuel de référence OpenGL .

GLFW_CONTEXT_ROBUSTNESS spécifie la stratégie de robustesse à utiliser par le contexte. Il


peut s'agir de GLFW_NO_RESET_NOTIFICATIONou GLFW_LOSE_CONTEXT_ON_RESET,
ou GLFW_NO_ROBUSTNESSde ne pas demander une stratégie de robustesse.

GLFW_CONTEXT_RELEASE_BEHAVIOR spécifie le comportement de libération à utiliser par


le contexte. Les valeurs possibles sont l'une
de GLFW_ANY_RELEASE_BEHAVIOR, GLFW_RELEASE_BEHAVIOR_FLUSHou GLFW_RELEASE_BEHA
VIOR_NONE. Si le comportement est GLFW_ANY_RELEASE_BEHAVIOR, le comportement par
défaut de l'API de création de contexte sera utilisé. Si le comportement
est GLFW_RELEASE_BEHAVIOR_FLUSH, le pipeline sera vidé chaque fois que le contexte n'est
plus le contexte actuel. Si le comportement est GLFW_RELEASE_BEHAVIOR_NONE, le pipeline ne
sera pas vidé lors de la libération.

Les comportements de libération de contexte sont décrits en détail par


l' extension GL_KHR_context_flush_control .

GLFW_CONTEXT_NO_ERROR spécifie si des erreurs doivent être générées par le


contexte. Les valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Si cette option est activée, les
situations qui auraient généré des erreurs provoquent à la place un comportement indéfini.
Le mode sans erreur pour OpenGL et OpenGL ES est décrit en détail par
l' extension GL_KHR_no_error .

Conseils de fenêtre spécifiques à macOS

GLFW_COCOA_RETINA_FRAMEBUFFER spécifie s'il faut utiliser des tampons d'images en


pleine résolution sur les écrans Retina. Les valeurs possibles
sont GLFW_TRUEet GLFW_FALSE. Ceci est ignoré sur les autres plates-formes.

GLFW_COCOA_FRAME_NAME spécifie le nom encodé UTF-8 à utiliser pour l'enregistrement


automatique du cadre de la fenêtre, ou si vide désactive l'enregistrement automatique du cadre
pour la fenêtre. Ceci est ignoré sur les autres plates-formes. Ceci est défini
avec glfwWindowHintString .

GLFW_COCOA_GRAPHICS_SWITCHING spécifie s'il faut en commutation graphique


automatique, c'est-à-dire permettre au système de choisir le GPU intégré pour le contexte
OpenGL et de le déplacer entre les GPU si nécessaire ou de le forcer à toujours fonctionner sur
le GPU discret. Cela n'affecte que les systèmes avec des GPU intégrés et discrets. Les valeurs
possibles sont GLFW_TRUEet GLFW_FALSE. Ceci est ignoré sur les autres plates-formes.

Des programmes et des outils plus simples peuvent vouloir activer cela pour économiser
de l'énergie, tandis que les jeux et autres applications effectuant un rendu avancé
voudront le laisser désactivé.

Une application groupée qui souhaite participer à la commutation graphique automatique


doit également le déclarer dans son Info.plistfichier en définissant
la NSSupportsAutomaticGraphicsSwitchingclé sur true.

Conseils de fenêtre spécifiques à X11

GLFW_X11_CLASS_NAME et GLFW_X11_INSTANCE_NAME spécifient les parties de classe


et d'instance codées ASCII souhaitées de la WM_CLASSpropriété de fenêtre ICCCM . Ceux-ci sont
définis avec glfwWindowHintString .

Valeurs prises en charge et valeurs par défaut


Valeur par
Indice de fenêtre Valeurs prises en charge
défaut

GLFW_RESIZABLE GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE

GLFW_VISIBLE GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE

GLFW_DECORATED GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE

GLFW_FOCUSED GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE


GLFW_AUTO_ICONI
GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE
FY

GLFW_FLOATING GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE

GLFW_MAXIMISED GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE

GLFW_CENTER_CU
GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE
RSOR

GLFW_TRANSPARE
GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE
NT_FRAMEBUFFER

GLFW_FOCUS_ON_
GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE
SHOW

GLFW_SCALE_TO_
GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE
MONITOR

GLFW_RED_BITS 8 0 à INT_MAXouGLFW_DONT_CARE

GLFW_GREEN_BITS 8 0 à INT_MAXouGLFW_DONT_CARE

GLFW_BLUE_BITS 8 0 à INT_MAXouGLFW_DONT_CARE

GLFW_ALPHA_BITS 8 0 à INT_MAXouGLFW_DONT_CARE

GLFW_DEPTH_BITS 24 0 à INT_MAXouGLFW_DONT_CARE

GLFW_STENCIL_BIT
8 0 à INT_MAXouGLFW_DONT_CARE
S

GLFW_ACCUM_RED
0 0 à INT_MAXouGLFW_DONT_CARE
_BITS

GLFW_ACCUM_GR
0 0 à INT_MAXouGLFW_DONT_CARE
EEN_BITS

GLFW_ACCUM_BLU
0 0 à INT_MAXouGLFW_DONT_CARE
E_BITS

GLFW_ACCUM_ALP
0 0 à INT_MAXouGLFW_DONT_CARE
HA_BITS

GLFW_AUX_BUFFE
0 0 à INT_MAXouGLFW_DONT_CARE
RS

GLFW_SAMPLES 0 0 à INT_MAXouGLFW_DONT_CARE
GLFW_REFRESH_R GLFW_DONT_CA
0 à INT_MAXouGLFW_DONT_CARE
ATE RE

GLFW_STEREO GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE

GLFW_SRGB_CAPA
GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE
BLE

GLFW_DOUBLEBUF
GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE
FER

GLFW_OPENGL_ GLFW_OPENGL_API, GLFW_OPENGL_ES_APIouGLFW
GLFW_CLIENT_API
API _NO_API

GLFW_CONTEXT_C GLFW_NATIVE_ GLFW_NATIVE_CONTEXT_API, GLFW_EGL_CONTEXT


REATION_API CONTEXT_API _APIouGLFW_OSMESA_CONTEXT_API

GLFW_CONTEXT_V Tout numéro de version majeure valide de l'API


1
ERSION_MAJOR client choisie

GLFW_CONTEXT_V Tout numéro de version mineure valide de l'API


0
ERSION_MINOR client choisie

GLFW_CONTEXT_R GLFW_NO_ROBU GLFW_NO_ROBUSTNESS, GLFW_NO_RESET_NOTIFIC


OBUSTNESS STNESS ATIONouGLFW_LOSE_CONTEXT_ON_RESET

GLFW_ANY_REL GLFW_ANY_RELEASE_BEHAVIOR, GLFW_RELEASE_B
GLFW_CONTEXT_R
EASE_BEHAVIO EHAVIOR_FLUSHouGLFW_RELEASE_BEHAVIOR_NON
ELEASE_BEHAVIOR
R E

GLFW_OPENGL_FO
GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE
RWARD_COMPAT

GLFW_OPENGL_DE
GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE
BUG_CONTEXT

GLFW_OPENGL_PR GLFW_OPENGL_ GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_COMP


OFILE ANY_PROFILE AT_PROFILEouGLFW_OPENGL_CORE_PROFILE

GLFW_COCOA_RET
GLFW_TRUE GLFW_TRUE ou alors GLFW_FALSE
INA_FRAMEBUFFER

GLFW_COCOA_FRA Un nom d'enregistrement automatique de trame


""
ME_NAME codé en UTF-8

GLFW_COCOA_GR GLFW_FALSE GLFW_TRUE ou alors GLFW_FALSE


APHICS_SWITCHIN
G

GLFW_X11_CLASS_
"" Un WM_CLASSnom de classe codé en ASCII
NAME

GLFW_X11_INSTAN
"" Un WM_CLASSnom d'instance codé en ASCII
CE_NAME

Traitement des événements de fenêtre


Voir Traitement des événements .

Propriétés et événements de la fenêtre


Pointeur utilisateur

Chaque fenêtre a un pointeur utilisateur qui peut être défini avec glfwSetWindowUserPointer et


interrogé avec glfwGetWindowUserPointer . Cela peut être utilisé à toutes fins utiles et ne sera
pas modifié par GLFW pendant toute la durée de vie de la fenêtre.

La valeur initiale du pointeur est NULL.

Indicateur de fermeture et de fermeture de fenêtre

Lorsque l'utilisateur tente de fermer la fenêtre, par exemple en cliquant sur le widget de fermeture
ou en utilisant un accord clé comme Alt+F4, l' indicateur de fermeture de la fenêtre est défini. La
fenêtre n'est cependant pas réellement détruite et, à moins que vous ne surveilliez ce
changement d'état, rien d'autre ne se passe.

L'état actuel de l'indicateur de fermeture est renvoyé par glfwWindowShouldClose et peut être


défini ou effacé directement avec glfwSetWindowShouldClose . Un modèle courant consiste à
utiliser l'indicateur de fermeture comme condition de boucle principale.

while (! glfwWindowShouldClose (fenêtre))


{
rendu (fenêtre);
glfwSwapBuffers (fenêtre);
glfwPollEvents ();
}

Si vous souhaitez être averti lorsque l'utilisateur tente de fermer une fenêtre, définissez un rappel
de fermeture.
glfwSetWindowCloseCallback (fenêtre, window_close_callback);

La fonction de rappel est appelée directement après que l'indicateur de fermeture a été défini. Il


peut être utilisé par exemple pour filtrer les demandes de fermeture et effacer à nouveau
l'indicateur de fermeture à moins que certaines conditions ne soient remplies.

void window_close_callback( GLFWwindow * fenêtre)


{
si (!time_to_close)
glfwSetWindowShouldClose (fenêtre, GLFW_FALSE );
}

La taille de la fenêtre

La taille d'une fenêtre peut être modifiée avec glfwSetWindowSize . Pour les fenêtres en mode
fenêtré, cela définit la taille, en coordonnées d'écran, de la zone de contenu ou de la
zone de contenu de la fenêtre. Le système de fenêtre peut imposer des limites sur la taille de la
fenêtre.

glfwSetWindowSize (fenêtre, 640, 480);

Pour les fenêtres plein écran, la taille spécifiée devient la nouvelle résolution du mode vidéo
souhaité de la fenêtre. Le mode vidéo correspondant le mieux au nouveau mode vidéo souhaité
est défini immédiatement. La fenêtre est redimensionnée pour s'adapter à la résolution du mode
vidéo défini.

Si vous souhaitez être averti lorsqu'une fenêtre est redimensionnée, que ce soit par l'utilisateur,
le système ou votre propre code, définissez un rappel de taille.

glfwSetWindowSizeCallback (fenêtre, window_size_callback);

La fonction de rappel reçoit la nouvelle taille, en coordonnées d'écran, de la zone de contenu de


la fenêtre lorsque la fenêtre est redimensionnée.

vide window_size_callback ( GLFWwindow * fenêtre, int largeur, int hauteur)


{
}

Il existe également glfwGetWindowSize pour récupérer directement la taille actuelle d'une


fenêtre.

int largeur, hauteur;


glfwGetWindowSize (fenêtre, &largeur, &hauteur);
Noter

Ne transmettez pas la taille de la fenêtre à glViewportou à d'autres appels OpenGL


basés sur des pixels. La taille de la fenêtre est en coordonnées d'écran, pas en
pixels. Utilisez la taille du framebuffer , qui est en pixels, pour les appels basés sur des
pixels.

Les fonctions ci-dessus fonctionnent avec la taille de la zone de contenu, mais les fenêtres
décorées ont généralement des barres de titre et des cadres de fenêtre autour de ce
rectangle. Vous pouvez récupérer l'étendue de ceux-ci avec glfwGetWindowFrameSize .

int gauche, haut, droite, bas ;


glfwGetWindowFrameSize (fenêtre, &gauche, &haut, &droite, &bas);

Les valeurs renvoyées sont les distances, en coordonnées d'écran, entre les bords de la zone de
contenu et les bords correspondants de la fenêtre complète. Comme ce sont des distances et
non des coordonnées, elles sont toujours nulles ou positives.

Taille du tampon d'images

Alors que la taille d'une fenêtre est mesurée en coordonnées d'écran, OpenGL fonctionne avec
des pixels. La taille que vous passez dans glViewport, par exemple, doit être en pixels. Sur
certaines machines, les coordonnées d'écran et les pixels sont les mêmes, mais sur d'autres, ils
ne le seront pas. Il existe un deuxième ensemble de fonctions pour récupérer la taille, en pixels,
du framebuffer d'une fenêtre.

Si vous souhaitez être averti lorsque le framebuffer d'une fenêtre est redimensionné, que ce soit
par l'utilisateur ou le système, définissez un rappel de taille.

glfwSetFramebufferSizeCallback (fenêtre, framebuffer_size_callback);

La fonction de rappel reçoit la nouvelle taille du framebuffer lorsqu'il est redimensionné, ce qui
peut par exemple être utilisé pour mettre à jour la fenêtre OpenGL.

vide framebuffer_size_callback ( GLFWwindow * fenêtre, int largeur, int hauteur)


{
glViewport(0, 0, largeur, hauteur);
}

Il existe également glfwGetFramebufferSize pour récupérer directement la taille actuelle du


framebuffer d'une fenêtre.
int largeur, hauteur;
glfwGetFramebufferSize (fenêtre, &largeur, &hauteur);
glViewport(0, 0, largeur, hauteur);

La taille d'un framebuffer peut changer indépendamment de la taille d'une fenêtre, par exemple si
la fenêtre est déplacée entre un moniteur ordinaire et un moniteur à haute résolution.

Échelle du contenu de la fenêtre

L'échelle de contenu d'une fenêtre peut être récupérée avec glfwGetWindowContentScale .

float xscale, yscale;


glfwGetWindowContentScale (fenêtre, &xscale, &yscale);

L'échelle du contenu est le rapport entre le DPI actuel et le DPI par défaut de la plate-forme. Ceci
est particulièrement important pour le texte et tous les éléments de l'interface utilisateur. Si les
dimensions en pixels de votre interface utilisateur mises à l'échelle par cela semblent appropriées
sur votre machine, elles devraient apparaître à une taille raisonnable sur les autres machines,
quels que soient leurs paramètres DPI et de mise à l'échelle. Cela repose sur le fait que les
paramètres DPI et de mise à l'échelle du système sont quelque peu corrects.

Sur les systèmes où chaque moniteur peut avoir sa propre échelle de contenu, l'échelle de
contenu de la fenêtre dépendra du moniteur sur lequel le système considère que la fenêtre se
trouve.

Si vous souhaitez être averti lorsque l'échelle de contenu d'une fenêtre change, que ce soit en
raison d'un changement de paramètre système ou parce qu'elle a été déplacée vers un moniteur
avec une échelle différente, définissez un rappel d'échelle de contenu.

glfwSetWindowContentScaleCallback (fenêtre, window_content_scale_callback);

La fonction de rappel reçoit la nouvelle échelle de contenu de la fenêtre.

void window_content_scale_callback( GLFWwindow * fenêtre, float xscale, float


yscale)
{
set_interface_scale(xscale, yscale);
}

Sur les plates-formes où les pixels et les coordonnées d'écran correspondent toujours à 1:1, la
fenêtre devra être redimensionnée pour apparaître à la même taille lorsqu'elle est déplacée vers
un moniteur avec une échelle de contenu différente. Pour que cela se fasse automatiquement à
la fois lors de la création de la fenêtre et lorsque son échelle de contenu change ultérieurement,
définissez l' indicateur de fenêtre GLFW_SCALE_TO_MONITOR .
Limites de taille de fenêtre

La taille minimale et maximale de la zone de contenu d'une fenêtre en mode fenêtré peut être
imposée avec glfwSetWindowSizeLimits . L'utilisateur peut redimensionner la fenêtre à
n'importe quelle taille et rapport d'aspect dans les limites spécifiées, à moins que le rapport
d'aspect ne soit également défini.

glfwSetWindowSizeLimits (fenêtre, 200, 200, 400, 400);

Pour spécifier uniquement une taille minimale ou une taille maximale, définissez l'autre paire
sur GLFW_DONT_CARE.

glfwSetWindowSizeLimits (fenêtre, 640, 480, GLFW_DONT_CARE , GLFW_DONT_CARE );

Pour désactiver les limites de taille d'une fenêtre, définissez-les toutes sur GLFW_DONT_CARE.

Le rapport hauteur/largeur de la zone de contenu d'une fenêtre en mode fenêtré peut être
appliqué avec glfwSetWindowAspectRatio . L'utilisateur peut redimensionner la fenêtre
librement à moins que des limites de taille ne soient également définies, mais la taille sera
contrainte de maintenir le rapport hauteur/largeur.

glfwSetWindowAspectRatio (fenêtre, 16, 9);

Le rapport hauteur/largeur est spécifié sous forme de numérateur et de dénominateur,


correspondant respectivement à la largeur et à la hauteur. Si vous souhaitez qu'une fenêtre
conserve son rapport hauteur/largeur actuel, utilisez sa taille actuelle comme rapport.

int largeur, hauteur;


glfwGetWindowSize (fenêtre, &largeur, &hauteur);
glfwSetWindowAspectRatio (fenêtre, largeur, hauteur);

Pour désactiver la limite de rapport hauteur/largeur pour une fenêtre, définissez les deux termes
sur GLFW_DONT_CARE.

Vous pouvez définir à la fois des limites de taille et des proportions pour une fenêtre, mais les
résultats ne sont pas définis s'ils sont en conflit.

Position de la fenêtre

La position d'une fenêtre en mode fenêtré peut être modifiée avec glfwSetWindowPos . Cela


déplace la fenêtre de sorte que le coin supérieur gauche de sa zone de contenu ait
les coordonnées d'écran spécifiées . Le système de fenêtres peut imposer des limites sur le
placement des fenêtres.
glfwSetWindowPos (fenêtre, 100, 100);

Si vous souhaitez être averti lorsqu'une fenêtre est déplacée, que ce soit par l'utilisateur, le
système ou votre propre code, définissez un rappel de position.

glfwSetWindowPosCallback (fenêtre, window_pos_callback);

La fonction de rappel reçoit la nouvelle position, en coordonnées d'écran, du coin supérieur


gauche de la zone de contenu lorsque la fenêtre est déplacée.

void window_pos_callback( GLFWwindow * fenêtre, int xpos, int ypos)


{
}

Il existe également glfwGetWindowPos pour récupérer directement la position actuelle de la


zone de contenu de la fenêtre.

int xpos, ypos;


glfwGetWindowPos (fenêtre, &xpos, &ypos);

Titre de la fenêtre

Toutes les fenêtres GLFW ont un titre, bien que les fenêtres non décorées ou plein écran
puissent ne pas l'afficher ou ne l'afficher que dans une barre des tâches ou une interface
similaire. Vous pouvez définir un titre de fenêtre codé en UTF-8 avec glfwSetWindowTitle .

glfwSetWindowTitle (fenêtre, "Ma fenêtre" );

La chaîne spécifiée est copiée avant le retour de la fonction, il n'est donc pas nécessaire de la
conserver.

Tant que votre fichier source est encodé en UTF-8, vous pouvez utiliser n'importe quel caractère
Unicode directement dans la source.

glfwSetWindowTitle (fenêtre, "ラストエグザイル" );

Si vous utilisez C++11 ou C11, vous pouvez utiliser un littéral de chaîne UTF-8.

glfwSetWindowTitle (fenêtre, u8 "Ceci est toujours une chaîne UTF-8" );

Icône de fenêtre

Les fenêtres décorées ont des icônes sur certaines plates-formes. Vous pouvez définir cette
icône en spécifiant une liste d'images candidates avec glfwSetWindowIcon .
Images GLFWimage [2];
images[0] = load_icon( "my_icon.png" );
images[1] = load_icon( "my_icon_small.png" );
glfwSetWindowIcon (fenêtre, 2, images);

Les données d'image sont 32 bits, little-endian, RGBA non prémultiplié, c'est-à-dire huit bits par
canal avec le canal rouge en premier. Les pixels sont disposés de manière canonique sous
forme de rangées séquentielles, à partir du coin supérieur gauche.

Pour revenir à l'icône de fenêtre par défaut, transmettez un tableau d'images vide.

glfwSetWindowIcon (fenêtre, 0, NULL);

Moniteur de fenêtre

Les fenêtres plein écran sont associées à un moniteur spécifique. Vous pouvez obtenir le handle
de ce moniteur avec glfwGetWindowMonitor .

GLFWmonitor * moniteur = glfwGetWindowMonitor (fenêtre);

Ce handle de moniteur est l'un de ceux renvoyés par glfwGetMonitors .

Pour les fenêtres en mode fenêtré, cette fonction renvoie NULL. Voici comment distinguer les
fenêtres plein écran des fenêtres en mode fenêtré.

Vous pouvez déplacer les fenêtres entre les moniteurs ou entre le mode plein écran et le mode
fenêtré avec glfwSetWindowMonitor . Lorsque vous créez une fenêtre en plein écran sur le
même moniteur ou sur un autre moniteur, spécifiez le moniteur, la résolution et la fréquence de
rafraîchissement souhaités. Les arguments de position sont ignorés.

const GLFWvidmode * mode = glfwGetVideoMode (moniteur);


glfwSetWindowMonitor (window, monitor, 0, 0, mode-> width , mode-> height , mode-
> refreshRate );

Lorsque vous créez une fenêtre fenêtrée, spécifiez la position et la taille souhaitées. L'argument
du taux de rafraîchissement est ignoré.

glfwSetWindowMonitor (fenêtre, NULL, xpos, ypos, largeur, hauteur, 0);

Cela restaure tous les paramètres de fenêtre précédents tels que si elle est décorée, flottante,
redimensionnable, a des limites de taille ou de rapport d'aspect, etc. Pour restaurer une fenêtre
qui était à l'origine fenêtrée à sa taille et à sa position d'origine, enregistrez-les avant de la faire
plein écran puis passez-les comme ci-dessus.
Iconification de la fenêtre

Windows peut être iconifié (c'est-à-dire minimisé) avec glfwIconifyWindow .

glfwIconifyWindow (fenêtre);

Lorsqu'une fenêtre plein écran est iconifiée, le mode vidéo d'origine de son moniteur est restauré
jusqu'à ce que l'utilisateur ou l'application restaure la fenêtre.

Les fenêtres iconifiées peuvent être restaurées avec glfwRestoreWindow . Cette fonction


restaure également les fenêtres à partir de la maximisation.

glfwRestoreWindow (fenêtre);

Lorsqu'une fenêtre plein écran est restaurée, le mode vidéo souhaité est également restauré sur
son moniteur.

Si vous souhaitez être averti lorsqu'une fenêtre est iconifiée ou restaurée, que ce soit par
l'utilisateur, le système ou votre propre code, définissez un rappel d'iconification.

glfwSetWindowIconifyCallback (fenêtre, window_iconify_callback);

La fonction de rappel reçoit les changements dans l'état d'iconification de la fenêtre.

void window_iconify_callback( GLFWwindow * fenêtre, int iconifié)


{
si (iconifié)
{
// La fenêtre a été iconifiée
}
autre
{
// La fenêtre a été restaurée
}
}

Vous pouvez également obtenir l'état actuel de l'iconification avec glfwGetWindowAttrib .

int iconified = glfwGetWindowAttrib (fenêtre, GLFW_ICONIFIED );

Maximisation de la fenêtre

Les fenêtres peuvent être agrandies (c'est-à-dire agrandies) avec glfwMaximizeWindow .


glfwMaximizeWindow (fenêtre);

Les fenêtres plein écran ne peuvent pas être agrandies et passer une fenêtre plein écran à cette
fonction ne fait rien.

Les fenêtres maximisées peuvent être restaurées avec glfwRestoreWindow . Cette fonction


restaure également les fenêtres à partir de l'iconification.

glfwRestoreWindow (fenêtre);

Si vous souhaitez être averti lorsqu'une fenêtre est agrandie ou restaurée, que ce soit par
l'utilisateur, le système ou votre propre code, définissez un rappel d'agrandissement.

glfwSetWindowMaximizeCallback (fenêtre, window_maximize_callback);

La fonction de rappel reçoit les modifications de l'état de maximisation de la fenêtre.

vide window_maximize_callback ( GLFWwindow * fenêtre, int maximisée)


{
si (maximisé)
{
// La fenêtre a été maximisée
}
autre
{
// La fenêtre a été restaurée
}
}

Vous pouvez également obtenir l'état de maximisation actuel avec glfwGetWindowAttrib .

int maximisé = glfwGetWindowAttrib (fenêtre, GLFW_MAXIMIZED );

Par défaut, les fenêtres nouvellement créées ne sont pas agrandies. Vous pouvez modifier ce
comportement en définissant l' indicateur de fenêtre GLFW_MAXIMIZED avant de créer la
fenêtre.

glfwWindowHint ( GLFW_MAXIMISE , GLFW_TRUE );

Visibilité de la fenêtre

Les fenêtres en mode fenêtré peuvent être masquées avec glfwHideWindow .

glfwHideWindow (fenêtre);
Cela rend la fenêtre complètement invisible pour l'utilisateur, y compris en la supprimant de la
barre des tâches, du dock ou de la liste des fenêtres. Les fenêtres plein écran ne peuvent pas
être masquées et l'appel de glfwHideWindow sur une fenêtre plein écran ne fait rien.

Les fenêtres cachées peuvent être affichées avec glfwShowWindow .

glfwShowWindow (fenêtre);

Par défaut, cette fonction définira également le focus d'entrée sur cette fenêtre. Définissez
l' indicateur de fenêtre GLFW_FOCUS_ON_SHOW pour modifier ce comportement pour toutes
les fenêtres nouvellement créées, ou modifiez le comportement d'une fenêtre existante
avec glfwSetWindowAttrib .

Vous pouvez également obtenir l'état de visibilité actuel avec glfwGetWindowAttrib .

int visible = glfwGetWindowAttrib (fenêtre, GLFW_VISIBLE );

Par défaut, les fenêtres nouvellement créées sont visibles. Vous pouvez modifier ce
comportement en définissant l' indicateur de fenêtre GLFW_VISIBLE avant de créer la fenêtre.

glfwWindowHint ( GLFW_VISIBLE , GLFW_FALSE );

Les fenêtres créées masquées sont complètement invisibles pour l'utilisateur jusqu'à ce qu'elles
soient affichées. Cela peut être utile si vous devez configurer davantage votre fenêtre avant de
l'afficher, par exemple en la déplaçant vers un emplacement spécifique.

Focus d'entrée de fenêtre

Windows peut recevoir le focus d'entrée et être mis au premier plan avec glfwFocusWindow .

glfwFocusWindow (fenêtre);

Gardez à l'esprit que cela peut être très perturbant pour l'utilisateur lorsqu'une fenêtre est forcée
vers le haut. Pour un moyen moins perturbateur d'attirer l'attention de l'utilisateur, consultez
les demandes d'attention .

Si vous souhaitez être averti lorsqu'une fenêtre gagne ou perd le focus d'entrée, que ce soit par
l'utilisateur, le système ou votre propre code, définissez un rappel de focus.

glfwSetWindowFocusCallback (fenêtre, window_focus_callback);

La fonction de rappel reçoit les modifications de l'état du focus d'entrée de la fenêtre.

void window_focus_callback( GLFWwindow * fenêtre, int focalisé)


{
si (concentré)
{
// La fenêtre a obtenu le focus d'entrée
}
autre
{
// La fenêtre a perdu le focus d'entrée
}
}

Vous pouvez également obtenir l'état actuel du focus d'entrée avec glfwGetWindowAttrib .

int focus = glfwGetWindowAttrib (fenêtre, GLFW_FOCUSED );

Par défaut, les fenêtres nouvellement créées reçoivent le focus d'entrée. Vous pouvez modifier
ce comportement en définissant l' indicateur de fenêtre GLFW_FOCUSED avant de créer la
fenêtre.

glfwWindowHint ( GLFW_FOCUSED , GLFW_FALSE );

Demande d'attention de fenêtre

Si vous souhaitez informer l'utilisateur d'un événement sans interrompre, vous pouvez demander
son attention avec glfwRequestWindowAttention .

glfwRequestWindowAttention (fenêtre);

Le système mettra en évidence la fenêtre spécifiée, ou sur les plates-formes où cela n'est pas
pris en charge, l'application dans son ensemble. Une fois que l'utilisateur y a prêté attention, le
système mettra automatiquement fin à la demande.

Dégâts et rafraîchissement des fenêtres

Si vous souhaitez être averti lorsque le contenu d'une fenêtre est endommagé et doit être
actualisé, définissez un rappel d'actualisation de fenêtre.

glfwSetWindowRefreshCallback (m_handle, window_refresh_callback);

La fonction de rappel est appelée lorsque le contenu de la fenêtre doit être actualisé.

void window_refresh_callback( GLFWwindow * fenêtre)


{
draw_editor_ui(fenêtre);
glfwSwapBuffers (fenêtre);
}

Noter

Sur les systèmes de fenêtre de composition tels que Aero, Compiz ou Aqua, où le
contenu de la fenêtre est enregistré hors écran, ce rappel peut être appelé uniquement
lorsque la fenêtre ou le framebuffer est redimensionné.

Transparence de la fenêtre

GLFW prend en charge deux types de transparence pour les fenêtres ; la transparence du
framebuffer et la transparence de toute la fenêtre. Une seule fenêtre ne peut pas utiliser les deux
méthodes. Les résultats de cette opération ne sont pas définis.

Les deux méthodes nécessitent que la plate-forme les supporte et toutes les versions de toutes
les plates-formes prises en charge par GLFW ne le font pas, il existe donc des mécanismes pour
vérifier si la fenêtre est vraiment transparente.

Les framebuffers de fenêtre peuvent être rendus transparents pixel par image avec l' indice
de fenêtre GLFW_TRANSPARENT_FRAMEBUFFER .

glfwWindowHint ( GLFW_TRANSPARENT_FRAMBUFFER , GLFW_TRUE );

Si pris en charge par le système, la zone de contenu de la fenêtre sera composée avec l'arrière-
plan à l'aide du canal alpha framebuffer par pixel. Cela nécessite que la composition de bureau
soit activée sur le système. Il n'affecte pas les décorations de fenêtres.

Vous pouvez vérifier si le framebuffer de fenêtre a été rendu transparent avec succès avec
l' attribut de fenêtre GLFW_TRANSPARENT_FRAMEBUFFER .

if ( glfwGetWindowAttrib (fenêtre, GLFW_TRANSPARENT_FRAMEBUFFER ))


{
// le framebuffer de la fenêtre est actuellement transparent
}

GLFW est livré avec un exemple qui a activé la transparence du framebuffer appelé gears.

L'opacité de toute la fenêtre, y compris les décorations, peut être définie


avec glfwSetWindowOpacity .

glfwSetWindowOpacity (fenêtre, 0.5f);


La valeur d'opacité (ou alpha) est un nombre fini positif compris entre zéro et un, où 0 (zéro) est
totalement transparent et 1 (un) est totalement opaque. La valeur d'opacité initiale pour les
fenêtres nouvellement créées est 1.

L'opacité actuelle d'une fenêtre peut être interrogée avec glfwGetWindowOpacity .

float opacity = glfwGetWindowOpacity (fenêtre);

Si le système ne prend pas en charge la transparence de toute la fenêtre, cette fonction en


renvoie toujours une.

GLFW est livré avec un programme de test qui vous permet de contrôler la transparence de
l'ensemble de la fenêtre au moment de l'exécution, appelé opacity.

Attributs de fenêtre

Windows a un certain nombre d'attributs qui peuvent être renvoyés à l'aide


de glfwGetWindowAttrib . Certains reflètent l'état qui peut changer à la suite de l'interaction de
l'utilisateur (par exemple, si elle a le focus d'entrée), tandis que d'autres reflètent les propriétés
inhérentes de la fenêtre (par exemple, quel type de bordure elle a). Certains sont liés à la fenêtre
et d'autres à son contexte OpenGL ou OpenGL ES.

if ( glfwGetWindowAttrib (fenêtre, GLFW_FOCUSED ))


{
// la fenêtre a le focus d'entrée
}

Les attributs
de fenêtre GLFW_DECORATED , GLFW_RESIZABLE , GLFW_FLOATING , GLFW_AUTO_IC
ONIFY et GLFW_FOCUS_ON_SHOW peuvent être modifiés avec glfwSetWindowAttrib .

glfwSetWindowAttrib (fenêtre, GLFW_RESIZABLE , GLFW_FALSE );

Attributs liés à la fenêtre

GLFW_FOCUSED indique si la fenêtre spécifiée a le focus d'entrée. Voir Focus d'entrée de


fenêtre pour plus de détails.

GLFW_ICONIFIED indique si la fenêtre spécifiée est iconifiée. Voir Iconification de la


fenêtre pour plus de détails.

GLFW_MAXIMIZED indique si la fenêtre spécifiée est agrandie. Voir Maximisation de la


fenêtre pour plus de détails.
GLFW_HOVERED indique si le curseur est actuellement directement sur la zone de contenu de
la fenêtre, sans aucune autre fenêtre entre les deux. Voir Événements entrée/sortie du
curseur pour plus de détails.

GLFW_VISIBLE indique si la fenêtre spécifiée est visible. Voir Visibilité de la fenêtre pour plus


de détails.

GLFW_RESIZABLE indique si la fenêtre spécifiée est redimensionnable par l'utilisateur . Cela


peut être défini avant la création avec l' indicateur de fenêtre GLFW_RESIZABLE ou après
avec glfwSetWindowAttrib .

GLFW_DECORATED indique si la fenêtre spécifiée a des décorations telles qu'une bordure, un


widget de fermeture, etc. Cela peut être défini avant la création avec l' indice
de fenêtre GLFW_DECORATED ou après avec glfwSetWindowAttrib .

GLFW_AUTO_ICONIFY indique si la fenêtre plein écran spécifiée est iconifiée en cas de perte


de focus, de fermeture d'un widget, etc. Cela peut être défini avant la création avec l' indice
de fenêtre GLFW_AUTO_ICONIFY ou après avec glfwSetWindowAttrib .

GLFW_FLOATING indique si la fenêtre spécifiée est flottante, également appelée la plus haute


ou toujours au-dessus. Cela peut être défini avant la création avec l' indice
de fenêtre GLFW_FLOATING ou après avec glfwSetWindowAttrib .

GLFW_TRANSPARENT_FRAMEBUFFER indique si la fenêtre spécifiée a un framebuffer


transparent, c'est-à-dire que le contenu de la fenêtre est composé avec l'arrière-plan en utilisant
le canal alpha du framebuffer de la fenêtre. Voir Transparence de la fenêtre pour plus de
détails.

GLFW_FOCUS_ON_SHOW spécifie si la fenêtre recevra le focus d'entrée


lorsque glfwShowWindow est appelé. Cela peut être défini avant la création avec l' indice
de fenêtre GLFW_FOCUS_ON_SHOW ou après avec glfwSetWindowAttrib .

Attributs liés au contexte

GLFW_CLIENT_API indique l'API client fournie par le contexte de la


fenêtre ; soit GLFW_OPENGL_API, GLFW_OPENGL_ES_APIsoit GLFW_NO_API.

GLFW_CONTEXT_CREATION_API indique l'API de création de contexte utilisée pour créer le


contexte de la
fenêtre ; soit GLFW_NATIVE_CONTEXT_API, GLFW_EGL_CONTEXT_APIsoit GLFW_OSMESA_CONTEX
T_API.

GLFW_CONTEXT_VERSION_MAJOR , GLFW_CONTEXT_VERSION_MINOR et GLFW_CON
TEXT_REVISION indiquent la version de l'API client du contexte de la fenêtre.
Noter

Ne confondez pas ces attributs


avec GLFW_VERSION_MAJOR, GLFW_VERSION_MINORet GLFW_VERSION_REVISIONqui
fournissent la version API de l'en-tête GLFW.

GLFW_OPENGL_FORWARD_COMPAT est GLFW_TRUEsi le contexte de la fenêtre est


compatible avec OpenGL en aval , ou GLFW_FALSEautrement.

GLFW_OPENGL_DEBUG_CONTEXT est GLFW_TRUEsi le contexte de la fenêtre est en mode


débogage, ou GLFW_FALSEautrement.

GLFW_OPENGL_PROFILE indique le profil OpenGL utilisé par le


contexte. C'est GLFW_OPENGL_CORE_PROFILEou GLFW_OPENGL_COMPAT_PROFILEsi le contexte
utilise un profil connu, ou GLFW_OPENGL_ANY_PROFILEsi le profil OpenGL est inconnu ou le
contexte est un contexte OpenGL ES. Notez que le profil renvoyé peut ne pas correspondre aux
bits de profil des indicateurs de contexte, car GLFW essaiera d'autres moyens de détecter le
profil lorsqu'aucun bit n'est défini.

GLFW_CONTEXT_RELEASE_BEHAVIOR indique la version utilisée par le contexte. Les


valeurs possibles sont l'une
de GLFW_ANY_RELEASE_BEHAVIOR, GLFW_RELEASE_BEHAVIOR_FLUSHou GLFW_RELEASE_BEHA
VIOR_NONE. Si le comportement est GLFW_ANY_RELEASE_BEHAVIOR, le comportement par
défaut de l'API de création de contexte sera utilisé. Si le comportement
est GLFW_RELEASE_BEHAVIOR_FLUSH, le pipeline sera vidé chaque fois que le contexte n'est
plus le contexte actuel. Si le comportement est GLFW_RELEASE_BEHAVIOR_NONE, le pipeline ne
sera pas vidé lors de la libération.

GLFW_CONTEXT_NO_ERROR indique si des erreurs sont générées par le contexte. Les


valeurs possibles sont GLFW_TRUEet GLFW_FALSE. Si cette option est activée, les situations qui
auraient généré des erreurs provoquent à la place un comportement indéfini.

GLFW_CONTEXT_ROBUSTNESS indique la stratégie de robustesse utilisée par le


contexte. C'est GLFW_LOSE_CONTEXT_ON_RESETou GLFW_NO_RESET_NOTIFICATIONsi le
contexte de la fenêtre prend en charge la robustesse, ou GLFW_NO_ROBUSTNESSautrement.

Attributs liés au framebuffer

GLFW n'expose pas les attributs du framebuffer par défaut (c'est-à-dire le framebuffer attaché à
la fenêtre) car ceux-ci peuvent être interrogés directement avec OpenGL, OpenGL ES ou Vulkan.
Si vous utilisez la version 3.0 ou supérieure d'OpenGL ou d'OpenGL ES,
la glGetFramebufferAttachmentParameterivfonction peut être utilisée pour récupérer le
nombre de bits pour les canaux de tampon rouge, vert, bleu, alpha, profondeur et stencil. Sinon,
la glGetIntegervfonction peut être utilisée.

Le nombre d'échantillons MSAA est toujours récupéré avec glGetIntegerv. Pour les contextes


prenant en charge les objets framebuffer, le nombre d'échantillons du framebuffer actuellement
lié est renvoyé.

Attribut glGetIntegerv glGetFramebufferAttachmentParameteriv

Mors rouges GL_RED_BITS GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE

Morceaux verts GL_GREEN_BITS GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE

Bits bleus GL_BLUE_BITS GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE

Bits alpha GL_ALPHA_BITS GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE

Bits de profondeur GL_DEPTH_BITS GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE

Mors de pochoir GL_STENCIL_BITS GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE

Échantillons MSAA GL_SAMPLES Non fourni par cette fonction

Lors de l'appel de glGetFramebufferAttachmentParameteriv, les tailles rouge, verte, bleue


et alpha sont interrogées à partir de GL_BACK_LEFT, tandis que les tailles de profondeur et de
gabarit sont respectivement interrogées à partir des pièces jointes GL_DEPTHet GL_STENCIL.

Échange de tampon
Les fenêtres GLFW sont par défaut à double tampon. Cela signifie que vous disposez de deux
tampons de rendu ; un tampon avant et un tampon arrière. Le tampon avant est celui qui est
affiché et le tampon arrière celui vers lequel vous effectuez le rendu.

Lorsque l'ensemble de l'image a été rendu, il est temps d'échanger les tampons arrière et avant
afin d'afficher ce qui a été rendu et de commencer à rendre une nouvelle image. Cela se fait
avec glfwSwapBuffers .

glfwSwapBuffers (fenêtre);

Parfois, il peut être utile de sélectionner le moment où l'échange de tampon aura lieu. Avec la
fonction glfwSwapInterval, il est possible de sélectionner le nombre minimum de
rafraîchissements de moniteur que le pilote doit attendre à partir du moment
où glfwSwapBuffers a été appelé avant d'échanger les tampons :
glfwIntervalle d'échange (1) ;

Si l'intervalle est égal à zéro, l'échange aura lieu immédiatement lorsque glfwSwapBuffers est


appelé sans attendre une actualisation. Sinon, au moins des retracements d'intervalle passeront
entre chaque échange de tampon. L'utilisation d'un intervalle d'échange de zéro peut être utile à
des fins d'analyse comparative, lorsqu'il n'est pas souhaitable de mesurer le temps d'attente du
retracement vertical. Cependant, un intervalle d'échange de un vous permet d'éviter les
déchirures.

Notez que cela peut ne pas fonctionner sur toutes les machines, car certains pilotes ont des
paramètres contrôlés par l'utilisateur qui remplacent tout intervalle d'échange demandé par
l'application.

Un contexte qui prend en


charge WGL_EXT_swap_control_tearl' GLX_EXT_swap_control_tearextension ou accepte
également les intervalles d'échange négatifs , ce qui permet au pilote d'échanger immédiatement
même si une trame arrive un peu en retard. Cela remplace le risque de déchirures visibles par
une plus grande stabilité du framerate. Vous pouvez vérifier ces extensions
avec glfwExtensionSupported .

Guide contextuel
Table des matières
 Objets de contexte

o Conseils de création de contexte


o Partage d'objet de contexte
o Contextes hors écran
o Windows sans contextes
 Contexte actuel
 Échange de tampon
 Extensions OpenGL et OpenGL ES
o Chargement de l'extension avec une bibliothèque de chargement
o Chargement manuel des extensions
 L'en-tête glext.h
 Vérification des extensions
 Récupérer des pointeurs de fonction

Ce guide présente les fonctions liées au contexte OpenGL et OpenGL ES de GLFW. Pour plus
de détails sur une fonction spécifique de cette catégorie, consultez la référence Contexte . Il
existe également des guides pour les autres domaines de l'API GLFW.

 Présentation de l'API
 Guide de fenêtre
 Guide de Vulkan
 Guide du moniteur
 Guide de saisie

Objets de contexte
Un objet window encapsule à la fois une fenêtre de niveau supérieur et un contexte OpenGL ou
OpenGL ES. Il est créé avec glfwCreateWindow et détruit
avec glfwDestroyWindow ou glfwTerminate . Voir Création de fenêtre pour plus
d'informations.

Comme la fenêtre et le contexte sont inséparablement liés, l'objet fenêtre sert également de
poignée de contexte.

Pour tester la création de différents types de contextes et voir leurs propriétés, exécutez
le glfwinfoprogramme de test.

Noter

Vulkan n'a pas de contexte et l'instance Vulkan est créée via l'API Vulkan elle-même. Si
vous utilisez Vulkan pour effectuer le rendu dans une fenêtre, désactivez la création de
contexte en définissant l' indice GLFW_CLIENT_API sur GLFW_NO_API. Pour plus
d'informations, consultez le guide Vulkan .

Conseils de création de contexte

Il existe un certain nombre d'indices, spécifiés à l'aide de glfwWindowHint , liés au type de


contexte créé. Voir les conseils liés au contexte dans le guide des fenêtres.

Partage d'objet de contexte


Lors de la création d'une fenêtre et de son contexte OpenGL ou OpenGL ES
avec glfwCreateWindow , vous pouvez spécifier une autre fenêtre avec laquelle la nouvelle doit
partager ses objets (textures, vertex et buffers d'éléments, etc.).

GLFWwindow * second_window = glfwCreateWindow (640, 480, "Second Window" , NULL,


first_window);

Le partage d'objets est implémenté par le système d'exploitation et le pilote graphique. Sur les
plateformes où il est possible de choisir quels types d'objets sont partagés, GLFW demande que
tous les types soient partagés.

Voir le chapitre correspondant des documents de référence OpenGL ou OpenGL ES pour plus


d'informations. Le nom et le numéro de ce chapitre varient malheureusement selon les versions
et les API, mais ont parfois été nommés Objets partagés et Contextes multiples .

GLFW est livré avec un exemple de programme de partage d'objets barebones appelé sharing.

Contextes hors écran

GLFW ne prend pas en charge la création de contextes sans fenêtre associée. Cependant, des
contextes avec des fenêtres cachées peuvent être créés avec l' indicateur
de fenêtre GLFW_VISIBLE .

glfwWindowHint ( GLFW_VISIBLE , GLFW_FALSE );


GLFWwindow * offscreen_context = glfwCreateWindow (640, 480, "" , NULL, NULL);

La fenêtre n'a jamais besoin d'être affichée et son contexte peut être utilisé comme un simple
contexte hors écran. Selon le gestionnaire de fenêtres, la taille du framebuffer d'une fenêtre
cachée peut ne pas être utilisable ou modifiable, donc les objets framebuffer sont recommandés
pour le rendu avec de tels contextes.

Vous devez toujours traiter les événements tant que vous disposez d'au moins une fenêtre,
même si aucune d'entre elles n'est visible.

macOS : la première fois qu'une fenêtre est créée, la barre de menus est créée. Ce n'est pas
souhaitable par exemple lors de l'écriture d'une application en ligne de commande
uniquement. La création de la barre de menus peut être désactivée avec l' astuce
d' initialisation GLFW_COCOA_MENUBAR .

Windows sans contextes

Vous pouvez désactiver la création de contexte en définissant


le conseil GLFW_CLIENT_API sur GLFW_NO_API. Les fenêtres sans contexte ne doivent pas
être transmises à glfwMakeContextCurrent ou glfwSwapBuffers .
Contexte actuel
Avant de pouvoir passer des appels OpenGL ou OpenGL ES, vous devez disposer d'un contexte
actuel du type correct. Un contexte ne peut être actuel que pour un seul thread à la fois, et un
thread ne peut avoir qu'un seul contexte actuel à la fois.

Lorsque vous déplacez un contexte entre des threads, vous devez le rendre non actuel sur
l'ancien thread avant de le rendre actuel sur le nouveau.

Le contexte d'une fenêtre est rendu courant avec glfwMakeContextCurrent .

glfwMakeContextCurrent (fenêtre);

La fenêtre du contexte courant est retournée par glfwGetCurrentContext .

GLFWwindow * fenêtre = glfwGetCurrentContext ();

Les fonctions GLFW suivantes nécessitent un contexte pour être actuel. L'appel de ces fonctions
sans contexte actuel générera une erreur GLFW_NO_CURRENT_CONTEXT .

 glfwIntervalleSwap
 glfwExtensionPrise en charge
 glfwGetProcAddress

Échange de tampon
Voir Échange de tampon dans le guide des fenêtres.

Extensions OpenGL et OpenGL ES


L'un des avantages d'OpenGL et d'OpenGL ES est leur extensibilité. Les fournisseurs de matériel
peuvent inclure des extensions dans leurs implémentations qui étendent l'API avant que cette
fonctionnalité ne soit incluse dans une nouvelle version de la spécification OpenGL ou OpenGL
ES, et certaines extensions ne sont jamais incluses et restent en tant qu'extensions jusqu'à ce
qu'elles deviennent obsolètes.

Une extension est définie par :

 Un nom d'extension (par exemple GL_ARB_debug_output)


 Nouveaux jetons OpenGL (par exemple GL_DEBUG_SEVERITY_HIGH_ARB)
 Nouvelles fonctions OpenGL (par exemple glGetDebugMessageLogARB)
Notez l' ARBaffixe, qui signifie Architecture Review Board et est utilisé pour les extensions
officielles. L'extension ci-dessus a été créée par l'ARB, mais il existe de nombreux affixes
différents, comme NVpour Nvidia et AMDpour, eh bien, AMD. Tout groupe peut également utiliser
l' EXTaffixe générique . Des listes d'extensions, ainsi que leurs spécifications, peuvent être
trouvées dans les registres OpenGL et OpenGL ES .

Chargement de l'extension avec une bibliothèque de


chargement

Une bibliothèque de chargeur d'extensions est le moyen le plus simple et le meilleur d'accéder
aux extensions OpenGL et OpenGL ES et aux versions modernes des API OpenGL ou OpenGL
ES de base. Ils s'occuperont de tous les détails de la déclaration et du chargement de tout ce
dont vous avez besoin. Une telle bibliothèque est heureuse et il y en a plusieurs autres.

L'exemple suivant utilisera glad mais toutes les bibliothèques de chargeur d'extension
fonctionnent de la même manière.

Vous devez d'abord générer les fichiers sources à l'aide du script Python content. Cet exemple
génère un chargeur pour n'importe quelle version d'OpenGL, qui est la valeur par défaut pour
GLFW et glad, mais des chargeurs pour OpenGL ES, ainsi que des chargeurs pour des versions
d'API spécifiques et des ensembles d'extensions peuvent être générés. Les fichiers générés sont
écrits dans le outputrépertoire.

python main.py --generator c --no-loader --out-path sortie

L' --no-loaderoption est ajoutée car GLFW fournit déjà une fonction pour charger les pointeurs
de fonction OpenGL et OpenGL ES, une qui utilise automatiquement l'API de création de
contexte sélectionnée, et happy peut l'appeler au lieu d'avoir à implémenter la sienne. Il existe
également plusieurs autres options de ligne de commande. Voir la documentation joyeuse pour
plus de détails.

Ajoutez
les fichiers output/src/glad.c, output/include/glad/glad.het générés output/include
/KHR/khrplatform.hà votre build. Ensuite, vous devez inclure le fichier d'en-tête glad, qui
remplacera l'en-tête OpenGL de votre environnement de développement. En incluant l'en-tête
glad avant l'en-tête GLFW, il supprime l'en-tête OpenGL ou OpenGL ES de l'environnement de
développement.

#include <heureux/heureux.h>
#include < GLFW/glfw3.h >

Enfin, vous devez initialiser happy une fois que vous avez un contexte actuel approprié.
window = glfwCreateWindow (640, 480, "Ma fenêtre" , NULL, NULL);
si (!fenêtre)
{
...
}
glfwMakeContextCurrent (fenêtre);
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress );

Une fois que glad a été chargé, vous avez accès à toutes les fonctions de base et d'extension
OpenGL prises en charge à la fois par le contexte que vous avez créé et le chargeur de glad que
vous avez généré et vous êtes prêt à commencer le rendu.

Vous pouvez spécifier une version minimale requise d'OpenGL ou d'OpenGL ES avec
des conseils contextuels . Si vos besoins sont plus complexes, vous pouvez vérifier la version
actuelle d'OpenGL ou d'OpenGL ES avec les attributs de contexte , ou vous pouvez vérifier si
une version spécifique est prise en charge par le contexte actuel avec
les GLAD_GL_VERSION_x_xbooléens.

si (GLAD_GL_VERSION_3_2)
{
// Appel du code spécifique à OpenGL 3.2+
}

Pour vérifier si une extension spécifique est prise en charge, utilisez les GLAD_GL_xxxbooléens.

si (GLAD_GL_ARB_debug_output)
{
// Utiliser GL_ARB_debug_output
}

Chargement manuel des extensions

N'utilisez pas cette technique à moins que cela ne soit absolument


nécessaire. Une bibliothèque de chargeur d'extension vous évitera une tonne de travail
fastidieux, répétitif et sujet aux erreurs.

Pour utiliser une certaine extension, vous devez d'abord vérifier si le contexte prend en charge
cette extension, puis, s'il introduit de nouvelles fonctions, récupérer les pointeurs vers ces
fonctions. GLFW fournit glfwExtensionSupported et glfwGetProcAddress pour le chargement
manuel des extensions et des nouvelles fonctions API.

Cette section montrera le chargement manuel des extensions OpenGL. Le chargement des
extensions OpenGL ES est identique à l'exception du nom de l'en-tête de l'extension.
L'en-tête glext.h

L'en- glext.htête d'extension est un fichier continuellement mis à jour qui définit les interfaces
pour toutes les extensions OpenGL. La dernière version de ceci peut toujours être trouvée dans
le registre OpenGL . Il existe également des en-têtes d'extension pour les différentes versions
d'OpenGL ES dans le registre OpenGL ES . Il est fortement recommandé d'utiliser votre propre
copie de l'en-tête d'extension, car celui inclus dans votre environnement de développement peut
être obsolète depuis plusieurs années et peut ne pas inclure les extensions que vous souhaitez
utiliser.

L'en-tête définit les types de pointeur de fonction pour toutes les fonctions de toutes les
extensions qu'il prend en charge. Ceux-ci ont des noms
comme PFNGLGETDEBUGMESSAGELOGARBPROC(pour glGetDebugMessageLogARB), c'est-à-dire
que le nom est mis en majuscule et PFN(pointeur vers la fonction) et PROC(procédure) sont
ajoutés aux extrémités.

Pour inclure l'en-tête d'extension, définissez GLFW_INCLUDE_GLEXT avant d'inclure l'en-tête


GLFW.

#define GLFW_INCLUDE_GLEXT
#include <GLFW/glfw3.h>

Vérification des extensions

Une machine donnée peut ne pas prendre en charge l'extension (elle peut avoir des pilotes plus
anciens ou une carte graphique qui n'a pas les fonctionnalités matérielles nécessaires), il est
donc nécessaire de vérifier au moment de l'exécution si le contexte prend en charge
l'extension. Cela se fait avec glfwExtensionSupported .

if ( glfwExtensionSupported ( " GL_ARB_debug_output " ))


{
// L'extension est supportée par le contexte courant
}

L'argument est une chaîne ASCII terminée par NULL avec le nom d'extension. Si l'extension est
prise en charge, glfwExtensionSupported renvoie GLFW_TRUE, sinon elle renvoie GLFW_FALSE.

Récupérer des pointeurs de fonction

De nombreuses extensions, mais pas toutes, nécessitent l'utilisation de nouvelles fonctions


OpenGL. Ces fonctions n'ont souvent pas de points d'entrée dans les bibliothèques d'API clientes
de votre système d'exploitation, ce qui oblige à les récupérer au moment de l'exécution. Vous
pouvez récupérer des pointeurs vers ces fonctions avec glfwGetProcAddress .
PFNGLGETDEBUGMESSAGELOGARBPROC pfnGetDebugMessageLog = glfwGetProcAddress (
"glGetDebugMessageLogARB" );

En général, vous devriez éviter de donner aux variables de pointeur de fonction le même nom
(exact) que la fonction, car cela pourrait embrouiller votre éditeur de liens. Au lieu de cela, vous
pouvez utiliser un préfixe différent, comme ci-dessus, ou un autre schéma de nommage.

Maintenant que toutes les pièces ont été présentées, voici à quoi elles pourraient ressembler
lorsqu'elles sont utilisées ensemble.

#define GLFW_INCLUDE_GLEXT
#include < GLFW/glfw3.h >
#define glGetDebugMessageLogARB pfnGetDebugMessageLog
PFNGLGETDEBUGMESSAGELOGARBPROC pfnGetDebugMessageLog;
// Flag indiquant si l'extension est supportée
int has_ARB_debug_output = 0;
void load_extensions( void )
{
if ( glfwExtensionSupported ( " GL_ARB_debug_output " ))
{
pfnGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGARBPROC)
glfwGetProcAddress ( "glGetDebugMessageLogARB" );
has_ARB_debug_output = 1 ;
}
}
void some_function( void )
{
si (has_ARB_debug_output)
{
// Maintenant, la fonction d'extension peut être appelée comme d'habitude
glGetDebugMessageLogARB(...);
}
}
Guide de Vulkan
Table des matières
 Liaison contre le chargeur Vulkan
 Y compris les fichiers d'en-tête Vulkan et GLFW
 Demande d'assistance Vulkan

o Interrogation des pointeurs de fonction Vulkan


 Interrogation des extensions Vulkan requises
 Requête pour la prise en charge de la présentation Vulkan
 Création de la fenêtre
 Création d'une surface de fenêtre Vulkan
Ce guide est destiné à combler les lacunes entre les ressources officielles Vulkan et le reste de la
documentation GLFW et ne remplace pas non plus. Il suppose une certaine familiarité avec les
concepts Vulkan tels que les chargeurs, les périphériques, les files d'attente et les surfaces et
laisse à la documentation Vulkan le soin d'expliquer les détails des fonctions Vulkan.

Pour développer pour Vulkan, vous devez télécharger le SDK LunarG Vulkan pour votre plate-
forme. Outre les en-têtes et les bibliothèques de liens, ils fournissent également les couches de
validation nécessaires au développement.

Le didacticiel Vulkan contient plus d'informations sur l'utilisation de GLFW et


Vulkan. Les échantillons Khronos Vulkan utilisent également GLFW, bien qu'avec un petit cadre
entre les deux.

Pour plus de détails sur une fonction de support Vulkan spécifique, consultez la référence de
support Vulkan . Il existe également des guides pour les autres domaines de l'API GLFW.

 Présentation de l'API
 Guide de fenêtre
 Guide contextuel
 Guide du moniteur
 Guide de saisie

Liaison contre le chargeur Vulkan


Par défaut, GLFW recherchera le chargeur Vulkan à la demande lors de l'exécution via son nom
standard ( vulkan-1.dllsous Windows, libvulkan.so.1Linux et autres systèmes de type
Unix et libvulkan.1.dylibmacOS). Cela signifie que GLFW n'a pas besoin d'être lié au
chargeur. Cependant, cela signifie également que si vous utilisez la forme de bibliothèque
statique du chargeur Vulkan, GLFW ne la trouvera pas ou (pire) utilisera la mauvaise.

L' option CMake GLFW_VULKAN_STATIC permet à GLFW d'appeler directement le chargeur


Vulkan au lieu de le charger dynamiquement lors de l'exécution. Ne pas établir de lien avec le
chargeur Vulkan sera alors une erreur de compilation.

macOS : étant donné que le chargeur Vulkan et l'ICD ne sont pas installés globalement sur
macOS, vous devez configurer l'ensemble d'applications conformément à la documentation du
SDK LunarG. Ceci est expliqué plus en détail dans la documentation du SDK pour macOS .

Y compris les fichiers d'en-tête Vulkan et GLFW


Pour inclure l'en-tête Vulkan, définissez GLFW_INCLUDE_VULKAN avant d'inclure l'en-tête
GLFW.
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

Si vous souhaitez plutôt inclure l'en-tête Vulkan à partir d'un emplacement personnalisé ou
utiliser votre propre en-tête Vulkan personnalisé, faites-le avant l'en-tête GLFW.

#include <chemin/vers/vulkan.h>
#include < GLFW/glfw3.h >

À moins qu'un en-tête Vulkan ne soit inclus, que ce soit par l'en-tête GLFW ou au-dessus,
aucune fonction GLFW qui prend ou renvoie des types Vulkan ne sera déclarée.

Les VK_USE_PLATFORM_*_KHRmacros n'ont pas besoin d'être définies pour que la partie Vulkan
de GLFW fonctionne. Ne les définissez que si vous utilisez directement ces extensions.

Demande d'assistance Vulkan


Si vous vous connectez directement au chargeur Vulkan, vous pouvez ignorer cette section. La
bibliothèque canonique du chargeur de bureau exporte toutes les fonctions d'extension du noyau
Vulkan et Khronos, leur permettant d'être appelées directement.

Si vous chargez le chargeur Vulkan dynamiquement au lieu de le lier directement, vous pouvez
vérifier la disponibilité d'un chargeur et d'un ICD avec glfwVulkanSupported .

if ( glfwVulkanSupported ())
{
// Vulkan est disponible, au moins pour le calcul
}

Cette fonction renvoie GLFW_TRUEsi le chargeur Vulkan et tout ICD minimalement fonctionnel ont
été trouvés.

Si l'une ou les deux n'étaient pas trouvées, l'appel de toute autre fonction GLFW liée à Vulkan
générera une erreur GLFW_API_UNAVAILABLE .

Interrogation des pointeurs de fonction Vulkan

Pour charger une fonction principale ou d'extension Vulkan à partir du chargeur trouvé,
appelez glfwGetInstanceProcAddress . Pour charger les fonctions nécessaires à la création de
l'instance, passez en NULLtant qu'instance.

PFN_vkCreateInstance pfnCreateInstance = (PFN_vkCreateInstance)


glfwGetInstanceProcAddress (NULL, "vkCreateInstance" );
Une fois que vous avez créé une instance, vous pouvez charger à partir de celle-ci toutes les
autres fonctions principales de Vulkan et les fonctions de toutes les extensions d'instance que
vous avez activées.

PFN_vkCreateDevice pfnCreateDevice = (PFN_vkCreateDevice)


glfwGetInstanceProcAddress (instance, "vkCreateDevice" );

Cette fonction appelle à son tour vkGetInstanceProcAddr. Si cela échoue, la fonction revient à


une requête spécifique à la plate-forme du chargeur Vulkan (c'est dlsym-
à- dire ou GetProcAddress). Si cela échoue également, la fonction renvoie NULL. Pour plus
d'informations sur vkGetInstanceProcAddr, consultez la documentation Vulkan.

Vulkan permet également vkGetDeviceProcAddrde charger des versions spécifiques à


l'appareil de la fonction Vulkan. Cette fonction peut être récupérée à partir d'une instance
avec glfwGetInstanceProcAddress .

PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)


glfwGetInstanceProcAddress (instance, "vkGetDeviceProcAddr" );

Les fonctions spécifiques au périphérique peuvent s'exécuter un peu plus rapidement, car elles
n'ont pas à être réparties en interne en fonction du périphérique qui leur est transmis. Pour plus
d'informations sur vkGetDeviceProcAddr, consultez la documentation Vulkan.

Interrogation des extensions Vulkan requises


Pour faire quoi que ce soit d'utile avec Vulkan, vous devez créer une instance. Si vous souhaitez
utiliser Vulkan pour effectuer le rendu dans une fenêtre, vous devez activer les extensions
d'instance dont GLFW a besoin pour créer des surfaces Vulkan.

Pour interroger les extensions d'instance requises,


appelez glfwGetRequiredInstanceExtensions .

uint32_t compte ;
const char ** extensions = glfwGetRequiredInstanceExtensions (&count);

Ces extensions doivent toutes être activées lors de la création d'instances qui vont être
transmises
à glfwGetPhysicalDevicePresentationSupport et glfwCreateWindowSurface . L'ensemble
d'extensions varie en fonction de la plate-forme et peut également varier en fonction des pilotes
graphiques et d'autres facteurs.

S'il échoue, il reviendra NULLet GLFW ne pourra pas créer de surfaces de fenêtre Vulkan. Vous
pouvez toujours utiliser Vulkan pour le rendu hors écran et le travail de calcul.
En cas de succès, le tableau renvoyé inclura toujours VK_KHR_surface, donc si vous n'avez pas
besoin d'extensions supplémentaires, vous pouvez passer cette liste directement à
la VkInstanceCreateInfostructure.

VkInstanceCreateInfo ici;
memset(&ici, 0, taille de (ici));
ici.enabledExtensionCount = compte;
ici.ppEnabledExtensionNames = extensions;
...

Des extensions supplémentaires peuvent être requises par les futures versions de GLFW. Vous
devez vérifier si les extensions que vous souhaitez activer sont déjà dans le tableau renvoyé, car
c'est une erreur de spécifier une extension plus d'une fois dans
la VkInstanceCreateInfostructure.

Requête pour la prise en charge de la


présentation Vulkan
Toutes les familles de files d'attente de chaque appareil Vulkan ne peuvent pas présenter des
images aux surfaces. Pour vérifier si une famille de files d'attente spécifique d'un périphérique
physique prend en charge la présentation d'images sans avoir à créer au préalable une fenêtre et
une surface, appelez glfwGetPhysicalDevicePresentationSupport .

if ( glfwGetPhysicalDevicePresentationSupport (instance, physical_device,


queue_family_index))
{
// La famille de files d'attente prend en charge la présentation d'images
}

L' VK_KHR_surfaceextension fournit en outre


la vkGetPhysicalDeviceSurfaceSupportKHRfonction qui effectue le même test sur une
surface Vulkan existante.

Création de la fenêtre
À moins que vous n'utilisiez OpenGL ou OpenGL ES avec la même fenêtre que Vulkan, il n'est
pas nécessaire de créer un contexte. Vous pouvez désactiver la création de contexte avec
l' astuce GLFW_CLIENT_API .

glfwWindowHint ( GLFW_CLIENT_API , GLFW_NO_API );


GLFWwindow * window = glfwCreateWindow (640, 480, "Fenêtre Title" , NULL, NULL);
Voir Windows sans contextes pour plus d'informations.

Création d'une surface de fenêtre Vulkan


Vous pouvez créer une surface Vulkan (telle que définie par l' VK_KHR_surfaceextension) pour
une fenêtre GLFW avec glfwCreateWindowSurface .

Surface VkSurfaceKHR ;
VkResult err = glfwCreateWindowSurface (instance, fenêtre, NULL, &surface);
si (erreur)
{
// La création de la surface de la fenêtre a échoué
}

Si un contexte OpenGL ou OpenGL ES a été créé sur la fenêtre, le contexte a la propriété de la


présentation sur la fenêtre et une surface Vulkan ne peut pas être créée.

Il est de votre responsabilité de détruire la surface. GLFW ne le détruit pas pour vous. Appelez


la vkDestroySurfaceKHRfonction de la même extension pour la détruire.

Guide du moniteur
Table des matières
 Surveiller les objets

o Récupération des moniteurs


o Surveiller les changements de configuration
 Propriétés du moniteur
o Modes vidéo
o grandeur physique
o Échelle de contenu
o Poste virtuel
o Espace de travail
o Nom lisible par l'homme
o Pointeur utilisateur
o Rampe gamma

Ce guide présente les fonctions liées au moniteur de GLFW. Pour plus de détails sur une fonction
spécifique de cette catégorie, consultez la référence du moniteur . Il existe également des
guides pour les autres domaines de GLFW.

 Présentation de l'API
 Guide de fenêtre
 Guide contextuel
 Guide de Vulkan
 Guide de saisie

Surveiller les objets


Un objet moniteur représente un moniteur actuellement connecté et est représenté comme un
pointeur vers le type opaque GLFWmonitor . Objets moniteur ne peuvent pas être créés ou
détruits par l'application et conservent leurs adresses jusqu'à ce que les moniteurs qu'ils
représentent sont déconnectés ou jusqu'à ce que la bibliothèque est terminée .

Chaque moniteur a un mode vidéo actuel, une liste des modes vidéo pris en charge, une position
virtuelle, un nom lisible par l'homme, une taille physique estimée et une rampe gamma. L'un des
moniteurs est le moniteur principal.

La position virtuelle d'un moniteur est en coordonnées d'écran et, avec le mode vidéo actuel,
décrit les fenêtres que les moniteurs connectés fournissent dans le bureau virtuel qui les couvre.

Pour voir comment GLFW voit la configuration de votre moniteur et ses modes vidéo disponibles,
exécutez le monitorsprogramme de test.

Récupération des moniteurs

Le moniteur principal est renvoyé par glfwGetPrimaryMonitor . C'est le moniteur préféré de


l'utilisateur et c'est généralement celui avec des éléments d'interface utilisateur globaux comme
la barre des tâches ou la barre de menus.

GLFWmonitor * primaire = glfwGetPrimaryMonitor ();

Vous pouvez récupérer tous les moniteurs actuellement connectés


avec glfwGetMonitors . Consultez la documentation de référence pour la durée de vie du
tableau renvoyé.
nombre entier ;
GLFWmonitor ** moniteurs = glfwGetMonitors (&count);

Le moniteur principal est toujours le premier moniteur du tableau renvoyé, mais d'autres
moniteurs peuvent être déplacés vers un index différent lorsqu'un moniteur est connecté ou
déconnecté.

Surveiller les changements de configuration

Si vous souhaitez être averti lorsqu'un moniteur est connecté ou déconnecté, définissez un
rappel de moniteur.

glfwSetMonitorCallback (monitor_callback);

La fonction de rappel reçoit le handle du moniteur qui a été connecté ou déconnecté et


l'événement qui s'est produit.

void monitor_callback( GLFWmonitor * monitor, int event)


{
si (événement == GLFW_CONNECTED )
{
// Le moniteur était connecté
}
else if (événement == GLFW_DISCONNECTED )
{
// Le moniteur a été déconnecté
}
}

Si un moniteur est déconnecté, toutes les fenêtres qui sont en plein écran passeront en mode
fenêtré avant que le rappel ne soit
appelé. Seuls glfwGetMonitorName et glfwGetMonitorUserPointer renverront des valeurs
utiles pour un moniteur déconnecté et uniquement avant le retour du rappel du moniteur.

Propriétés du moniteur
Chaque moniteur a un mode vidéo actuel, une liste de modes vidéo pris en charge, une position
virtuelle, une échelle de contenu, un nom lisible par l'homme, un pointeur utilisateur, une taille
physique estimée et une rampe gamma.

Modes vidéo
GLFW fait généralement du bon travail en sélectionnant un mode vidéo approprié lorsque vous
créez une fenêtre plein écran, modifiez son mode vidéo ou créez une fenêtre plein écran, mais il
est parfois utile de savoir exactement quels modes vidéo sont pris en charge.

Les modes vidéo sont représentés sous forme de structures GLFWvidmode . Vous pouvez


obtenir un tableau des modes vidéo pris en charge par un moniteur
avec glfwGetVideoModes . Consultez la documentation de référence pour la durée de vie du
tableau renvoyé.

nombre entier ;
GLFWvidmode * modes = glfwGetVideoModes (moniteur, &count);

Pour obtenir le mode vidéo actuel d'un moniteur, appelez glfwGetVideoMode . Consultez la


documentation de référence pour la durée de vie du pointeur renvoyé.

const GLFWvidmode * mode = glfwGetVideoMode (moniteur);

La résolution d'un mode vidéo est spécifiée en coordonnées d'écran et non en pixels.

grandeur physique

La taille physique d'un moniteur en millimètres, ou une estimation de celle-ci, peut être récupérée
avec glfwGetMonitorPhysicalSize . Cela n'a aucun rapport avec sa résolution actuelle , c'est-à-
dire la largeur et la hauteur de son mode vidéo actuel .

int largeur_mm, hauteur_mm;


glfwGetMonitorPhysicalSize (moniteur, &width_mm, &height_mm);

Bien que cela puisse être utilisé pour calculer le DPI brut d'un moniteur, cela n'est souvent pas
utile. Utilisez plutôt l' échelle de contenu du moniteur et l' échelle de contenu de la
fenêtre pour mettre à l'échelle votre contenu.

Échelle de contenu

L'échelle de contenu d'un moniteur peut être récupérée avec glfwGetMonitorContentScale .

float xscale, yscale;


glfwGetMonitorContentScale (moniteur, &xscale, &yscale);

L'échelle du contenu est le rapport entre le DPI actuel et le DPI par défaut de la plate-forme. Ceci
est particulièrement important pour le texte et tous les éléments de l'interface utilisateur. Si les
dimensions en pixels de votre interface utilisateur mises à l'échelle par cela semblent appropriées
sur votre machine, elles devraient apparaître à une taille raisonnable sur les autres machines,
quels que soient leurs paramètres DPI et de mise à l'échelle. Cela repose sur le fait que les
paramètres DPI et de mise à l'échelle du système sont quelque peu corrects.

L'échelle du contenu peut dépendre à la fois de la résolution du moniteur, de la densité de pixels


et des paramètres de l'utilisateur. Il peut être très différent du DPI brut calculé à partir de la taille
physique et de la résolution actuelle.

Poste virtuel

La position du moniteur sur le bureau virtuel, en coordonnées d'écran , peut être récupérée
avec glfwGetMonitorPos .

int xpos, ypos;


glfwGetMonitorPos (moniteur, &xpos, &ypos);

Espace de travail

La zone d'un moniteur non occupée par les barres de tâches globales ou les barres de menus
est la zone de travail. Ceci est spécifié dans les coordonnées de l'écran et peut être récupéré
avec glfwGetMonitorWorkarea .

int xpos, ypos, largeur, hauteur;


glfwGetMonitorWorkarea (moniteur, &xpos, &ypos, &width, &height);

Nom lisible par l'homme

Le nom codé en UTF-8 lisible par l'homme d'un moniteur est renvoyé
par glfwGetMonitorName . Consultez la documentation de référence pour la durée de vie de la
chaîne renvoyée.

const char * nom = glfwGetMonitorName (moniteur);

Il n'est pas garanti que les noms de moniteur soient uniques. Deux moniteurs du même modèle
et de la même marque peuvent avoir le même nom. Seul le handle du moniteur est garanti
unique, et seulement jusqu'à ce que ce moniteur soit déconnecté.

Pointeur utilisateur

Chaque moniteur a un pointeur utilisateur qui peut être défini


avec glfwSetMonitorUserPointer et interrogé avec glfwGetMonitorUserPointer . Cela peut
être utilisé pour n'importe quel but dont vous avez besoin et ne sera pas modifié par GLFW. La
valeur sera conservée jusqu'à ce que le moniteur soit déconnecté ou jusqu'à ce que la
bibliothèque soit terminée.
La valeur initiale du pointeur est NULL.

Rampe gamma

La rampe gamma d'un moniteur peut être définie avec glfwSetGammaRamp , qui accepte un
handle de moniteur et un pointeur vers une structure GLFWgammaramp .

rampe GLFWgammaramp ;
court non signé rouge[256], vert[256], bleu[256] ;
rampe. taille = 256 ;
rampe. rouge = rouge ;
rampe. vert = vert ;
rampe. bleu = bleu ;
pour (i = 0 ; i < taille de rampe ; i++)
{
// Remplir les tableaux de rampe gamma comme vous le souhaitez
}
glfwSetGammaRamp (moniteur, &ramp);

Les données de la rampe gamma sont copiées avant le retour de la fonction, il n'est donc pas
nécessaire de les conserver une fois la rampe définie.

Il est recommandé que votre rampe gamma ait la même taille que la rampe gamma actuelle pour
ce moniteur.

La rampe gamma actuelle d'un moniteur est renvoyée par glfwGetGammaRamp . Voir la


documentation de référence pour la durée de vie de la structure renvoyée.

const GLFWgammaramp * rampe = glfwGetGammaRamp (moniteur);

Si vous souhaitez définir une rampe gamma régulière, vous pouvez demander à GLFW de la
calculer pour vous à partir de l'exposant souhaité avec glfwSetGamma , qui à son tour
appelle glfwSetGammaRamp avec la rampe résultante.

glfwSetGamma (moniteur, 1.0);

Pour expérimenter la correction gamma via la fonction glfwSetGamma , exécutez


le gammaprogramme de test.

Noter
La rampe gamma contrôlée par logiciel est appliquée en plus de la correction gamma
matérielle, qui est aujourd'hui généralement une approximation du gamma sRGB. Cela
signifie que définir une rampe parfaitement linéaire, ou gamma 1.0, produira le
comportement par défaut (généralement de type sRGB).

Guide de saisie
Table des matières
 Traitement des événements
 La saisie au clavier
o Entrée clé
o Saisie de texte
o Noms clés
 Saisie à la souris
o Position du curseur
o Mode curseur
o Mouvement de souris brut
o Objets curseur

 Création de curseur personnalisé


 Création de curseur standard
 Destruction du curseur
 Réglage du curseur
 Curseur entrer/quitter les événements
 Saisie du bouton de la souris
 Saisie de défilement
 Entrée joystick
 États de l'axe du joystick
 États des boutons du joystick
 États du chapeau du joystick
 Nom de la manette
 Pointeur utilisateur du joystick
 Modifications de la configuration du joystick
 Entrée manette de jeu
 Mappages de la manette de jeu
 Saisie de l'heure
 Entrée et sortie du presse-papiers
 Entrée de chute de chemin

Ce guide présente les fonctions liées à l'entrée de GLFW. Pour plus de détails sur une fonction
spécifique de cette catégorie, consultez la référence d'entrée . Il existe également des guides
pour les autres domaines de GLFW.

 Présentation de l'API
 Guide de fenêtre
 Guide contextuel
 Guide de Vulkan
 Guide du moniteur

GLFW fournit de nombreux types d'entrées. Alors que certains ne peuvent être interrogés,
comme l'heure, ou uniquement reçus via des rappels, comme le défilement, beaucoup
fournissent à la fois des rappels et une interrogation. Les rappels sont plus laborieux à utiliser
que les interrogations, mais sont moins gourmands en CPU et garantissent que vous ne
manquez pas les changements d'état.

Tous les rappels d'entrée reçoivent un handle de fenêtre. En utilisant le pointeur utilisateur de
fenêtre , vous pouvez accéder à des structures ou des objets non globaux à partir de vos
rappels.

Pour avoir une meilleure idée du comportement des divers rappels d'événements, exécutez
le eventsprogramme de test. Il enregistre chaque rappel pris en charge par GLFW et imprime
tous les arguments fournis pour chaque événement, ainsi que les informations de temps et de
séquence.

Traitement des événements


GLFW doit interroger le système de fenêtrage pour les événements à la fois pour fournir une
entrée à l'application et pour prouver au système de fenêtrage que l'application ne s'est pas
verrouillée. Le traitement des événements est normalement effectué à chaque trame après
l' échange de tampon . Même lorsque vous n'avez pas de fenêtres, une interrogation
d'événements doit être effectuée afin de recevoir les événements de connexion du moniteur et du
joystick.

Il existe trois fonctions pour le traitement des événements en attente. glfwPollEvents , traite


uniquement les événements qui ont déjà été reçus, puis renvoie immédiatement.

glfwPollEvents ();

C'est le meilleur choix lors du rendu en continu, comme le font la plupart des jeux.

Si vous n'avez besoin de mettre à jour le contenu de la fenêtre que lorsque vous recevez de
nouvelles entrées, glfwWaitEvents est un meilleur choix.

glfwWaitEvents ();

Il met le thread en veille jusqu'à ce qu'au moins un événement ait été reçu, puis traite tous les
événements reçus. Cela permet d'économiser beaucoup de cycles CPU et est utile, par exemple,
pour les outils d'édition.

Si vous souhaitez attendre des événements mais que des éléments d'interface utilisateur ou
d'autres tâches nécessitent des mises à jour périodiques, glfwWaitEventsTimeout vous permet
de spécifier un délai d'expiration.

glfwWaitEventsTimeout (0.7);
Il met le thread en veille jusqu'à ce qu'au moins un événement soit reçu, ou jusqu'à ce que le
nombre de secondes spécifié se soit écoulé. Il traite ensuite tous les événements reçus.

Si le thread principal dort dans glfwWaitEvents , vous pouvez le réveiller d'un autre thread en
publiant un événement vide dans la file d'attente d'événements avec glfwPostEmptyEvent .

glfwPostEmptyEvent ();

Ne supposez pas que les rappels ne seront appelés qu'en réponse aux fonctions ci-dessus. Bien
qu'il soit nécessaire de traiter les événements d'une ou plusieurs des manières ci-dessus, les
systèmes de fenêtres qui nécessitent que GLFW enregistre ses propres rappels peuvent
transmettre des événements à GLFW en réponse à de nombreux appels de fonctions système de
fenêtres. GLFW transmettra ces événements aux rappels d'application avant de revenir.

Par exemple, sous Windows, la fonction système avec laquelle glfwSetWindowSize est


implémentée enverra des événements de taille de fenêtre directement au rappel d'événement de
chaque fenêtre et que GLFW implémente pour ses fenêtres. Si vous avez défini un rappel de
taille de fenêtre, GLFW l'appellera à son tour avec la nouvelle taille avant que tout ne revienne
de l' appel glfwSetWindowSize .

La saisie au clavier
GLFW divise la saisie au clavier en deux catégories ; événements clés et événements de
caractère. Les événements de touche se rapportent aux touches physiques réelles du clavier,
tandis que les événements de caractère se rapportent aux points de code Unicode générés en
appuyant sur certaines d'entre elles.

Les touches et les caractères ne correspondent pas à 1:1. Une seule pression sur une touche
peut produire plusieurs caractères, et un seul caractère peut nécessiter plusieurs touches pour
produire. Ce n'est peut-être pas le cas sur votre machine, mais vos utilisateurs n'utilisent
probablement pas tous la même disposition de clavier, la même méthode de saisie ou même le
même système d'exploitation que vous.

Entrée clé

Si vous souhaitez être averti lorsqu'une touche physique est enfoncée ou relâchée ou lorsqu'elle
se répète, définissez un rappel de touche.

glfwSetKeyCallback (fenêtre, key_callback);

La fonction de rappel reçoit la touche du clavier , le scancode spécifique à la plate-forme, l'action


de touche et les bits de modification .
vide key_callback ( GLFWwindow * fenêtre, int clé, int scancode, int action int
mods)
{
si (clé == GLFW_KEY_E && action == GLFW_PRESS )
activate_airship();
}

L'action est l'une de GLFW_PRESS, GLFW_REPEATou GLFW_RELEASE. La clé


sera GLFW_KEY_UNKNOWNsi GLFW ne possède pas de jeton de clé, par exemple les clés E-
mail et Play .

Le scancode est unique pour chaque clé, qu'elle ait ou non un jeton de clé. Les codes de
numérisation sont spécifiques à la plate-forme mais cohérents dans le temps, de sorte que les
clés auront des codes de numérisation différents selon la plate-forme, mais elles peuvent être
enregistrées en toute sécurité sur le disque. Vous pouvez interroger le scancode pour n'importe
quelle clé nommée sur la plate-forme actuelle avec glfwGetKeyScancode .

const int scancode = glfwGetKeyScancode ( GLFW_KEY_X );


set_key_mapping(scancode, swap_weapons);

Le dernier état signalé pour chaque clé nommée est également enregistré dans des tableaux
d'état par fenêtre qui peuvent être interrogés avec glfwGetKey .

état int = glfwGetKey (fenêtre, GLFW_KEY_E );


si (état == GLFW_PRESS )
{
activate_airship();
}

L'état renvoyé est l'un de GLFW_PRESSou GLFW_RELEASE.

Cette fonction renvoie uniquement l'état de l'événement de clé mis en cache. Il n'interroge pas le
système sur l'état physique actuel de la clé.

Chaque fois que vous interrogez l'état, vous risquez de manquer le changement d'état que vous
recherchez. Si une touche enfoncée est à nouveau relâchée avant d'avoir interrogé son état,
vous aurez manqué l'appui sur la touche. La solution recommandée pour cela est d'utiliser un
rappel de touche, mais il existe également le GLFW_STICKY_KEYSmode de saisie.

glfwSetInputMode (fenêtre, GLFW_STICKY_KEYS , GLFW_TRUE );

Lorsque le mode touches rémanentes est activé, l'état d'interrogation d'une clé
restera GLFW_PRESSjusqu'à ce que l'état de cette clé soit interrogé avec glfwGetKey . Une fois
qu'il a été interrogé, si un événement de libération de clé avait été traité entre-temps, l'état sera
réinitialisé à GLFW_RELEASE, sinon il restera GLFW_PRESS.

Si vous souhaitez connaître l'état des touches Caps Lock et Num Lock lorsque les événements
d'entrée ont été générés, définissez le GLFW_LOCK_KEY_MODSmode de saisie.

glfwSetInputMode (fenêtre, GLFW_LOCK_KEY_MODS , GLFW_TRUE );

Lorsque ce mode d'entrée est activé, tout rappel qui reçoit des bits de modification aura
le bit GLFW_MOD_CAPS_LOCK défini si Caps Lock était activé lorsque l'événement s'est
produit et le bit GLFW_MOD_NUM_LOCK défini si Num Lock était activé .

La GLFW_KEY_LASTconstante contient la valeur la plus élevée de toute clé nommée .

Saisie de texte

GLFW prend en charge la saisie de texte sous la forme d'un flux de points de code Unicode , tel
que produit par le système de saisie de texte du système d'exploitation. Contrairement à la saisie
par touche, la saisie de texte obéit aux dispositions de clavier et aux touches de modification et
prend en charge la composition de caractères à l'aide de touches mortes . Une fois reçus, vous
pouvez encoder les points de code en UTF-8 ou tout autre encodage que vous préférez.

Étant donné que an a une unsigned intlongueur de 32 bits sur toutes les plates-formes prises
en charge par GLFW, vous pouvez traiter l'argument de point de code comme UTF-32 endian
natif.

Si vous souhaitez proposer une saisie de texte régulière, définissez un rappel de caractère.

glfwSetCharCallback (fenêtre, character_callback);

La fonction de rappel reçoit des points de code Unicode pour les événements clés qui auraient
conduit à une saisie de texte normale et se comporte généralement comme un champ de texte
standard sur cette plate-forme.

void character_callback ( fenêtre GLFWwindow *, point de code int non signé )


{
}

Noms clés

Si vous souhaitez faire référence aux touches par leur nom, vous pouvez interroger le nom
dépendant de la disposition du clavier des touches imprimables avec glfwGetKeyName .

const char * key_name = glfwGetKeyName ( GLFW_KEY_W , 0);


show_tutorial_hint( "Appuyez sur %s pour avancer" , key_name);

Cette fonction peut gérer à la fois les clés et les scancodes . Si la clé spécifiée
est GLFW_KEY_UNKNOWNalors le scancode est utilisé, sinon il est ignoré. Cela correspond au
comportement du rappel de touche, ce qui signifie que les arguments de rappel peuvent toujours
être transmis sans modification à cette fonction.

Saisie à la souris
L'entrée de la souris se présente sous de nombreuses formes, notamment le mouvement de la
souris, les pressions sur les boutons et les décalages de défilement. L'apparence du curseur peut
également être modifiée, soit en une image personnalisée, soit en une forme de curseur standard
à partir du thème système.

Position du curseur

Si vous souhaitez être averti lorsque le curseur se déplace sur la fenêtre, définissez un rappel de
position du curseur.

glfwSetCursorPosCallback (fenêtre, curseur_position_callback);

Les fonctions de rappel reçoivent la position du curseur, mesurée en coordonnées d'écran mais
par rapport au coin supérieur gauche de la zone de contenu de la fenêtre. Sur les plates-formes
qui le fournissent, la position complète du curseur sous-pixel est transmise.

static void cursor_position_callback ( fenêtre GLFWwindow *, double xpos, double


ypos)
{
}

La position du curseur est également enregistrée par fenêtre et peut être interrogée
avec glfwGetCursorPos .

double xpos, ypos;


glfwGetCursorPos (fenêtre, &xpos, &ypos);

Mode curseur

Le GLFW_CURSORmode d'entrée fournit plusieurs modes de curseur pour des formes spéciales
d'entrée de mouvement de souris. Par défaut, le mode curseur est GLFW_CURSOR_NORMAL, ce qui
signifie que le curseur fléché normal (ou un autre curseur défini avec glfwSetCursor ) est utilisé
et que le mouvement du curseur n'est pas limité.
Si vous souhaitez implémenter des commandes de caméra basées sur le mouvement de la
souris ou d'autres schémas de saisie qui nécessitent un mouvement de souris illimité, définissez
le mode curseur sur GLFW_CURSOR_DISABLED.

glfwSetInputMode (fenêtre, GLFW_CURSOR , GLFW_CURSOR_DISABLED );

Cela masquera le curseur et le verrouillera à la fenêtre spécifiée. GLFW s'occupera ensuite de


tous les détails du recentrage du curseur et du calcul du décalage et fournira à l'application une
position virtuelle du curseur. Cette position virtuelle est fournie normalement à la fois par le rappel
de position du curseur et par l'interrogation.

Noter

Vous ne devez pas implémenter votre propre version de cette fonctionnalité en utilisant
d'autres fonctionnalités de GLFW. Il n'est pas pris en charge et ne fonctionnera pas aussi
efficacement que GLFW_CURSOR_DISABLED.

Si vous souhaitez que le curseur ne soit masqué que lorsqu'il se trouve au-dessus d'une fenêtre,
mais que vous souhaitez tout de même qu'il se comporte normalement, définissez le mode du
curseur sur GLFW_CURSOR_HIDDEN.

glfwSetInputMode (fenêtre, GLFW_CURSOR , GLFW_CURSOR_HIDDEN );

Ce mode ne limite pas le mouvement du curseur.

Pour sortir de l'un de ces modes spéciaux, restaurez le GLFW_CURSOR_NORMALmode curseur.

glfwSetInputMode (fenêtre, GLFW_CURSOR , GLFW_CURSOR_NORMAL );

Mouvement de souris brut

Lorsque le curseur est désactivé, le mouvement de souris brut (non mis à l'échelle et non
accéléré) peut être activé s'il est disponible.

Le mouvement brut de la souris est plus proche du mouvement réel de la souris sur une
surface. Il n'est pas affecté par la mise à l'échelle et l'accélération appliquées au mouvement du
curseur du bureau. Ce traitement convient à un curseur tandis que le mouvement brut est
meilleur pour contrôler par exemple une caméra 3D. Pour cette raison, le mouvement brut de la
souris n'est fourni que lorsque le curseur est désactivé.
Appelez glfwRawMouseMotionSupported pour vérifier si la machine actuelle fournit un
mouvement brut et définissez le GLFW_RAW_MOUSE_MOTIONmode d'entrée pour l'activer. Il est
désactivé par défaut.

if ( glfwRawMouseMouseSupported ())
glfwSetInputMode (fenêtre, GLFW_RAW_MOUSE_MOTION , GLFW_TRUE );

S'il est pris en charge, le mouvement brut de la souris peut être activé ou désactivé par fenêtre et
à tout moment, mais il ne sera fourni que lorsque le curseur est désactivé.

Objets curseur

GLFW prend en charge la création d'images de curseur de thème personnalisé et système,


encapsulées en tant qu'objets GLFWcursor . Ils sont créés
avec glfwCreateCursor ou glfwCreateStandardCursor et détruits avec glfwDestroyCursor ,
ou glfwTerminate , s'il en reste.

Création de curseur personnalisé

Un curseur personnalisé est créé avec glfwCreateCursor , qui renvoie un handle vers l'objet
curseur créé. Par exemple, cela crée un curseur carré blanc 16x16 avec le point chaud dans le
coin supérieur gauche :

unsigned carbonisation pixels [16 * 16 * 4];


memset(pixels, 0xff, sizeof (pixels));
Image GLFWimage ;
image. largeur = 16 ;
image. hauteur = 16 ;
image. pixels = pixels ;
GLFWcursor * curseur = glfwCreateCursor (&image, 0, 0);

Si la création du curseur échoue, NULLsera renvoyé, il est donc nécessaire de vérifier la valeur


de retour.

Les données d'image sont 32 bits, little-endian, RGBA non prémultiplié, c'est-à-dire huit bits par
canal avec le canal rouge en premier. Les pixels sont disposés de manière canonique sous
forme de rangées séquentielles, à partir du coin supérieur gauche.

Création de curseur standard

Un curseur avec une forme standard du thème du curseur système actuel peut être créé
avec glfwCreateStandardCursor .

GLFWcursor * curseur = glfwCreateStandardCursor ( GLFW_HRESIZE_CURSOR );


Ces objets curseur se comportent exactement de la même manière que ceux créés
avec glfwCreateCursor, sauf que le thème du curseur système fournit l'image réelle.

Destruction du curseur

Lorsqu'un curseur n'est plus nécessaire, détruisez-le avec glfwDestroyCursor .

glfwDestroyCursor (curseur);

La destruction du curseur réussit toujours. Si le curseur est actif pour n'importe quelle fenêtre,
cette fenêtre reviendra au curseur par défaut. Cela n'affecte pas le mode curseur. Tous les
curseurs restants sont détruits lorsque glfwTerminate est appelé.

Réglage du curseur

Un curseur peut être défini comme courant pour une fenêtre avec glfwSetCursor .

glfwSetCursor (fenêtre, curseur);

Une fois définie, l'image du curseur sera utilisée tant que le curseur système se trouve sur la
zone de contenu de la fenêtre et que le mode curseur est défini sur GLFW_CURSOR_NORMAL.

Un seul curseur peut être défini pour un nombre quelconque de fenêtres.

Pour revenir au curseur par défaut, définissez le curseur de cette fenêtre sur NULL.

glfwSetCursor (fenêtre, NULL);

Lorsqu'un curseur est détruit, toute fenêtre qui l'a défini reviendra au curseur par défaut. Cela
n'affecte pas le mode curseur.

Curseur entrer/quitter les événements

Si vous souhaitez être averti lorsque le curseur entre ou quitte la zone de contenu d'une fenêtre,
définissez un rappel d'entrée/sortie du curseur.

glfwSetCursorEnterCallback (fenêtre, cursor_enter_callback);

La fonction de rappel reçoit la nouvelle classification du curseur.

vide cursor_enter_callback ( GLFWwindow * fenêtre, int entrée)


{
si (entré)
{
// Le curseur est entré dans la zone de contenu de la fenêtre
}
autre
{
// Le curseur a quitté la zone de contenu de la fenêtre
}
}

Vous pouvez demander si le curseur se trouve actuellement dans la zone de contenu de la


fenêtre avec l' attribut de fenêtre GLFW_HOVERED .

if ( glfwGetWindowAttrib (fenêtre, GLFW_HOVERED ))


{
point culminant_interface();
}

Saisie du bouton de la souris

Si vous souhaitez être averti lorsqu'un bouton de la souris est enfoncé ou relâché, définissez un
rappel du bouton de la souris.

glfwSetMouseButtonCallback (fenêtre, mouse_button_callback);

La fonction de rappel reçoit le bouton de la souris , l'action du bouton et les bits de


modification .

vide mouse_button_callback ( GLFWwindow * fenêtre, int bouton, int action int


mods)
{
si (bouton == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS )
popup_menu();
}

L'action est l'une de GLFW_PRESSou GLFW_RELEASE.

Les états des boutons de la souris pour les boutons nommés sont également enregistrés dans
des tableaux d'états par fenêtre qui peuvent être interrogés avec glfwGetMouseButton .

état int = glfwGetMouseButton (fenêtre, GLFW_MOUSE_BUTTON_LEFT );


si (état == GLFW_PRESS )
{
upgrade_vache();
}

L'état renvoyé est l'un de GLFW_PRESSou GLFW_RELEASE.


Cette fonction renvoie uniquement l'état de l'événement du bouton de la souris mis en cache. Il
n'interroge pas le système sur l'état actuel du bouton de la souris.

Chaque fois que vous interrogez l'état, vous risquez de manquer le changement d'état que vous
recherchez. Si un bouton de la souris enfoncé est à nouveau relâché avant d'avoir interrogé son
état, vous aurez manqué l'appui sur le bouton. La solution recommandée pour cela est d'utiliser
un rappel du bouton de la souris, mais il existe également
le GLFW_STICKY_MOUSE_BUTTONSmode de saisie.

glfwSetInputMode (fenêtre, GLFW_STICKY_MOUSE_BUTTONS , GLFW_TRUE );

Lorsque le mode boutons de souris collants est activé, l'état d'interrogation d'un bouton de souris
restera GLFW_PRESSjusqu'à ce que l'état de ce bouton soit interrogé
avec glfwGetMouseButton . Une fois qu'il a été interrogé, si un événement de relâchement du
bouton de la souris avait été traité entre-temps, l'état sera réinitialisé à GLFW_RELEASE, sinon il
restera GLFW_PRESS.

La GLFW_MOUSE_BUTTON_LASTconstante contient la valeur la plus élevée de n'importe


quel bouton nommé .

Saisie de défilement

Si vous souhaitez être averti lorsque l'utilisateur fait défiler, que ce soit avec une molette de la
souris ou un geste du pavé tactile, définissez un rappel de défilement.

glfwSetScrollCallback (fenêtre, scroll_callback);

La fonction de rappel reçoit des décalages de défilement bidimensionnels.

void scroll_callback ( fenêtre GLFWwindow *, double xoffset, double yoffset)


{
}

Une molette de souris normale, étant verticale, fournit des décalages le long de l'axe Y.

Entrée joystick
Les fonctions du joystick exposent les joysticks et les contrôleurs connectés, les deux étant
appelés joysticks. Il prend en charge jusqu'à seize joysticks, allant
de GLFW_JOYSTICK_1, GLFW_JOYSTICK_2jusqu'à et y
compris GLFW_JOYSTICK_16ou GLFW_JOYSTICK_LAST. Vous pouvez tester si un joystick est
présent avec glfwJoystickPresent .

int present = glfwJoystickPresent ( GLFW_JOYSTICK_1 );


Chaque joystick a zéro ou plusieurs axes, zéro ou plusieurs boutons, zéro ou plusieurs
chapeaux, un nom lisible par l'homme, un pointeur utilisateur et un GUID compatible SDL.

Lorsque GLFW est initialisé, les joysticks détectés sont ajoutés au début du tableau. Une fois
qu'un joystick est détecté, il conserve son ID attribué jusqu'à ce qu'il soit déconnecté ou que la
bibliothèque soit terminée. Ainsi, lorsque les joysticks sont connectés et déconnectés, des
lacunes peuvent apparaître dans les ID.

L'état de l'axe du joystick, du bouton et du chapeau est mis à jour lorsqu'il est interrogé et ne
nécessite pas la création d'une fenêtre ni le traitement d'événements. Cependant, si vous
souhaitez que les événements de connexion et de déconnexion du joystick soient transmis de
manière fiable au rappel du joystick, vous devez traiter les événements .

Pour voir toutes les propriétés de tous les joysticks connectés en temps réel, exécutez
le joysticksprogramme de test.

États de l'axe du joystick

Les positions de tous les axes d'un joystick sont renvoyées


par glfwGetJoystickAxes . Consultez la documentation de référence pour la durée de vie du
tableau renvoyé.

nombre entier ;
const float * axes = glfwGetJoystickAxes ( GLFW_JOYSTICK_5 , &count);

Chaque élément du tableau renvoyé est une valeur comprise entre -1,0 et 1,0.

États des boutons du joystick

Les états de tous les boutons d'un joystick sont renvoyés


par glfwGetJoystickButtons . Consultez la documentation de référence pour la durée de vie du
tableau renvoyé.

nombre entier ;
const char non signé * boutons = glfwGetJoystickButtons ( GLFW_JOYSTICK_3 ,
&count);

Chaque élément du tableau renvoyé est soit GLFW_PRESSou GLFW_RELEASE.

Pour une compatibilité descendante avec les versions antérieures qui n'avaient
pas glfwGetJoystickHats , le tableau de boutons par défaut inclut également tous les
chapeaux. Consultez la documentation de référence de glfwGetJoystickButtons pour plus de
détails.
États du chapeau du joystick

Les états de tous les chapeaux sont renvoyés par glfwGetJoystickHats . Consultez la


documentation de référence pour la durée de vie du tableau renvoyé.

nombre entier ;
const unsigned char * hats = glfwGetJoystickHats ( GLFW_JOYSTICK_7 , &count);

Chaque élément du tableau renvoyé est l'un des suivants :

Nom Valeur

GLFW_HAT_CENTERED 0

GLFW_HAT_UP 1

GLFW_HAT_RIGHT 2

GLFW_HAT_DOWN 4

GLFW_HAT_LEFT 8

GLFW_HAT_RIGHT_UP GLFW_HAT_RIGHT | GLFW_HAT_UP

GLFW_HAT_RIGHT_DOWN GLFW_HAT_RIGHT | GLFW_HAT_DOWN

GLFW_HAT_LEFT_UP GLFW_HAT_LEFT | GLFW_HAT_UP

GLFW_HAT_LEFT_DOWN GLFW_HAT_LEFT | GLFW_HAT_DOWN

Les directions diagonales sont des combinaisons au niveau du bit des directions principales
(haut, droite, bas et gauche) et vous pouvez les tester individuellement en les effectuant par AND
avec la direction correspondante.

if (chapeaux[2] & GLFW_HAT_RIGHT )


{
// L'état du chapeau 2 peut être à droite, à droite ou à droite
}

Pour une compatibilité descendante avec les versions antérieures qui n'avaient
pas glfwGetJoystickHats , tous les chapeaux sont également inclus par défaut dans le tableau
de boutons. Consultez la documentation de référence de glfwGetJoystickButtons pour plus de
détails.

Nom de la manette
Le nom codé en UTF-8 lisible par l'homme d'un joystick est renvoyé
par glfwGetJoystickName . Consultez la documentation de référence pour la durée de vie de la
chaîne renvoyée.

const char * nom = glfwGetJoystickName ( GLFW_JOYSTICK_4 );

Il n'est pas garanti que les noms de joystick soient uniques. Deux joysticks du même modèle et
de la même marque peuvent avoir le même nom. Seul l' ID du joystick est garanti unique, et
seulement jusqu'à ce que ce joystick soit déconnecté.

Pointeur utilisateur du joystick

Chaque joystick a un pointeur utilisateur qui peut être défini


avec glfwSetJoystickUserPointer et interrogé avec glfwGetJoystickUserPointer . Cela peut
être utilisé pour n'importe quel but dont vous avez besoin et ne sera pas modifié par GLFW. La
valeur sera conservée jusqu'à ce que le joystick soit déconnecté ou jusqu'à ce que la
bibliothèque soit terminée.

La valeur initiale du pointeur est NULL.

Modifications de la configuration du joystick

Si vous souhaitez être averti lorsqu'un joystick est connecté ou déconnecté, définissez un rappel
du joystick.

glfwSetJoystickCallback (joystick_callback);

La fonction de rappel reçoit l'ID du joystick qui a été connecté et déconnecté et l'événement qui
s'est produit.

void joystick_callback( int jid, int event)


{
si (événement == GLFW_CONNECTED )
{
// Le joystick était connecté
}
else if (événement == GLFW_DISCONNECTED )
{
// Le joystick était déconnecté
}
}

Pour que les événements de connexion et de déconnexion du joystick soient livrés sur toutes les
plateformes, vous devez appeler l'une des fonctions de traitement d'événement . La
déconnexion du joystick peut également être détectée et le rappel appelé par les fonctions du
joystick. La fonction renverra alors ce qu'elle renvoie pour un joystick déconnecté.

Seuls glfwGetJoystickName et glfwGetJoystickUserPointer renverront des valeurs utiles


pour un joystick déconnecté et uniquement avant le retour du rappel du moniteur.

Entrée manette de jeu

Les fonctions du joystick fournissent des axes, des boutons et des chapeaux sans étiquette, sans
indication de leur emplacement sur l'appareil. Leur ordre peut également varier d'une plate-forme
à l'autre, même avec le même appareil.

Pour résoudre ce problème, la communauté SDL a externalisé


le projet SDL_GameControllerDB , une base de données de mappages de nombreux appareils
différents vers une manette de jeu de type Xbox.

GLFW prend en charge ce format de mappage et contient une copie des mappages disponibles
au moment de la publication. Voir Mappages de la manette de jeu pour savoir comment le
mettre à jour au moment de l'exécution. Les mappages seront automatiquement attribués aux
joysticks à chaque fois qu'un joystick est connecté ou que les mappages sont mis à jour.

Vous pouvez vérifier si un joystick est à la fois présent et a un mappage de manette de jeu
avec glfwJoystickIsGamepad .

si ( glfwJoystickIsGamepad ( GLFW_JOYSTICK_2 ))
{
// Utiliser comme manette de jeu
}

Si vous n'êtes intéressé que par l'entrée de la manette de jeu, vous pouvez utiliser cette fonction
au lieu de glfwJoystickPresent .

Vous pouvez interroger le nom lisible fourni par le mappage de la manette de jeu
avec glfwGetGamepadName . Cela peut être ou non le même que le nom du joystick .

const char * nom = glfwGetGamepadName ( GLFW_JOYSTICK_7 );

Pour récupérer l'état de la manette de jeu d'un joystick, appelez glfwGetGamepadState .

état GLFWgamepadstate ;
if ( glfwGetGamepadState ( GLFW_JOYSTICK_3 , &état))
{
if (état. boutons [ GLFW_GAMEPAD_BUTTON_A ])
{
input_jump();
}
input_speed(state. axes [ GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER ]);
}

La structure GLFWgamepadstate a deux tableaux ; un pour les états des boutons et un pour les
états des axes. Les valeurs pour chaque bouton et axe sont les mêmes que pour les
fonctions glfwGetJoystickButtons et glfwGetJoystickAxes , c'est-à-
dire GLFW_PRESSou GLFW_RELEASEpour les boutons et -1,0 à 1,0 inclus pour les axes.

Les tailles des tableaux et les positions au sein de chaque tableau sont fixes.

Les indices des
boutons sont GLFW_GAMEPAD_BUTTON_A, GLFW_GAMEPAD_BUTTON_B, GLFW_GAMEPAD_BUTTON_
X, GLFW_GAMEPAD_BUTTON_Y, GLFW_GAMEPAD_BUTTON_LEFT_BUMPER, GLFW_GAMEPAD_BUTTON
_RIGHT_BUMPER, GLFW_GAMEPAD_BUTTON_BACK, GLFW_GAMEPAD_BUTTON_START, GLFW_GAMEP
AD_BUTTON_GUIDE, GLFW_GAMEPAD_BUTTON_LEFT_THUMB, GLFW_GAMEPAD_BUTTON_RIGHT_TH
UMB, GLFW_GAMEPAD_BUTTON_DPAD_UP, GLFW_GAMEPAD_BUTTON_DPAD_RIGHT, GLFW_GAMEPAD
_BUTTON_DPAD_DOWNet GLFW_GAMEPAD_BUTTON_DPAD_LEFT.

Pour ceux qui préfèrent, il existe également


les alias GLFW_GAMEPAD_BUTTON_CROSS, GLFW_GAMEPAD_BUTTON_CIRCLE, GLFW_GAMEPAD_BU
TTON_SQUAREet GLFW_GAMEPAD_BUTTON_TRIANGLEpour les indices des boutons A, B, X et Y.

Les indices des
axes sont GLFW_GAMEPAD_AXIS_LEFT_X, GLFW_GAMEPAD_AXIS_LEFT_Y, GLFW_GAMEPAD_AXIS
_RIGHT_X, GLFW_GAMEPAD_AXIS_RIGHT_Y, GLFW_GAMEPAD_AXIS_LEFT_TRIGGERet GLFW_GAM
EPAD_AXIS_RIGHT_TRIGGER.

Les constantes GLFW_GAMEPAD_BUTTON_LASTet sont GLFW_GAMEPAD_AXIS_LASTégales au plus


grand index disponible pour chaque tableau.

Mappages de la manette de jeu

GLFW contient une copie des mappages disponibles dans SDL_GameControllerDB au moment


de la publication. Les plus récents peuvent être ajoutés au moment de l'exécution
avec glfwUpdateGamepadMappings .

const char * mappings = load_file_contents( "game/data/gamecontrollerdb.txt" );


glfwUpdateGamepadMappings (mappages);

Cette fonction prend en charge tout, des lignes simples jusqu'au contenu non modifié de
l'ensemble du gamecontrollerdb.txtfichier.
Vous trouverez ci-dessous une description du format de mappage. Veuillez garder à l'esprit
que cette description ne fait pas autorité . Le format est défini par les projets SDL et
SDL_GameControllerDB et leur documentation et leur code sont prioritaires.

Chaque mappage est une seule ligne de valeurs séparées par des virgules décrivant le GUID, le
nom et la disposition de la manette de jeu. Les lignes qui ne commencent pas par un chiffre
hexadécimal sont ignorées.

La première valeur est toujours le GUID de la manette, une chaîne hexadécimale de 32


caractères qui identifie généralement sa marque, son modèle, sa révision et le type de connexion
à l'ordinateur. Lorsque ces informations ne sont pas disponibles, le GUID est généré à l'aide du
nom de la manette de jeu. GLFW utilise le format GUID SDL 2.0.5+ mais peut convertir à partir
des formats plus anciens.

La deuxième valeur est toujours le nom lisible par l'homme de la manette de jeu.

Toutes les valeurs suivantes sont sous la forme <field>:<value>et décrivent la disposition du


mappage. Ces champs peuvent ne pas tous être présents et peuvent apparaître dans n'importe
quel ordre.

Les champs du bouton


sont a, b, c, d, back, start, guide, dpup, dpright, dpdown, dpleft, leftshoulder, rightsh
oulder, leftsticket rightstick.

Les champs des axes sont leftx, lefty, rightx, righty, lefttriggeret righttrigger.

La valeur d'un champ d'axe ou de bouton peut être un bouton de joystick, un axe de joystick, un
masque de chapeau ou vide. Les boutons du joystick sont spécifiés comme bN, par
exemple b2pour le troisième bouton. Les axes du joystick sont spécifiés comme aN, par
exemple a7pour le huitième bouton. Les masques de bits de chapeau de joystick sont spécifiés
comme hN.N, par exemple h0.8pour gauche sur le premier chapeau. Plus d'un bit peut être
défini dans le masque.

Avant un axe, il peut y avoir un +ou un -modificateur de plage, par exemple +a3pour la moitié


positive du quatrième axe. Cela limite l'entrée aux seules moitiés positives ou négatives de l'axe
du joystick. Après un axe ou un demi-axe, il peut y avoir le ~modificateur d'inversion, par
exemple a2~ou -a7~. Cela annule les valeurs de l'axe de la manette.

Le masque de bits de chapeau correspond aux états de chapeau dans les fonctions du joystick.

Il existe également un platformchamp spécial qui spécifie pour quelle plate-forme le mappage


est valide. Les valeurs possibles sont Windows, Mac OS Xet Linux.
Vous trouverez ci-dessous un exemple de ce à quoi pourrait ressembler un mappage de manette
de jeu. C'est celui intégré à GLFW pour les contrôleurs Xbox accessibles via l'API XInput sous
Windows. Cet exemple a été divisé en plusieurs lignes pour tenir sur la page, mais les véritables
mappages de manettes de jeu doivent être sur une seule ligne.

78696e707574010000000000000000000,Manette de jeu XInput (GLFW),plate-


forme:Windows,a:b0,
b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,
joystick droit:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,
déclencheur droit:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,

Noter

GLFW ne prend pas encore en charge la plage de sortie et les modificateurs +et -qui ont
été récemment ajoutés à SDL. Les modificateurs d'entrée +, -et ~sont pris en charge et
décrits ci-dessus.

Saisie de l'heure
GLFW fournit une entrée de temps haute résolution, en secondes, avec glfwGetTime .

secondes doubles = glfwGetTime ();

Il renvoie le nombre de secondes depuis que la bibliothèque a été initialisée avec glfwInit . Les


sources de temps spécifiques à la plate-forme utilisées ont généralement une résolution en
microsecondes ou en nanosecondes.

Vous pouvez modifier l'heure de base avec glfwSetTime .

glfwSetTime (4.0);

Cela définit l'heure à l'heure spécifiée, en secondes, et elle continue à compter à partir de là.

Vous pouvez également accéder au timer brut utilisé pour implémenter les fonctions ci-dessus,
avec glfwGetTimerValue .

valeur uint64_t = glfwGetTimerValue ();

Cette valeur est en 1 / seconde de fréquence. La fréquence de la minuterie brute varie en


fonction du système d'exploitation et du matériel. Vous pouvez interroger la fréquence, en Hz,
avec glfwGetTimerFrequency .
uint64_t fréquence = glfwGetTimerFrequency ();

Entrée et sortie du presse-papiers


Si le presse-papiers du système contient une chaîne encodée en UTF-8 ou s'il peut être converti
en un, vous pouvez le récupérer avec glfwGetClipboardString . Consultez la documentation de
référence pour la durée de vie de la chaîne renvoyée.

const char * text = glfwGetClipboardString (NULL);


si (texte)
{
insert_text(text);
}

Si le presse-papiers est vide ou si son contenu n'a pas pu être converti, NULLest renvoyé.

Le contenu du presse-papiers du système peut être défini sur une chaîne encodée en UTF-8
avec glfwSetClipboardString .

glfwSetClipboardString (NULL, "Une chaîne contenant des mots" );

Entrée de chute de chemin


Si vous souhaitez recevoir les chemins des fichiers et/ou répertoires déposés sur une fenêtre,
définissez un rappel de dépôt de fichier.

glfwSetDropCallback (fenêtre, drop_callback);

La fonction de rappel reçoit un tableau de chemins codés en UTF-8.

void drop_callback( GLFWwindow * window, int count, const char ** chemins)


{
int je;
pour (i = 0; i < compter; i++)
handle_dropped_file(chemins[i]);
}

Le tableau de chemins et ses chaînes ne sont valides que jusqu'au retour du rappel de
suppression de fichier, car ils peuvent avoir été générés spécifiquement pour cet
événement. Vous devez faire une copie complète du tableau si vous souhaitez conserver les
chemins.
Questions fréquemment posées
Cette page tente de répondre à certaines des questions les plus
fréquemment posées par les utilisateurs de GLFW.

Table des matières

 introduction
o 1.1 - Qu'est-ce que GLFW ?
o 1.2 - Qu'est-ce que GLFW n'est pas ?
o 1.3 - Pourquoi encore une autre bibliothèque OpenGL ?
o 1.4 - Quelles plateformes sont supportées par GLFW ?
o 1.5 - Quelles versions d'OpenGL sont supportées par GLFW ?
 Général
o 2.1 - Pourquoi utiliser des profondeurs de bits rouge/vert/bleu
distinctes ?
o 2.2 - Est-il possible de changer de mode vidéo après la création
d'une fenêtre ?
o 2.3 - La prise en charge du chargement d'images ou de
textures sera-t-elle ajoutée à GLFW ?
o 2.4 - Le support du son sera-t-il ajouté à GLFW ?
o 2.5 - La prise en charge du rendu des polices ou du texte sera-
t-elle ajoutée à GLFW ?
o 2.6 - La prise en charge des menus contextuels sera-t-elle
ajoutée à GLFW ?
o 2.7 - La prise en charge de la boîte de message sera-t-elle
ajoutée à GLFW ?
o 2.8 - Qu'est-ce qu'Unicode ?
o 2.9 - Le thread GLFW est-il sûr ?
o 2.10 - Puis-je vérifier plusieurs clés à la fois ?
o 2.11 - Quelles API de minuterie GLFW utilise-t-il ?
o 2.12 - Quelles API de système de fenêtres GLFW utilise-t-il ?
o 2.13 - Pourquoi votre gl.h n'a-t-il pas les fonctions dont j'ai
besoin ?
o 2.14 - Pourquoi mes objets ont-ils l'air tout faux ?
o 2.15 - Puis-je utiliser des chargeurs d'extension avec GLFW ?
o 2.16 - Comment utiliser les méthodes C++ comme callbacks ?
 les fenêtres
o 3.1 - Quels compilateurs sont supportés par GLFW ?
o 3.2 - Pourquoi est-ce que j'obtiens des erreurs de lien lorsque
j'essaie de construire mon programme ?
o 3.3 - Pourquoi glfwSwapInterval ne fonctionne-t-il pas ?
o 3.4 - Avec quelles bibliothèques dois-je lier ?
o 3.5 - Pourquoi mon application se bloque lorsque je déplace ou
redimensionne la fenêtre ?
 macOS
o 4.1 - Comment créer un contexte OpenGL 3.0+ ?
o 4.2 - Avec quelles bibliothèques dois-je lier ?
o 4.3 - Pourquoi ma sortie est-elle dans le coin inférieur gauche
de la fenêtre ?
 Unix/X11
o 5.1 - Avec quelles bibliothèques dois-je lier ?

introduction
1.1 - Qu'est-ce que GLFW ?

GLFW est une petite bibliothèque C qui vous permet de créer et de gérer
des fenêtres, des contextes OpenGL et OpenGL ES et des surfaces
Vulkan, d'énumérer des moniteurs et des modes vidéo ainsi que de gérer
des entrées telles que le clavier, la souris, le joystick, le presse-papiers et
l'heure.

GLFW fournit une fine couche d'abstraction multiplateforme, principalement


pour les applications dont la seule sortie graphique se fait via OpenGL,
OpenGL ES ou Vulkan. Alors que GLFW est très utile lors du
développement d'applications OpenGL multi-plateformes, les développeurs
mono-plateforme peuvent également bénéficier d'éviter d'avoir à traiter
avec des API spécifiques à la plate-forme kludgy.

Les bibliothèques comme GLFW sont utiles car OpenGL et OpenGL ES en


eux-mêmes ne fournissent aucun mécanisme pour créer le contexte
nécessaire, gérer les fenêtres, les entrées utilisateur, la synchronisation,
etc. Comme indiqué dans la spécification OpenGL 3.1 (chapitre 2, premier
paragraphe) :

OpenGL ne s'occupe que du rendu dans un framebuffer (et de la lecture


des valeurs stockées dans ce framebuffer). Il n'y a pas de prise en charge
d'autres périphériques parfois associés au matériel graphique, tels que les
souris et les claviers. Les programmeurs doivent s'appuyer sur d'autres
mécanismes pour obtenir l'entrée de l'utilisateur.

GLFW correspond assez bien à la description des autres mécanismes .

Contrairement aux API GL, Vulkan fournit ses propres fonctions de création
d'instance et de surface, mais la création de surface est spécifique à la
plate-forme et l'API ne couvre toujours que le rendu.

1.2 - Qu'est-ce que GLFW n'est pas ?

GLFW est par conception pas…

 une implémentation d'OpenGL, OpenGL ES ou Vulkan. Il englobe les


différentes API de création de contexte et de surface spécifiques à la
plate-forme.
 un en-tête OpenGL, OpenGL ES ou Vulkan. Il inclut les en-têtes
d'API déjà fournis par votre environnement de développement.
 un chargeur d'extension OpenGL, OpenGL ES ou Vulkan. Il existe
déjà de bonnes bibliothèques de chargeurs d'extensions pour les API
GL.
 une bibliothèque d'interface utilisateur. Il vous permet de créer des
fenêtres de niveau supérieur avec des contextes OpenGL et OpenGL
ES et des surfaces Vulkan. Pas de menus, pas de boutons.
 une bibliothèque Windows uniquement. Les demandes de
fonctionnalités qui ne peuvent pas être implémentées de manière
portable seront refusées à moins qu'elles ne soient discrètes, comme
le port Windows recherchant une GLFW_ICONressource lors de la
création de la fenêtre.
 une bibliothèque de threads. Il existe déjà de bonnes bibliothèques
de threads multiplateformes et le threading a été ajouté aux
bibliothèques standard C11 et C++11.
 une bibliothèque de chargement d'images. Il existe déjà de bonnes
bibliothèques de chargement d'images multiplateformes.
 capable de restituer du texte. Il existe déjà plusieurs bibliothèques qui
rendent du texte avec OpenGL et un rendu de texte multiplateforme
cohérent ne peut de toute façon pas dépendre des installations de
rendu de texte de la plate-forme.
 capable de rendre n'importe quoi. Le rendu dépend de vous et/ou
d'autres bibliothèques.
 intégré à n'importe quelle boîte à outils d'interface utilisateur
sur n'importe quelle plate-forme. De bonnes boîtes à outils d'interface
utilisateur fournissent déjà des widgets compatibles OpenGL et le fait
d'avoir deux bibliothèques s'adressant toutes deux au vaste état
global d'un système de fenêtres pose problème.
 capable de lire le son.
 GLUT ou SDL.

1.3 - Pourquoi encore une autre bibliothèque OpenGL ?

Il existe plusieurs autres bibliothèques disponibles pour aider au


développement OpenGL. Les plus courants sont freeglut , une
implémentation Open Source de GLUT et SDL .

Cependant, freeglut vise principalement à fournir un clone stable de GLUT,


tandis que SDL est trop volumineux pour certaines personnes et n'a jamais
eu OpenGL comme objectif principal.

Nous pensons donc qu'il y a de la place pour une bibliothèque légère et


moderne pour gérer les contextes, les fenêtres et les entrées OpenGL.

1.4 - Quelles plateformes sont supportées par GLFW ?

Actuellement, GLFW prend en charge Windows (XP et versions


ultérieures), macOS (10.8 Mountain Lion et versions ultérieures) et les
systèmes d'exploitation de type Unix avec le système X Window, tels que
Linux, FreeBSD et Cygwin. La prise en charge de Wayland est disponible
mais la fonctionnalité n'est pas encore terminée.

GLFW est conçu pour être aussi portable que possible, et le code a été
écrit dans un souci de portabilité.

1.5 - Quelles versions d'OpenGL sont supportées par GLFW ?

TL; DR Toutes les versions prises en charge par votre système


d'exploitation, pilote et GPU.

Cette question provient probablement de la version originale


des extensions WGL_ARB_create_context et GLX_ARB_create_context, qui
indiquait que l'ancien mécanisme de création de contexte serait limité à la
version OpenGL 2.1. Cependant, ce n'est plus le cas et les spécifications
ont été mises à jour en conséquence.

GLFW 2.6 et les versions antérieures n'utilisent que l'ancien mécanisme de


création de contexte, qui sous Windows et X11 peut renvoyer des
contextes de n'importe quelle version, même nouvelle, à condition qu'ils
implémentent l' ARB_compatibility extension. La plupart des pilotes
modernes le font.
La création explicite de contextes OpenGL de la version 3.0 et supérieure
sur Windows et X11, y compris les profils et les indicateurs, est prise en
charge par GLFW 2.7 et supérieur.

Cependant, macOS ne prenait pas en charge OpenGL 3.0 ou version


ultérieure au moment de la sortie de GLFW 2.7, et la prise en charge
qu'Apple a depuis ajoutée n'inclut que les contextes de profil de base
OpenGL 3.2 à compatibilité ascendante. De plus, la création de tels
contextes nécessite un nouveau code, de sorte que les anciennes versions
de GLFW ne peuvent pas créer de contextes OpenGL 3.0 sur macOS.

La première version de GLFW à prendre en charge la création de contextes


OpenGL 3.2 sur macOS était la 2.7.2.

Général
2.1 - Pourquoi utiliser des profondeurs de bits rouge/vert/bleu
distinctes ?

Parce que c'est ainsi que la plupart des plates-formes décrivent les formats
de pixels compatibles OpenGL et comment OpenGL décrit ses
framebuffers. Cela rend GLFW plus cohérent avec les API avec lesquelles
il interagit et plus évolutif.

Cela ne vous empêche bien sûr pas de présenter à l'utilisateur les


profondeurs de couleur familières à valeur unique.

2.2 - Est-il possible de changer de mode vidéo après la création d'une


fenêtre ?

Vous pouvez modifier la résolution d'une fenêtre plein écran


avec glfwSetWindowSize, mais le format de pixel, c'est-à-dire la profondeur de
bit du framebuffer, restera le même. La modification du format de pixel
nécessite la recréation du contexte.

2.3 - La prise en charge du chargement d'images ou de textures sera-t-


elle ajoutée à GLFW ?

Non.
2.4 - Le support du son sera-t-il ajouté à GLFW ?

Non.

Cependant, si vous recherchez une API de type OpenGL pour le son, jetez
un œil à OpenAL.

2.5 - La prise en charge du rendu des polices ou du texte sera-t-elle


ajoutée à GLFW ?

Non.

Il existe déjà plusieurs kits d'outils de rendu de polices compétents


disponibles pour OpenGL, aucun d'entre eux ne nécessitant une intégration
avec une bibliothèque de gestion de contexte ou de fenêtre.

2.6 - La prise en charge des menus contextuels sera-t-elle ajoutée à


GLFW ?

Non.

2.7 - La prise en charge de la boîte de message sera-t-elle ajoutée à


GLFW ?

Pas tout de suite.

Le principal problème empêchant cet ajout est l'absence d'une boîte à outils
d'interface utilisateur standard compatible Unicode sur les systèmes de
type Unix tels que Linux et FreeBSD. Dépendre, disons, de Gtk+,
introduirait donc une dépendance sur une énorme quantité de code pas
nécessairement présent sur la machine de l'utilisateur.

Comme il n'y a aucune raison pour laquelle le code de la boîte de message


doit être intégré dans GLFW, il est préférable de laisser cette fonctionnalité
à une bibliothèque séparée.

2.8 - Qu'est-ce qu'Unicode ?

Unicode (parfois appelé ISO 10646) est une norme de codage de


caractères qui code pratiquement tous les caractères de toutes les langues
écrites du monde dans un jeu de caractères commun. Il est de plus en plus
accepté dans le monde entier et aujourd'hui, la plupart des plates-formes,
langages informatiques et API prennent en charge Unicode (GLFW en fait
désormais partie).

Visitez le Consortium Unicode pour plus d'informations sur Unicode.


Voir aussi Wikipédia sur Unicode .

2.9 - Le thread GLFW est-il sûr ?

Certaines parties le sont, en particulier celles nécessaires pour permettre le


rendu et la création d'objets Vulkan à partir de threads
secondaires. Voir Thread Safety dans la documentation pour plus de
détails.

2.10 - Puis-je vérifier plusieurs clés à la fois ?

Oui, vous pouvez.

La fonction glfwGetKeyvous permet de vérifier l'état de n'importe quelle


touche du clavier (y compris les touches spéciales). Vous pouvez même
appeler la fonction à partir d'une fonction de rappel, ce qui permet de
vérifier des éléments tels que les événements de touche Ctrl + F3 (lorsque
vous obtenez un GLFW_KEY_F3événement d'appui sur une touche, vérifiez
l'état de la touche CTRL gauche ou droite avec glfwGetKey(window,
GLFW_KEY_LEFT_CONTROL)ou glfwGetKey(window, GLFW_KEY_RIGHT_CONTROL), ou les
deux ).

2.11 - Quelles API de minuterie GLFW utilise-t-il ?

Sous Windows, l' QueryPerformanceCounterAPI est utilisée si disponible,


avec timeGetTimecomme solution de repli.

Sur macOS, la mach_absolute_timesource de temps Mach est utilisée.

Sur les systèmes d'exploitation de type Unix utilisant les ports X11 et
Wayland, la CLOCK_MONOTONICsource de temps POSIX est utilisée si
disponible, avec gettimeofdaycomme solution de secours.

2.12 - Quelles API de système de fenêtres GLFW utilise-t-il ?

Sous Windows, plain Win32 est utilisé pour la gestion des fenêtres et des
entrées, et WGL ou EGL pour créer des contextes OpenGL et OpenGL ES.

Sur macOS, Cocoa est utilisé pour la gestion des fenêtres et des entrées,
et NSOpenGL pour créer des contextes OpenGL.

Sur les systèmes de type Unix utilisant le système X Window, l'API Xlib est
utilisée pour la gestion des fenêtres et des entrées, et GLX ou EGL pour
créer des contextes OpenGL et OpenGL ES.
Sur les systèmes Linux utilisant Wayland, l'API Wayland est utilisée pour la
gestion des fenêtres et des entrées, et EGL pour créer des contextes
OpenGL et OpenGL ES.

2.13 - Pourquoi votre gl.h n'a-t-il pas les fonctions dont j'ai besoin ?

GLFW ne fournit aucune version de gl.hou glu.h. Le glfw3.h fichier d'en-tête


comprend les versions déjà présentes dans votre environnement de
développement.

Cependant, si vous utilisez Windows, vous ne pouvez rien obtenir de plus


récent qu'OpenGL 1.2 sans utiliser d'extensions. La gestion des extensions
dans GLFW étant très rudimentaire, nous vous recommandons d'utiliser
une bibliothèque de chargement d'extensions dédiée telle que glad .

2.14 - Pourquoi mes objets ont-ils l'air tout faux ?

GLFW n'encapsule pas OpenGL. Aucun code GLFW n'est impliqué lorsque


vous effectuez un appel OpenGL. Au lieu de GLFW, pensez à connecter
votre code à OpenGL, puis à vous écarter. Cette connexion est le contexte
OpenGL que vous créez et actualisez avec GLFW. Si vous obtenez des
résultats de rendu incorrects, cela est donc probablement dû à des erreurs
dans votre code, l'implémentation OpenGL ou les deux.

Le wiki OpenGL.org contient un article détaillé sur les erreurs courantes qui


peuvent vous aider à localiser le problème.

2.15 - Puis-je utiliser des chargeurs d'extension avec GLFW ?

Oui, tant que vous empêchez l'en-tête GLFW d'inclure l'en-tête de l'API
client de la plate-forme (par exemple gl.hpour OpenGL). Il y a deux façons
de faire ça. Soit inclure l'en-tête du chargeur d'extension avant d'inclure
l'en-tête GLFW :
#include <glad/glad.h>
#include <GLFW/glfw3.h>

L'en-tête du chargeur d'extension désactivera et remplacera l'en-tête


OpenGL standard inclus dans l'en-tête GLFW. Vous pouvez également
désactiver vous-même l'en-tête OpenGL standard en
définissant GLFW_INCLUDE_NONEavant d'inclure l'en-tête GLFW. Cela vous
permettra d'inclure les en-têtes GLFW et du chargeur d'extension dans
n'importe quel ordre :
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include <glad/glad.h>
2.16 - Comment utiliser les méthodes C++ comme callbacks ?

Vous ne pouvez pas utiliser de méthodes régulières comme rappels, car


GLFW est une bibliothèque C et ne connaît pas les objets et
les thispointeurs. Si vous souhaitez recevoir des rappels vers un objet C++,
utilisez des méthodes statiques ou des fonctions normales comme rappels,
stockez le pointeur vers l'objet que vous souhaitez appeler en tant que
pointeur utilisateur pour la fenêtre et utilisez-le pour appeler des méthodes
sur votre objet.

les fenêtres
3.1 - Quels compilateurs sont supportés par GLFW ?

Actuellement, les versions de GLFW sont testées avec MinGW, MinGW-


w64 et Visual C++ 2010, 2012, 2013 et 2015, mais elles devraient
fonctionner avec n'importe quel compilateur prenant en charge C99 (C89
sous Windows). Les environnements de développement très anciens
peuvent nécessiter des en-têtes système mis à jour.

La distribution binaire Windows de GLFW contient des bibliothèques


précompilées pour MinGW et les versions les plus récentes de Visual C++.

3.2 - Pourquoi est-ce que j'obtiens des erreurs de lien lorsque j'essaie
de construire mon programme ?

Consultez le guide Création de programmes utilisant GLFW pour plus de


détails sur la façon de compiler et de lier des programmes sur différentes
plates-formes.

3.3 - Pourquoi glfwSwapInterval ne fonctionne-t-il pas ?

Les pilotes graphiques modernes ont des paramètres qui permettent aux
utilisateurs de remplacer la demande d'une application pour (entre autres)
l'intervalle d'échange. Si un tel paramètre est activé,
il glfwSwapIntervaln'aura aucun effet.

3.4 - Avec quelles bibliothèques dois-je lier ?


Voir les programmes de construction qui utilisent le guide GLFW pour plus
de détails.

3.5 - Pourquoi mon application se bloque lorsque je déplace ou


redimensionne la fenêtre ?

La boucle d'événements Windows est bloquée par certaines actions telles


que faire glisser ou redimensionner une fenêtre ou ouvrir le menu de la
fenêtre. Cela fait partie de la conception de Windows et ne peut pas être
modifié par GLFW. Si vous souhaitez continuer le rendu pendant de telles
actions, vous devez effectuer le rendu à partir d'un thread secondaire.

macOS
4.1 - Comment créer un contexte OpenGL 3.0+ ?

Les seuls contextes OpenGL 3.x et 4.x actuellement pris en charge par
macOS sont des contextes de profil de base à compatibilité
ascendante. Les versions prises en charge sont 3.2 sur 10.7 Lion et 3.3 et
4.1 sur 10.9 Mavericks. Dans tous les cas, votre GPU doit prendre en
charge la version OpenGL spécifiée pour que la création du contexte
réussisse.

Pour créer un contexte OpenGL 3.2 ou version ultérieure, vous devez


définir les conseils suivants :
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

Cela vous donnera un contexte pour la version la plus élevée d'OpenGL


supérieure ou égale à 3.2 qui est prise en charge par votre système
d'exploitation et votre GPU. Cela fonctionne car aucune fonctionnalité n'a
été dépréciée entre OpenGL 3.2 et 4.1, ce qui rend les backards OpenGL
4.1 à compatibilité ascendante avec 3.2. Si la version demandée n'est pas
prise en charge, la création de la fenêtre échouera.

Si votre code nécessite OpenGL 3.3 ou 4.1, vous pouvez spécifier ces
versions à la place, ainsi que toute version OpenGL valide entre les deux.
4.2 - Avec quelles bibliothèques dois-je lier ?

Voir les programmes de construction qui utilisent le guide GLFW pour plus


de détails.

4.3 - Pourquoi ma sortie est-elle dans le coin inférieur gauche de la


fenêtre ?

Vous passez la taille de la fenêtre, qui est en coordonnées d'écran,


à glViewport, qui fonctionne avec les pixels. Sur macOS avec un écran
Retina, et éventuellement sur d'autres plates-formes à l'avenir, les
coordonnées d'écran et les pixels ne correspondent pas à 1:1. Utilisez la
taille du framebuffer, qui est en pixels, au lieu de la taille de la
fenêtre. Consultez le guide de manipulation des fenêtres pour plus de
détails.

Unix/X11
5.1 - Avec quelles bibliothèques dois-je lier ?

Voir les programmes de construction qui utilisent le guide GLFW pour plus


de détails.

Vous aimerez peut-être aussi