simple2d
v1.2.0
Simple 2D est un petit moteur graphique open source offrant des fonctionnalités essentielles de dessin, de médias et de saisie 2D. Il est écrit en C et fonctionne sur de nombreuses plates-formes, créant des fenêtres natives et interagissant avec le matériel à l'aide de SDL tout en restituant le contenu avec OpenGL.
Veuillez noter que ce README sera continuellement mis à jour à mesure que de nouvelles fonctionnalités seront ajoutées, que des bogues seront corrigés et que d'autres modifications seront apportées. Consultez les notes de version pour obtenir un lien vers la documentation de cette version.
Ouvrez un ticket sur GitHub si vous rencontrez des problèmes, si vous avez une demande de fonctionnalité ou si vous souhaitez simplement poser une question. Apprenez-en davantage sur la contribution ci-dessous.
Simple 2D prend en charge tous les principaux systèmes d'exploitation et plates-formes matérielles et est testé sur les dernières versions de macOS, iOS, tvOS, Windows, Linux et Raspbian sur Raspberry Pi.
Pour installer la dernière version...
Utiliser Homebrew :
brew tap simple2d/tap
brew install simple2d La formule Homebrew ci-dessus installera également les frameworks iOS et tvOS sur /usr/local/Frameworks/Simple2D par défaut. Après l'installation, exécutez la commande simple2d simulator pour voir les options disponibles pour interagir avec les simulateurs iOS et tvOS. Exécutez simple2d build pour apprendre à créer des projets Xcode avec les SDK iOS et tvOS. Des exemples de projets Xcode peuvent être trouvés dans le référentiel deps .
Téléchargez le programme d'installation Windows pour Visual C++ ou MinGW.
Pour MinGW, nous vous recommandons d'utiliser un environnement MSYS2 (également disponible sur Chocolatey) avec une invite de commande MinGW 64 bits (généralement mingw64.exe ). Simple 2D peut également être installé sur MinGW en utilisant les instructions Linux ci-dessous.
Exécutez le script Bash simple2d.sh . Tout sera expliqué tout au long du parcours et vous serez invité avant toute action. Pour exécuter le script depuis le Web, collez cet extrait dans votre terminal :
url= ' https://raw.githubusercontent.com/simple2d/simple2d/master/bin/simple2d.sh ' ; which curl > /dev/null && cmd= ' curl -fsSL ' || cmd= ' wget -qO - ' ; bash <( $cmd $url ) installSimple 2D prend en charge les plates-formes ARM exécutant Linux, comme le Raspberry Pi. Étant donné que la plupart des distributions Linux ont des packages SDL configurés pour les plates-formes de bureau traditionnelles, le script d'installation compilera SDL à partir des sources lorsque ARM est détecté, désactivant les systèmes de fenêtrage (comme X11) et OpenGL (forçant OpenGL ES à la place).
Une fois installé, utilisez l'utilitaire de ligne de commande simple2d pour mettre à jour Simple 2D, rechercher les problèmes, générer les bibliothèques nécessaires à la compilation des applications, et bien plus encore. Exécutez simplement simple2d pour voir toutes les commandes et options disponibles.
Alternativement, vous pouvez compiler et installer Simple 2D à partir des sources. Clonez d’abord ce dépôt en utilisant :
git clone --recursive https://github.com/simple2d/simple2d.git Pour réduire la taille de ce référentiel, les sous-modules Git sont utilisés pour référencer les supports de test et les dépendances. L'indicateur --recursive garantit que les sous-modules sont initialisés et mis à jour lorsque ce référentiel est cloné. Si vous clonez ce dépôt sans l'indicateur --recursive , vous pouvez toujours initialiser et mettre à jour les sous-modules avec :
git submodule init
git submodule update --remote Mettez à jour ces sous-modules à tout moment en utilisant git submodule update --remote
Ensuite, créez et installez sur des systèmes de type Unix, y compris Windows à l'aide de MinGW, en exécutant :
make && make installSous Windows utilisant Visual C++, ouvrez une invite de commande Visual Studio 64 bits et exécutez :
nmake /f NMakefile all install Notez que sur macOS et Linux, le makefile ne recherchera ni n'installera les dépendances, contrairement à l'installation via Homebrew ou le script simple2d.sh , respectivement. Les dépendances pour Windows, prenant en charge à la fois Visual C++ et MinGW, sont incluses dans ce référentiel (référencées par le sous-module deps ) et installées par les deux makefiles.
Sous Windows utilisant Visual C++, Simple 2D sera installé sur %LOCALAPPDATA%simple2d , alors assurez-vous de l'ajouter à votre chemin (par exemple avec set PATH=%PATH%;%LOCALAPPDATA%simple2d ). Dans tous les autres cas, il sera installé dans /usr/local/ . Sous Windows utilisant MinGW, assurez-vous que /usr/local/bin se trouve également dans votre chemin.
Pour créer les archives de version, qui sont jointes sous forme de téléchargements à chaque version, exécutez make release sur macOS et Windows à l'aide de MinGW, et nmake /f NMakefile release sur Windows à l'aide de Visual C++.
Simple 2D dispose de plusieurs programmes de test pour s'assurer que tout fonctionne comme il se doit.
auto.c — Un ensemble de tests unitaires automatisés pour l'interface publique.triangle.c — L'exemple « Hello Triangle » dans ce README.testcard.c — Une carte graphique, similaire aux cartes de test TV, dans le but de garantir le bon fonctionnement des visuels et des entrées.audio.c — Teste les fonctions audio avec différents formats de fichiers interprétés à la fois comme des échantillons sonores et de la musique.controller.c — Fournit un retour visuel et numérique sur les entrées du contrôleur de jeu.triangle-ios-tvos.c — Un triangle.c modifié conçu pour les appareils iOS et tvOS. Exécutez make test , ou nmake /f NMakefile test sous Windows à l'aide de Visual C++, pour compiler les tests dans le répertoire test/ . Les exécutables résultants porteront le même nom que leurs fichiers source C. Étant donné que les chemins des médias sont définis de manière relative dans ces programmes de test, assurez-vous de cd au répertoire test/ avant d'exécuter un test, par exemple :
# On Unix-like systems
make test && cd test/ && ./testcard
# On Windows using MinGW
make test & cd test & testcard.exe
# On Windows using Visual C++
nmake /f NMakefile test & cd test & testcard.exe Chaque test a également une cible makefile, vous pouvez donc créer et exécuter des tests en utilisant, par exemple, make test testcard . Ou, désinstallez tout facilement, reconstruisez Simple 2D et les tests à partir des sources, et exécutez des tests en utilisant make rebuild <name_of_test> , par exemple :
# Rebuild and run `auto.c` then `testcard.c`...
# ...on Unix-like systems and Windows using MinGW
make rebuild auto testcard
# ...on Windows using Visual C++
nmake /f NMakefile rebuild auto testcard Pour exécuter les tests iOS et tvOS, exécutez d'abord make frameworks && make install-frameworks pour créer et installer les frameworks iOS et tvOS. Ensuite, exécutez make ios pour exécuter le test dans un simulateur iOS et make tvos s'exécute dans un simulateur tvOS.
Créer des applications 2D est simple ! Créons une fenêtre et dessinons un triangle...
#include <simple2d.h>
void render () {
S2D_DrawTriangle (
320 , 50 , 1 , 0 , 0 , 1 ,
540 , 430 , 0 , 1 , 0 , 1 ,
100 , 430 , 0 , 0 , 1 , 1
);
}
int main () {
S2D_Window * window = S2D_CreateWindow (
"Hello Triangle" , 640 , 480 , NULL , render , 0
);
S2D_Show ( window );
return 0 ;
} Enregistrez le code ci-dessus dans un fichier appelé triangle.c et compilez-le en exécutant simple2d build triangle.c sur la ligne de commande (dans MinGW, exécutez-le dans une invite Bash). Exécutez maintenant l'application en utilisant ./triangle sur macOS et Linux, ou triangle.exe sous Windows, et profitez de votre superbe triangle dans une fenêtre 640 x 480 à 60 images par seconde !
La commande simple2d build est un raccourci utile pour compiler un fichier source unique. Bien entendu, vous pouvez également utiliser directement un compilateur, par exemple sur des systèmes de type Unix :
cc triangle.c ` simple2d --libs ` -o triangleEt sous Windows en utilisant Visual C++ dans une invite de commande développeur :
cl triangle.c /I %LOCALAPPDATA% s imple2d /link /LIBPATH %LOCALAPPDATA% s imple2d s imple2d.lib /SUBSYSTEM:CONSOLE
# as a PowerShell command
iex " cl triangle.c $( simple2d --libs ) " Découvrons les applications de structuration pour le dessin 2D et plus encore.
Tout le contenu rendu, les entrées et le son sont contrôlés par la fenêtre, donc créer une fenêtre est la première chose que vous ferez. Commencez par déclarer un pointeur vers une structure S2D_Window et initialisez-le en utilisant S2D_CreateWindow() .
S2D_Window * window = S2D_CreateWindow (
"Hello World!" , // title of the window
800 , 600 , // width and height
update , render , // callback function pointers (these can be NULL)
0 // flags
); Pour définir la largeur et la hauteur de la fenêtre de la même manière que celles de l'affichage, utilisez respectivement S2D_DISPLAY_WIDTH et S2D_DISPLAY_HEIGHT pour ces valeurs.
Les indicateurs de fenêtre peuvent être 0 ou l'un des éléments suivants :
S2D_RESIZABLE // allow window to be resized
S2D_BORDERLESS // show window without a border
S2D_FULLSCREEN // show window at fullscreen
S2D_HIGHDPI // enable high DPI mode Les indicateurs peuvent également être combinés à l'aide de l'opérateur OR au niveau du bit, par exemple : S2D_RESIZABLE | S2D_BORDERLESS
La taille de la fenêtre, la zone où les graphiques sont dessinés dans la fenêtre, peut être définie indépendamment de la taille de la fenêtre comme suit :
window -> viewport . width = 400 ;
window -> viewport . height = 300 ; La fenêtre a différents modes de mise à l'échelle, tels que S2D_FIXED (la fenêtre reste de la même taille lorsque la taille de la fenêtre change), S2D_EXPAND (la fenêtre s'agrandit pour remplir la fenêtre lorsqu'elle est redimensionnée), S2D_SCALE (la valeur par défaut, où la fenêtre est mise à l'échelle proportionnellement et est centrée dans le fenêtre), ou S2D_STRETCH (la fenêtre s'étire pour remplir toute la fenêtre). Définissez le mode comme ceci :
window -> viewport . mode = S2D_FIXED ;Avant d'afficher la fenêtre, ces attributs peuvent être définis :
window -> vsync = false; // set the vertical sync, true by default
window -> icon = "app.png" ; // set the icon for the windowUne fois votre fenêtre prête à fonctionner, affichez-la en utilisant :
S2D_Show ( window );À tout moment avant ou pendant l'affichage de la fenêtre, ces attributs peuvent être définis :
// Cap the frame rate, 60 frames per second by default
window -> fps_cap = 30 ;
// Set the window background color, black by default
window -> background . r = 1.0 ;
window -> background . g = 0.5 ;
window -> background . b = 0.8 ;
window -> background . a = 1.0 ; Les fonctions de rappel peuvent également être modifiées à tout moment – plus d’informations à ce sujet ci-dessous. De nombreuses valeurs peuvent être lues à partir de la structure S2D_Window , voir le fichier d'en-tête simple2d.h pour plus de détails.
L'icône de la fenêtre peut être modifiée en utilisant :
S2D_SetIcon ( window , "new_icon.png" );Prenez une capture d'écran de la fenêtre au format PNG, en fournissant un chemin de fichier :
S2D_Screenshot ( window , "./screenshot.png" );Lorsque vous avez terminé avec la fenêtre, libérez-la en utilisant :
S2D_FreeWindow ( window ); La boucle de fenêtre est l'endroit où se déroule toute l'action : la fréquence d'images est définie, les entrées sont gérées, l'état de l'application est mis à jour et les visuels sont rendus. Vous souhaiterez déclarer deux fonctions essentielles qui seront appelées par la boucle de fenêtre : update() et render() . Comme une boucle de jeu traditionnelle, update() est utilisé pour mettre à jour l'état de l'application et render() est utilisé pour dessiner la scène. Simple 2D optimise les deux fonctions en termes de performances et de précision. Il est donc recommandé de séparer les tâches de mise à jour et de rendu.
Les fonctions de mise à jour et de rendu devraient ressembler à ceci :
void update () { /* update your application state */ }
void render () { /* draw stuff */ } N'oubliez pas d'ajouter ces noms de fonctions lors de l'appel de S2D_CreateWindow() (voir la section "La fenêtre" ci-dessus pour un exemple).
Pour quitter la boucle de fenêtre à tout moment, utilisez :
S2D_Close ( window );Toutes sortes de formes et de textures peuvent être dessinées dans la fenêtre. Découvrez chacun d’eux ci-dessous.
Plusieurs formes géométriques sont disponibles, comme des triangles, des quadrilatères (à partir desquels des rectangles et des carrés peuvent être créés), des lignes et des cercles. Chaque forme contient des sommets, c'est-à-dire des endroits où deux lignes se rejoignent pour former un angle (un triangle en a trois, par exemple). Pour chaque sommet d'un triangle et d'un quadrilatère, six valeurs doivent être définies : les coordonnées x et y et quatre valeurs de couleur. Les lignes ont deux sommets, bien que les couleurs de chaque coin puissent être définies. Les cercles ont un seul point central et une seule couleur qui peut être définie. Lorsque les sommets ont des valeurs de couleur différentes, l'espace entre eux est fusionné dans un dégradé.
Les raccourcis pour les exemples ci-dessous sont :
x = the x coordinate
y = the y coordinate
// Color range is from 0.0 to 1.0
r = red
g = green
b = blue
a = alpha ( opacity ) En utilisant cette notation, x2 serait la deuxième coordonnée x et b2 serait la valeur bleue à ce sommet.
Pour dessiner un triangle, utilisez :
S2D_DrawTriangle ( x1 , y1 , r1 , g1 , b1 , a1 ,
x2 , y2 , r2 , g2 , b2 , a2 ,
x3 , y3 , r3 , g3 , b3 , a3 );Pour dessiner un quadrilatère, utilisez :
S2D_DrawQuad ( x1 , y1 , r1 , g1 , b1 , a1 ,
x2 , y2 , r2 , g2 , b2 , a2 ,
x3 , y3 , r3 , g3 , b3 , a3 ,
x4 , y4 , r4 , g4 , b4 , a4 );Pour tracer une ligne, utilisez :
S2D_DrawLine ( x1 , y1 , x2 , y2 ,
width ,
r1 , g1 , b1 , a1 ,
r2 , g2 , b2 , a2 ,
r3 , g3 , b3 , a3 ,
r4 , g4 , b4 , a4 );Pour dessiner un cercle, utilisez :
S2D_DrawCircle ( x , y , radius , sectors , r , g , b , a ); Des images dans de nombreux formats populaires, tels que JPEG, PNG et BMP, peuvent être dessinées dans la fenêtre. Contrairement aux formes, les images doivent être lues à partir de fichiers et stockées en mémoire. Déclarez simplement un pointeur vers une structure S2D_Image et initialisez-le en utilisant S2D_CreateImage() en fournissant le chemin du fichier vers l'image.
S2D_Image * img = S2D_CreateImage ( "image.png" ); Si l'image est introuvable, elle renverra NULL .
Une fois que vous avez votre image, vous pouvez alors modifier sa position x, y comme ceci :
img -> x = 125 ;
img -> y = 350 ;Modifiez la taille de l'image en ajustant sa largeur et sa hauteur :
img -> width = 256 ;
img -> height = 512 ;Faites pivoter l'image comme ceci :
// Angle should be in degrees
// The last parameter is the point the image should rotate around, either:
// S2D_CENTER, S2D_TOP_LEFT, S2D_TOP_RIGHT, S2D_BOTTOM_LEFT, or S2D_BOTTOM_RIGHT
S2D_RotateImage ( img , angle , S2D_CENTER );
// Or, set a custom point to rotate around
img -> rx = 50 ;
img -> ry = 75 ;
// Set the rotation angle directly
img -> rotate = 90 ;Vous pouvez également ajuster la couleur de l'image comme ceci :
// Default is 1.0 for each, a white color filter
img -> color . r = 1.0 ;
img -> color . g = 0.8 ;
img -> color . b = 0.2 ;
img -> color . a = 1.0 ;Enfin, dessinez l'image en utilisant :
S2D_DrawImage ( img );Puisque les images sont allouées dynamiquement, libérez-les en utilisant :
S2D_FreeImage ( img ); Les sprites sont des types spéciaux d'images qui peuvent être utilisés pour créer des animations. Pour créer un sprite, déclarez un pointeur vers une structure S2D_Sprite et initialisez-le à l'aide de S2D_CreateSprite() en fournissant le chemin du fichier vers l'image de la feuille de sprite.
S2D_Sprite * spr = S2D_CreateSprite ( "sprite_sheet.png" ); Si l'image du sprite est introuvable, elle renverra NULL .
Découpez la feuille de sprite sur une seule image en fournissant un rectangle de découpage :
S2D_ClipSprite ( spr , x , y , width , height ); La position x, y du sprite lui-même peut être modifiée comme suit :
spr -> x = 150 ;
spr -> y = 275 ;Modifiez la taille du sprite en ajustant sa largeur et sa hauteur :
spr -> width = 100 ;
spr -> height = 100 ;Faites pivoter le sprite comme ceci :
// Angle should be in degrees
// The last parameter is the point the sprite should rotate around, either:
// S2D_CENTER, S2D_TOP_LEFT, S2D_TOP_RIGHT, S2D_BOTTOM_LEFT, or S2D_BOTTOM_RIGHT
S2D_RotateSprite ( spr , angle , S2D_CENTER );
// Or, set a custom point to rotate around
spr -> rx = 50 ;
spr -> ry = 75 ;
// Set the rotation angle directly
spr -> rotate = 90 ;Vous pouvez également ajuster la couleur de l'image du sprite comme ceci :
// Default is 1.0 for each, a white color filter
spr -> color . r = 1.0 ;
spr -> color . g = 0.8 ;
spr -> color . b = 0.2 ;
spr -> color . a = 1.0 ;Enfin, dessinez le sprite en utilisant :
S2D_DrawSprite ( spr );Puisque les sprites sont alloués dynamiquement, libérez-les en utilisant :
S2D_FreeSprite ( spr ); Le texte est dessiné un peu comme des images. Commencez par trouver votre police OpenType préférée (avec une extension de fichier .ttf ou .otf ), puis déclarez un pointeur vers une structure S2D_Text et initialisez-la à l'aide de S2D_CreateText() en fournissant le chemin du fichier vers la police, le message à afficher et la taille. .
S2D_Text * txt = S2D_CreateText ( "vera.ttf" , "Hello world!" , 20 ); Si le fichier de police est introuvable, il renverra NULL .
Vous pouvez ensuite modifier la position x, y du texte, par exemple :
txt -> x = 127 ;
txt -> y = 740 ;Faites pivoter le texte comme ceci :
// Angle should be in degrees
// The last parameter is the point the text should rotate around, either:
// S2D_CENTER, S2D_TOP_LEFT, S2D_TOP_RIGHT, S2D_BOTTOM_LEFT, or S2D_BOTTOM_RIGHT
S2D_RotateText ( txt , angle , S2D_CENTER );
// Or, set a custom point to rotate around
txt -> rx = 50 ;
txt -> ry = 75 ;
// Set the rotation angle directly
txt -> rotate = 90 ;Changez la couleur du texte comme ceci :
// Default is 1.0 for each, a white color filter
txt -> color . r = 0.5 ;
txt -> color . g = 1.0 ;
txt -> color . b = 0.0 ;
txt -> color . a = 0.7 ;Enfin, dessinez le texte en utilisant :
S2D_DrawText ( txt );Vous pouvez également modifier le SMS à tout moment :
S2D_SetText ( txt , "A different message!" );
// Format text just like `printf`
S2D_SetText ( txt , "Welcome %s!" , player );Puisque le texte est alloué dynamiquement, libérez-le en utilisant :
S2D_FreeText ( txt );Simple 2D prend en charge un certain nombre de formats audio populaires, notamment WAV, MP3, Ogg Vorbis et FLAC. Il existe deux types de concepts audio : les sons et la musique. Les sons sont destinés à être de courts échantillons, joués sans interruption, comme un effet. La musique est destinée à des morceaux plus longs qui peuvent être joués, mis en pause, arrêtés, repris et fondus, comme une bande sonore de fond.
Créez un son en déclarant d'abord un pointeur vers une structure S2D_Sound et initialisez-le en utilisant S2D_CreateSound() fournissant le chemin d'accès au fichier audio.
S2D_Sound * snd = S2D_CreateSound ( "sound.wav" ); Si le fichier audio est introuvable, il renverra NULL .
Jouez le son comme ceci :
S2D_PlaySound ( snd );Vous pouvez obtenir et régler le volume d'un son comme ceci :
int volume = S2D_GetSoundVolume ( snd );
S2D_SetSoundVolume ( snd , 50 ); // set volume 50%De plus, obtenez et réglez le volume de tous les sons comme ceci, où le volume est compris entre 0 (le plus doux) et 100 (le plus fort) :
int volume = S2D_GetSoundMixVolume ();
S2D_SetSoundMixVolume ( 50 ); // set volume 50%Puisque les sons sont alloués dynamiquement, libérez-les en utilisant :
S2D_FreeSound ( snd ); De même, créez de la musique en déclarant un pointeur vers une structure S2D_Music et initialisez-la en utilisant S2D_CreateMusic() fournissant le chemin d'accès au fichier audio.
S2D_Music * mus = S2D_CreateMusic ( "music.ogg" ); Si le fichier audio est introuvable, il renverra NULL .
Jouez la musique comme ceci, où le deuxième paramètre est une valeur booléenne indiquant si la musique doit être répétée :
S2D_PlayMusic ( mus , true); // play on a loopUn seul morceau de musique peut être joué à la fois. Les fonctions suivantes pour mettre en pause, reprendre, obtenir et régler le volume, arrêter et disparaître s'appliquent à la musique en cours de lecture :
S2D_PauseMusic ();
S2D_ResumeMusic ();
S2D_StopMusic ();
int volume = S2D_GetMusicVolume ();
S2D_SetMusicVolume ( 50 ); // set volume 50%
// Fade out over 2000 milliseconds, or 2 seconds
S2D_FadeOutMusic ( 2000 );Puisque la musique est allouée dynamiquement, libérez-la en utilisant :
S2D_FreeMusic ( mus );La 2D simple peut capturer les données d'à peu près n'importe quoi. Apprenons à récupérer les événements d'entrée de la souris, du clavier et des contrôleurs de jeu.
Il existe trois types d'événements de clavier capturés par la fenêtre : lorsqu'une touche est enfoncée, une touche est maintenue enfoncée et une touche est relâchée. Lorsqu'un événement clavier a lieu, la fenêtre appelle sa fonction on_key() .
Pour capturer la saisie au clavier, définissez d'abord la fonction on_key() et lisez les détails de l'événement à partir de la structure S2D_Event , par exemple :
void on_key ( S2D_Event e ) {
// Check `e.key` for the key being interacted with
switch ( e . type ) {
case S2D_KEY_DOWN :
// Key was pressed
break ;
case S2D_KEY_HELD :
// Key is being held down
break ;
case S2D_KEY_UP :
// Key was released
break ;
}
}Ensuite, attachez le rappel à la fenêtre :
window -> on_key = on_key ; La position du curseur de la souris ou du trackpad peut être lue à tout moment depuis la fenêtre. Notez que le coin supérieur gauche est l’origine, (0, 0) .
window -> mouse . x ;
window -> mouse . y ; Pour capturer l'entrée du bouton de la souris, définissez d'abord la fonction on_mouse() et lisez les détails de l'événement à partir de la structure S2D_Event , par exemple :
// `e.button` can be one of:
// S2D_MOUSE_LEFT
// S2D_MOUSE_MIDDLE
// S2D_MOUSE_RIGHT
// S2D_MOUSE_X1
// S2D_MOUSE_X2
void on_mouse ( S2D_Event e ) {
switch ( e . type ) {
case S2D_MOUSE_DOWN :
// Mouse button was pressed
// Use `e.button` to see what button was clicked
// Check `e.dblclick` to see if was a double click
break ;
case S2D_MOUSE_UP :
// Mouse button was released
// Use `e.button` to see what button was clicked
// Check `e.dblclick` to see if was a double click
break ;
case S2D_MOUSE_SCROLL :
// Mouse was scrolled
// Check `e.direction` for direction being scrolled, normal or inverted:
// S2D_MOUSE_SCROLL_NORMAL
// S2D_MOUSE_SCROLL_INVERTED
// Check `e.delta_x` and `e.delta_y` for the difference in x and y position
break ;
case S2D_MOUSE_MOVE :
// Mouse was moved
// Check `e.delta_x` and `e.delta_y` for the difference in x and y position
break ;
}
}Ensuite, attachez le rappel à la fenêtre :
window -> on_mouse = on_mouse ;Cachez le curseur sur la fenêtre (et affichez-le à nouveau) en utilisant :
S2D_HideCursor ();
S2D_ShowCursor (); Tous les contrôleurs de jeu sont automatiquement détectés, ajoutés et supprimés. Il existe deux types d'événements capturés par la fenêtre : le mouvement de l'axe et les pressions sur les boutons. Lorsqu'un bouton est enfoncé ou qu'un joystick est déplacé, la fenêtre appelle sa fonction on_controller() . Les boutons et les axes sont mappés sur une disposition générique de contrôleur Xbox.
Pour capturer l'entrée du contrôleur, définissez d'abord la fonction on_controller() et lisez les détails de l'événement à partir de la structure S2D_Event , par exemple :
void on_controller ( S2D_Event e ) {
// Check `e.which` for the controller being interacted with
switch ( e . type ) {
case S2D_AXIS :
// Controller axis was moved
// Use `e.axis` to get the axis, either:
// S2D_AXIS_LEFTX, S2D_AXIS_LEFTY,
// S2D_AXIS_RIGHTX, S2D_AXIS_RIGHTY,
// S2D_AXIS_TRIGGERLEFT, S2D_AXIS_TRIGGERRIGHT,
// or S2D_AXIS_INVALID
// Use `e.value` to get the value of the axis
break ;
// For the following button events, use `e.button`
// to get the button pressed or released, which can be:
// S2D_BUTTON_A, S2D_BUTTON_B, S2D_BUTTON_X, S2D_BUTTON_Y,
// S2D_BUTTON_BACK, S2D_BUTTON_GUIDE, S2D_BUTTON_START,
// S2D_BUTTON_LEFTSTICK, S2D_BUTTON_RIGHTSTICK,
// S2D_BUTTON_LEFTSHOULDER, S2D_BUTTON_RIGHTSHOULDER,
// S2D_BUTTON_DPAD_UP, S2D_BUTTON_DPAD_DOWN,
// S2D_BUTTON_DPAD_LEFT, S2D_BUTTON_DPAD_RIGHT,
// or S2D_BUTTON_INVALID
case S2D_BUTTON_DOWN :
// Controller button was pressed
break ;
case S2D_BUTTON_UP :
// Controller button was released
break ;
}
}Ensuite, attachez le rappel à la fenêtre :
window -> on_controller = on_controller ; Voir le test controller.c pour un exemple exhaustif de la façon d'interagir avec les contrôleurs de jeu.
Vous êtes certain de trouver des contrôleurs qui n'ont pas encore de mappage de boutons, surtout s'ils sont neufs. Consultez la base de données communautaire des mappages de contrôleurs pour des exemples de génération de chaînes de mappage. Une fois que vous avez la chaîne de mappage, vous pouvez l'enregistrer en utilisant S2D_AddControllerMapping() , ou ajouter plusieurs mappages à partir d'un fichier en utilisant S2D_AddControllerMappingsFromFile() et en fournissant le chemin du fichier.
"Le simple peut être plus difficile que le complexe : vous devez travailler dur pour clarifier votre pensée afin de rendre les choses simples. Mais cela en vaut la peine, car une fois que vous y êtes parvenu, vous pouvez déplacer des montagnes." -Steve Jobs
Malgré les progrès continus du matériel et des logiciels d'infographie, se lancer dans une programmation graphique simple n'est pas si simple ni accessible. Nous travaillons pour changer cela.
Si vous aimez le projet, pensez à contribuer ! Consultez les numéros ouverts pour trouver des idées ou suggérez les vôtres. Nous recherchons toujours des moyens de rendre le projet plus attrayant et d'améliorer l'expérience des développeurs sur chaque plateforme. Ne vous inquiétez pas si vous n'êtes pas un expert en C ou en API graphiques, nous serons ravis de vous guider tout au long de votre parcours.
Si vous êtes un hacker inconditionnel de C et OS, vous devriez sérieusement envisager de contribuer à SDL afin que nous puissions continuer à écrire des jeux sans vous soucier des détails de la plate-forme en dessous. Jetez un œil aux conférences des Steam Dev Days, en particulier à celle de Ryan C. Gordon sur le développement de jeux avec SDL 2.0.
simple2d.shdeps (suivez les instructions dans le README) et exécutez git submodule update --remote dans ce dépôt pour mettre à jour le sous-module.simple2d.sh et simple2d.cmd , valider les modificationsrelease make/nmakev#.#.# ; joindre les programmes d'installation Windows et les bibliothèques Apple aux notes de versionsha256 pour la version et l'archive des frameworks, en utilisant shasum -a 256 <file>brew audit --strict ./simple2d.rb pour détecter tout problème avec la formulebrew install ./simple2d.rbSimple 2D a été créé par Tom Black, qui pensait que la programmation graphique simple était trop difficile et a décidé de faire quelque chose.
Tout est sous licence MIT, alors piratez.
Apprécier!
