simple2d
v1.2.0
Simple 2D ist eine kleine Open-Source-Grafik-Engine, die wichtige 2D-Zeichnungs-, Medien- und Eingabefunktionen bietet. Es ist in C geschrieben und funktioniert auf vielen Plattformen, erstellt native Fenster und interagiert mit Hardware über SDL, während Inhalte mit OpenGL gerendert werden.
Bitte beachten Sie, dass diese README-Datei kontinuierlich aktualisiert wird, wenn neue Funktionen hinzugefügt, Fehler behoben und andere Änderungen vorgenommen werden. Sehen Sie sich die Versionshinweise an, um einen Link zur Dokumentation dieser Version zu erhalten.
Öffnen Sie ein Problem auf GitHub, wenn Sie auf Probleme stoßen, eine Funktionsanfrage haben oder einfach eine Frage stellen möchten. Erfahren Sie unten mehr über das Mitwirken.
Simple 2D unterstützt alle wichtigen Betriebssysteme und Hardwareplattformen und wurde auf den neuesten Versionen von macOS, iOS, tvOS, Windows, Linux und Raspbian auf dem Raspberry Pi getestet.
Um die neueste Version zu installieren...
Verwenden Sie Homebrew:
brew tap simple2d/tap
brew install simple2d Die obige Homebrew-Formel installiert standardmäßig auch die iOS- und tvOS-Frameworks in /usr/local/Frameworks/Simple2D . Führen Sie nach der Installation den Befehl simple2d simulator aus, um die verfügbaren Optionen für die Interaktion mit den iOS- und tvOS-Simulatoren anzuzeigen. Führen Sie simple2d build aus, um zu erfahren, wie Sie Xcode-Projekte mit den iOS- und tvOS-SDKs erstellen. Beispiel-Xcode-Projekte finden Sie im deps Repository.
Laden Sie das Windows-Installationsprogramm für Visual C++ oder MinGW herunter.
Für MinGW empfehlen wir die Verwendung einer MSYS2-Umgebung (auch auf Chocolatey verfügbar) zusammen mit einer MinGW 64-Bit-Eingabeaufforderung (normalerweise mingw64.exe ). Simple 2D kann mithilfe der folgenden Linux-Anweisungen auch auf MinGW installiert werden.
Führen Sie das Bash-Skript simple2d.sh aus. Dabei wird Ihnen alles erklärt und Sie werden aufgefordert, bevor Maßnahmen ergriffen werden. Um das Skript über das Internet auszuführen, fügen Sie dieses Snippet in Ihr Terminal ein:
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 unterstützt ARM-Plattformen unter Linux, wie den Raspberry Pi. Da bei den meisten Linux-Distributionen SDL-Pakete für herkömmliche Desktop-Plattformen konfiguriert sind, kompiliert das Installationsskript SDL aus der Quelle, wenn ARM erkannt wird, und deaktiviert dabei Fenstersysteme (wie X11) und OpenGL (und erzwingt stattdessen OpenGL ES).
Verwenden Sie nach der Installation das Befehlszeilendienstprogramm simple2d , um Simple 2D zu aktualisieren, auf Probleme zu prüfen, die zum Kompilieren von Anwendungen erforderlichen Bibliotheken auszugeben und vieles mehr. Führen Sie einfach simple2d aus, um alle verfügbaren Befehle und Optionen anzuzeigen.
Alternativ können Sie Simple 2D aus dem Quellcode kompilieren und installieren. Klonen Sie zunächst dieses Repo mit:
git clone --recursive https://github.com/simple2d/simple2d.git Um die Größe dieses Repositorys klein zu halten, werden Git-Submodule verwendet, um auf Testmedien und Abhängigkeiten zu verweisen. Das Flag --recursive stellt sicher, dass Submodule initialisiert und aktualisiert werden, wenn dieses Repo geklont wird. Wenn Sie dieses Repo ohne das Flag --recursive geklont haben, können Sie Submodule trotzdem initialisieren und aktualisieren mit:
git submodule init
git submodule update --remote Aktualisieren Sie diese Submodule jederzeit mit git submodule update --remote
Erstellen und installieren Sie als Nächstes auf Unix-ähnlichen Systemen, einschließlich Windows, mit MinGW, indem Sie Folgendes ausführen:
make && make installÖffnen Sie unter Windows mit Visual C++ eine 64-Bit-Visual Studio-Eingabeaufforderung und führen Sie Folgendes aus:
nmake /f NMakefile all install Beachten Sie, dass das Makefile unter macOS und Linux im Gegensatz zur Installation über Homebrew bzw. das Skript simple2d.sh nicht nach Abhängigkeiten sucht oder diese installiert. Abhängigkeiten für Windows, die sowohl Visual C++ als auch MinGW unterstützen, sind in diesem Repository enthalten (auf das durch das deps Submodul verwiesen wird) und werden von beiden Makefiles installiert.
Unter Windows mit Visual C++ wird Simple 2D unter %LOCALAPPDATA%simple2d installiert. Stellen Sie daher sicher, dass Sie dies zu Ihrem Pfad hinzufügen (zum Beispiel mit set PATH=%PATH%;%LOCALAPPDATA%simple2d ). In allen anderen Fällen wird es nach /usr/local/ installiert. Stellen Sie unter Windows mit MinGW sicher, dass sich auch /usr/local/bin in Ihrem Pfad befindet.
Um die Release-Archive zu erstellen, die jeder Version als Download beigefügt sind, führen Sie make release unter macOS und Windows mit MinGW und nmake /f NMakefile release unter Windows mit Visual C++ aus.
Simple 2D verfügt über mehrere Testprogramme, um sicherzustellen, dass alles wie gewünscht funktioniert.
auto.c – Eine Reihe automatisierter Komponententests für die öffentliche Schnittstelle.triangle.c – Das „Hello Triangle“-Beispiel in dieser README-Datei.testcard.c – Eine Grafikkarte, ähnlich wie TV-Testkarten, mit dem Ziel sicherzustellen, dass Bilder und Eingaben ordnungsgemäß funktionieren.audio.c – Testet Audiofunktionen mit verschiedenen Dateiformaten, die sowohl als Klangbeispiele als auch als Musik interpretiert werden.controller.c – Bietet visuelles und numerisches Feedback zur Gamecontroller-Eingabe.triangle-ios-tvos.c – Ein modifiziertes triangle.c das für iOS- und tvOS-Geräte entwickelt wurde. Führen Sie make test oder nmake /f NMakefile test unter Windows mit Visual C++ aus, um Tests im Verzeichnis test/ zu kompilieren. Die resultierenden ausführbaren Dateien haben denselben Namen wie ihre C-Quelldateien. Da Medienpfade in diesen Testprogrammen relativ festgelegt sind, stellen Sie sicher, dass cd in das Verzeichnis test/ wechseln, bevor Sie einen Test ausführen, zum Beispiel:
# 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 Jeder Test verfügt außerdem über ein Makefile-Ziel, sodass Sie Tests beispielsweise mit make test testcard erstellen und ausführen können. Oder deinstallieren Sie bequem alles, erstellen Sie Simple 2D und Tests aus dem Quellcode neu und führen Sie Tests mit make rebuild <name_of_test> aus, zum Beispiel:
# 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 Um die iOS- und tvOS-Tests auszuführen, führen Sie zunächst make frameworks && make install-frameworks aus, um die iOS- und tvOS-Frameworks zu erstellen und zu installieren. Führen Sie als Nächstes make ios aus, um den Test in einem iOS-Simulator auszuführen, und make tvos um ihn in einem tvOS-Simulator auszuführen.
Das Erstellen von 2D-Apps ist einfach! Lassen Sie uns ein Fenster erstellen und ein Dreieck zeichnen ...
#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 ;
} Speichern Sie den obigen Code in einer Datei namens triangle.c und kompilieren Sie ihn, indem Sie simple2d build triangle.c in der Befehlszeile ausführen (führen Sie dies in MinGW in einer Bash-Eingabeaufforderung aus). Führen Sie jetzt die App mit ./triangle unter macOS und Linux oder triangle.exe unter Windows aus und genießen Sie Ihr atemberaubendes Dreieck in einem 640x480-Fenster mit 60 Bildern pro Sekunde!
Der Befehl simple2d build ist eine hilfreiche Verknüpfung zum Kompilieren einer einzelnen Quelldatei. Natürlich können Sie auch direkt einen Compiler verwenden, beispielsweise auf Unix-ähnlichen Systemen:
cc triangle.c ` simple2d --libs ` -o triangleUnd unter Windows mit Visual C++ in einer Entwickler-Eingabeaufforderung:
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 ) " Erfahren Sie mehr über Strukturierungsanwendungen für 2D-Zeichnungen und mehr.
Der gesamte gerenderte Inhalt, alle Eingaben und der Ton werden durch das Fenster gesteuert, daher ist das Erstellen eines Fensters das Erste, was Sie tun müssen. Beginnen Sie mit der Deklaration eines Zeigers auf eine S2D_Window -Struktur und initialisieren Sie ihn mit 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
); Um die Breite und Höhe des Fensters auf die gleiche Weise wie die Anzeige einzustellen, verwenden Sie S2D_DISPLAY_WIDTH bzw. S2D_DISPLAY_HEIGHT für diese Werte.
Die Fensterflags können 0 oder eine der folgenden sein:
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 Flags können auch mit dem bitweisen ODER-Operator kombiniert werden, zum Beispiel: S2D_RESIZABLE | S2D_BORDERLESS
Die Größe des Ansichtsfensters, also des Bereichs, in dem Grafiken im Fenster gezeichnet werden, kann unabhängig von der Fenstergröße wie folgt eingestellt werden:
window -> viewport . width = 400 ;
window -> viewport . height = 300 ; Das Ansichtsfenster verfügt über verschiedene Skalierungsmodi, wie z. B. S2D_FIXED (das Ansichtsfenster behält die gleiche Größe, wenn sich die Fenstergröße ändert), S2D_EXPAND (das Ansichtsfenster wird erweitert, um das Fenster auszufüllen, wenn die Größe geändert wird), S2D_SCALE (die Standardeinstellung, bei der das Ansichtsfenster proportional skaliert und in der Mitte zentriert wird). Fenster) oder S2D_STRETCH (Ansichtsfenster wird gedehnt, um das gesamte Fenster auszufüllen). Stellen Sie den Modus wie folgt ein:
window -> viewport . mode = S2D_FIXED ;Bevor das Fenster angezeigt wird, können folgende Attribute festgelegt werden:
window -> vsync = false; // set the vertical sync, true by default
window -> icon = "app.png" ; // set the icon for the windowSobald Ihr Fenster betriebsbereit ist, zeigen Sie es an mit:
S2D_Show ( window );Diese Attribute können jederzeit vor oder während der Anzeige des Fensters festgelegt werden:
// 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 ; Auch Callback-Funktionen können jederzeit geändert werden – mehr dazu weiter unten. Viele Werte können aus der S2D_Window -Struktur gelesen werden. Weitere Informationen finden Sie in der Header-Datei simple2d.h .
Das Fenstersymbol kann geändert werden mit:
S2D_SetIcon ( window , "new_icon.png" );Machen Sie einen Screenshot des Fensters im PNG-Format und geben Sie einen Dateipfad an:
S2D_Screenshot ( window , "./screenshot.png" );Wenn Sie mit dem Fenster fertig sind, geben Sie es frei, indem Sie Folgendes verwenden:
S2D_FreeWindow ( window ); In der Fensterschleife finden alle Aktionen statt: Die Bildrate wird festgelegt, Eingaben werden verarbeitet, der App-Status wird aktualisiert und visuelle Elemente werden gerendert. Sie möchten zwei wesentliche Funktionen deklarieren, die von der Fensterschleife aufgerufen werden: update() und render() . Wie bei einer herkömmlichen Spielschleife wird update() zum Aktualisieren des Anwendungsstatus und render() zum Zeichnen der Szene verwendet. Simple 2D optimiert beide Funktionen hinsichtlich Leistung und Genauigkeit, daher empfiehlt es sich, diese Aktualisierungs- und Rendering-Aufgaben getrennt zu halten.
Die Update- und Renderfunktionen sollten wie folgt aussehen:
void update () { /* update your application state */ }
void render () { /* draw stuff */ } Denken Sie daran, diese Funktionsnamen hinzuzufügen, wenn Sie S2D_CreateWindow() aufrufen (ein Beispiel finden Sie im Abschnitt „Das Fenster“ oben).
Um die Fensterschleife jederzeit zu verlassen, verwenden Sie:
S2D_Close ( window );Im Fenster können alle möglichen Formen und Texturen gezeichnet werden. Erfahren Sie unten mehr über jeden einzelnen davon.
Es stehen verschiedene geometrische Formen zur Verfügung, wie Dreiecke, Vierecke (aus denen Rechtecke und Quadrate hergestellt werden können), Linien und Kreise. Jede Form enthält Scheitelpunkte, also Stellen, an denen sich zwei Linien treffen, um einen Winkel zu bilden (ein Dreieck hat beispielsweise drei). Für jeden Scheitelpunkt eines Dreiecks und Vierecks müssen sechs Werte festgelegt werden: die x und y -Koordinaten sowie vier Farbwerte. Linien haben zwei Eckpunkte, obwohl Farben für jede Ecke festgelegt werden können. Kreise haben einen einzigen Mittelpunkt und eine einstellbare Farbe. Wenn Scheitelpunkte unterschiedliche Farbwerte haben, wird der Raum zwischen ihnen in einem Farbverlauf gemischt.
Die Abkürzungen für die folgenden Beispiele lauten:
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 ) Bei Verwendung dieser Notation wäre x2 die zweite x Koordinate und b2 wäre der Blauwert an diesem Scheitelpunkt.
Um ein Dreieck zu zeichnen, verwenden Sie:
S2D_DrawTriangle ( x1 , y1 , r1 , g1 , b1 , a1 ,
x2 , y2 , r2 , g2 , b2 , a2 ,
x3 , y3 , r3 , g3 , b3 , a3 );Um ein Viereck zu zeichnen, verwenden Sie:
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 );Um eine Linie zu zeichnen, verwenden Sie:
S2D_DrawLine ( x1 , y1 , x2 , y2 ,
width ,
r1 , g1 , b1 , a1 ,
r2 , g2 , b2 , a2 ,
r3 , g3 , b3 , a3 ,
r4 , g4 , b4 , a4 );Um einen Kreis zu zeichnen, verwenden Sie:
S2D_DrawCircle ( x , y , radius , sectors , r , g , b , a ); Im Fenster können Bilder in vielen gängigen Formaten wie JPEG, PNG und BMP gezeichnet werden. Im Gegensatz zu Formen müssen Bilder aus Dateien gelesen und im Speicher gespeichert werden. Deklarieren Sie einfach einen Zeiger auf eine S2D_Image -Struktur und initialisieren Sie ihn mit S2D_CreateImage() das den Dateipfad zum Bild bereitstellt.
S2D_Image * img = S2D_CreateImage ( "image.png" ); Wenn das Bild nicht gefunden werden kann, wird NULL zurückgegeben.
Sobald Sie Ihr Bild haben, können Sie seine x, y -Position wie folgt ändern:
img -> x = 125 ;
img -> y = 350 ;Ändern Sie die Größe des Bildes, indem Sie dessen Breite und Höhe anpassen:
img -> width = 256 ;
img -> height = 512 ;Drehen Sie das Bild wie folgt:
// 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 ;Sie können die Farbe des Bildes auch wie folgt anpassen:
// 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 ;Zeichnen Sie abschließend das Bild mit:
S2D_DrawImage ( img );Da Bilder dynamisch zugewiesen werden, geben Sie sie frei, indem Sie Folgendes verwenden:
S2D_FreeImage ( img ); Sprites sind spezielle Arten von Bildern, die zur Erstellung von Animationen verwendet werden können. Um ein Sprite zu erstellen, deklarieren Sie einen Zeiger auf eine S2D_Sprite Struktur und initialisieren Sie ihn mit S2D_CreateSprite() das den Dateipfad zum Sprite-Sheet-Bild bereitstellt.
S2D_Sprite * spr = S2D_CreateSprite ( "sprite_sheet.png" ); Wenn das Sprite-Bild nicht gefunden werden kann, wird NULL zurückgegeben.
Schneiden Sie das Sprite-Sheet auf ein einzelnes Bild zu, indem Sie ein Ausschnittsrechteck bereitstellen:
S2D_ClipSprite ( spr , x , y , width , height ); Die x, y Position des Sprites selbst kann wie folgt geändert werden:
spr -> x = 150 ;
spr -> y = 275 ;Ändern Sie die Größe des Sprites, indem Sie seine Breite und Höhe anpassen:
spr -> width = 100 ;
spr -> height = 100 ;Drehen Sie das Sprite wie folgt:
// 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 ;Sie können die Farbe des Sprite-Bildes auch wie folgt anpassen:
// 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 ;Zeichnen Sie abschließend das Sprite mit:
S2D_DrawSprite ( spr );Da Sprites dynamisch zugewiesen werden, geben Sie sie frei, indem Sie Folgendes verwenden:
S2D_FreeSprite ( spr ); Text wird ähnlich wie Bilder gezeichnet. Suchen Sie zunächst Ihre bevorzugte OpenType-Schriftart (mit der Dateierweiterung .ttf oder .otf ), deklarieren Sie dann einen Zeiger auf eine S2D_Text -Struktur und initialisieren Sie sie mit S2D_CreateText() unter Angabe des Dateipfads zur Schriftart, der anzuzeigenden Meldung und der Größe .
S2D_Text * txt = S2D_CreateText ( "vera.ttf" , "Hello world!" , 20 ); Wenn die Schriftartdatei nicht gefunden werden kann, wird NULL zurückgegeben.
Anschließend können Sie die x, y Position des Textes ändern, zum Beispiel:
txt -> x = 127 ;
txt -> y = 740 ;Drehen Sie den Text wie folgt:
// 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 ;Ändern Sie die Farbe des Textes wie folgt:
// 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 ;Zeichnen Sie abschließend den Text mit:
S2D_DrawText ( txt );Sie können die Textnachricht auch jederzeit ändern:
S2D_SetText ( txt , "A different message!" );
// Format text just like `printf`
S2D_SetText ( txt , "Welcome %s!" , player );Da Text dynamisch zugewiesen wird, geben Sie ihn frei, indem Sie Folgendes verwenden:
S2D_FreeText ( txt );Simple 2D unterstützt eine Reihe beliebter Audioformate, darunter WAV, MP3, Ogg Vorbis und FLAC. Es gibt zwei Arten von Audiokonzepten: Klänge und Musik. Sounds sollen kurze Samples sein, die wie ein Effekt ohne Unterbrechung abgespielt werden. Bei Musik handelt es sich um längere Stücke, die wie ein Hintergrundsoundtrack abgespielt, angehalten, gestoppt, fortgesetzt und ausgeblendet werden können.
Erstellen Sie einen Sound, indem Sie zunächst einen Zeiger auf eine S2D_Sound -Struktur deklarieren und ihn mit S2D_CreateSound() initialisieren, das den Pfad zur Audiodatei bereitstellt.
S2D_Sound * snd = S2D_CreateSound ( "sound.wav" ); Wenn die Audiodatei nicht gefunden werden kann, wird NULL zurückgegeben.
Spielen Sie den Sound so ab:
S2D_PlaySound ( snd );Sie können die Lautstärke eines Tons folgendermaßen ermitteln und einstellen:
int volume = S2D_GetSoundVolume ( snd );
S2D_SetSoundVolume ( snd , 50 ); // set volume 50%Rufen Sie außerdem die Lautstärke aller Töne ab und stellen Sie sie wie folgt ein, wobei die Lautstärke im Bereich zwischen 0 (am leisesten) und 100 (am lautesten) liegt:
int volume = S2D_GetSoundMixVolume ();
S2D_SetSoundMixVolume ( 50 ); // set volume 50%Da Sounds dynamisch zugewiesen werden, geben Sie sie frei, indem Sie Folgendes verwenden:
S2D_FreeSound ( snd ); Erstellen Sie auf ähnliche Weise Musik, indem Sie einen Zeiger auf eine S2D_Music -Struktur deklarieren und diese mit S2D_CreateMusic() initialisieren, das den Pfad zur Audiodatei bereitstellt.
S2D_Music * mus = S2D_CreateMusic ( "music.ogg" ); Wenn die Audiodatei nicht gefunden werden kann, wird NULL zurückgegeben.
Spielen Sie die Musik wie folgt ab, wobei der zweite Parameter ein boolescher Wert ist, der angibt, ob die Musik wiederholt werden soll:
S2D_PlayMusic ( mus , true); // play on a loopEs kann jeweils nur ein Musikstück abgespielt werden. Die folgenden Funktionen zum Anhalten, Fortsetzen, Abrufen und Einstellen der Lautstärke, Stoppen und Ausblenden gelten für die gerade abgespielte Musik:
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 );Da Musik dynamisch zugewiesen wird, geben Sie sie frei, indem Sie Folgendes verwenden:
S2D_FreeMusic ( mus );Simple 2D kann Eingaben von nahezu allem erfassen. Erfahren Sie, wie Sie Eingabeereignisse von Maus, Tastatur und Gamecontrollern abrufen.
Es gibt drei Arten von Tastaturereignissen, die vom Fenster erfasst werden: Wenn eine Taste gedrückt wird, wird eine Taste gedrückt gehalten und eine Taste wird losgelassen. Wenn ein Tastaturereignis stattfindet, ruft das Fenster seine Funktion on_key() auf.
Um Tastatureingaben zu erfassen, definieren Sie zunächst die Funktion on_key() und lesen Sie die Ereignisdetails aus der S2D_Event -Struktur, zum Beispiel:
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 ;
}
}Hängen Sie dann den Rückruf an das Fenster an:
window -> on_key = on_key ; Die Cursorposition der Maus oder des Trackpads kann jederzeit aus dem Fenster abgelesen werden. Beachten Sie, dass die obere linke Ecke der Ursprung ist, (0, 0) .
window -> mouse . x ;
window -> mouse . y ; Um Maustasteneingaben zu erfassen, definieren Sie zunächst die Funktion on_mouse() und lesen Sie die Ereignisdetails aus der S2D_Event Struktur, zum Beispiel:
// `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 ;
}
}Hängen Sie dann den Rückruf an das Fenster an:
window -> on_mouse = on_mouse ;Verstecken Sie den Cursor über dem Fenster (und zeigen Sie es wieder an), indem Sie Folgendes verwenden:
S2D_HideCursor ();
S2D_ShowCursor (); Alle Gamecontroller werden automatisch erkannt, hinzugefügt und entfernt. Es gibt zwei Arten von Ereignissen, die vom Fenster erfasst werden: Achsenbewegungen und Tastendrücke. Wenn eine Taste gedrückt oder ein Joystick bewegt wird, ruft das Fenster seine Funktion on_controller() auf. Tasten und Achsen sind einem generischen Xbox-Controller-Layout zugeordnet.
Um Controller-Eingaben zu erfassen, definieren Sie zunächst die Funktion on_controller() und lesen Sie die Ereignisdetails aus der S2D_Event -Struktur, zum Beispiel:
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 ;
}
}Hängen Sie dann den Rückruf an das Fenster an:
window -> on_controller = on_controller ; Ein ausführliches Beispiel für die Interaktion mit Gamecontrollern finden Sie im controller.c -Test.
Sie werden mit Sicherheit Controller finden, die noch keine Tastenbelegung haben, insbesondere wenn sie brandneu sind. Beispiele für die Generierung von Zuordnungszeichenfolgen finden Sie in der von der Community bereitgestellten Datenbank mit Controller-Zuordnungen. Sobald Sie die Zuordnungszeichenfolge haben, können Sie sie mit S2D_AddControllerMapping() registrieren oder mehrere Zuordnungen aus einer Datei hinzufügen, indem Sie S2D_AddControllerMappingsFromFile() verwenden und den Dateipfad angeben.
„Einfach kann schwieriger sein als komplex: Man muss hart arbeiten, um klar zu denken, dass es einfach ist. Aber am Ende lohnt es sich, denn wenn man erst einmal dort angekommen ist, kann man Berge versetzen.“ — Steve Jobs
Trotz der kontinuierlichen Fortschritte in der Computergrafik-Hardware und -Software ist der Einstieg in die einfache Grafikprogrammierung nicht so einfach oder zugänglich. Wir arbeiten daran, das zu ändern.
Wenn Ihnen das Projekt gefällt, denken Sie bitte über einen Beitrag nach! Sehen Sie sich die offenen Themen an, um Ideen zu erhalten, oder schlagen Sie Ihre eigenen vor. Wir sind immer auf der Suche nach Möglichkeiten, das Projekt einladender zu gestalten und das Entwicklererlebnis auf jeder Plattform zu verbessern. Machen Sie sich keine Sorgen, wenn Sie kein Experte für C oder Grafik-APIs sind – wir führen Sie gerne durch alles.
Wenn Sie ein Hardcore-C- und OS-Hacker sind , sollten Sie ernsthaft darüber nachdenken, einen Beitrag zu SDL zu leisten, damit wir weiterhin Spiele schreiben können, ohne uns um die darunter liegenden Plattformdetails kümmern zu müssen. Schauen Sie sich die Vorträge der Steam Dev Days an, insbesondere Ryan C. Gordons Vortrag über Spieleentwicklung mit SDL 2.0.
simple2d.shdeps -Repository vor (folgen Sie den Anweisungen in der README-Datei) und führen Sie in diesem Repository git submodule update --remote aus, um das Submodul zu aktualisierensimple2d.sh und simple2d.cmd und übernehmen Sie die Änderungenrelease make/nmake“.v#.#.# ; Hängen Sie Windows-Installationsprogramme und Apple-Bibliotheken an Versionshinweise ansha256 Prüfsummen für das Release- und Framework-Archiv mit shasum -a 256 <file>brew audit --strict ./simple2d.rb aus, um etwaige Probleme mit der Formel zu erkennenbrew install ./simple2d.rbSimple 2D wurde von Tom Black entwickelt, der einfache Grafikprogrammierung für viel zu schwierig hielt und beschloss, etwas dagegen zu unternehmen.
Alles ist MIT-lizenziert, also hacken Sie los.
Genießen!
