simple2d
v1.2.0
Simple 2D es un pequeño motor de gráficos de código abierto que proporciona capacidades esenciales de entrada, medios y dibujo 2D. Está escrito en C y funciona en muchas plataformas, creando ventanas nativas e interactuando con hardware usando SDL mientras renderiza contenido con OpenGL.
Tenga en cuenta que este archivo README se actualizará continuamente a medida que se agreguen nuevas funciones, se corrijan errores y se realicen otros cambios. Vea las notas de la versión para obtener un enlace a la documentación de esa versión.
Abra una incidencia en GitHub si encuentra algún problema, tiene una solicitud de función o simplemente desea hacer una pregunta. Obtenga más información sobre cómo contribuir a continuación.
Simple 2D es compatible con todos los principales sistemas operativos y plataformas de hardware, y se prueba en las últimas versiones de macOS, iOS, tvOS, Windows, Linux y Raspbian en Raspberry Pi.
Para instalar la última versión...
Utilice cerveza casera:
brew tap simple2d/tap
brew install simple2d La fórmula Homebrew anterior también instalará los marcos de iOS y tvOS en /usr/local/Frameworks/Simple2D de forma predeterminada. Después de la instalación, ejecute el comando simple2d simulator para ver las opciones disponibles para interactuar con los simuladores de iOS y tvOS. Ejecute simple2d build para aprender a crear proyectos Xcode con los SDK de iOS y tvOS. Se pueden encontrar proyectos de Xcode de ejemplo en el repositorio deps .
Descargue el instalador de Windows para Visual C++ o MinGW.
Para MinGW, recomendamos utilizar un entorno MSYS2 (también disponible en Chocolatey) junto con un símbolo del sistema MinGW de 64 bits (normalmente mingw64.exe ). Simple 2D también se puede instalar en MinGW siguiendo las instrucciones de Linux a continuación.
Ejecute el script Bash simple2d.sh . Todo se explicará a lo largo del camino y se le avisará antes de tomar cualquier medida. Para ejecutar el script desde la web, pegue este fragmento en su 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 admite plataformas ARM que ejecutan Linux, como Raspberry Pi. Dado que la mayoría de las distribuciones de Linux tienen paquetes SDL configurados para plataformas de escritorio tradicionales, el script de instalación compilará SDL desde el código fuente cuando se detecte ARM, deshabilitando los sistemas de ventanas (como X11) y OpenGL (forzando en su lugar OpenGL ES).
Una vez instalado, utilice la utilidad de línea de comandos simple2d para actualizar Simple 2D, buscar problemas, generar las bibliotecas necesarias para compilar aplicaciones y más. Simplemente ejecute simple2d para ver todos los comandos y opciones disponibles.
Alternativamente, puede compilar e instalar Simple 2D desde el código fuente. Primero clona este repositorio usando:
git clone --recursive https://github.com/simple2d/simple2d.git Para mantener pequeño el tamaño de este repositorio, se utilizan submódulos de Git para hacer referencia a los medios de prueba y las dependencias. El indicador --recursive garantiza que los submódulos se inicialicen y actualicen cuando se clona este repositorio. Si clonaste este repositorio sin el indicador --recursive , aún puedes inicializar y actualizar los submódulos con:
git submodule init
git submodule update --remote Actualice estos submódulos en cualquier momento usando git submodule update --remote
A continuación, cree e instale en sistemas tipo Unix, incluido Windows, utilizando MinGW, ejecutando:
make && make installEn Windows que utiliza Visual C++, abra un símbolo del sistema de Visual Studio de 64 bits y ejecute:
nmake /f NMakefile all install Tenga en cuenta que en macOS y Linux, el archivo MAKE no buscará ni instalará dependencias, a diferencia de la instalación mediante Homebrew o el script simple2d.sh , respectivamente. Las dependencias para Windows, que admiten Visual C++ y MinGW, se incluyen en este repositorio (al que se hace referencia en el submódulo deps ) y se instalan mediante ambos archivos MAKE.
En Windows que usa Visual C++, Simple 2D se instalará en %LOCALAPPDATA%simple2d , así que asegúrese de agregarlo a su ruta (por ejemplo, con set PATH=%PATH%;%LOCALAPPDATA%simple2d ). En todos los demás casos, se instalará en /usr/local/ . En Windows que usa MinGW, asegúrese de que /usr/local/bin también esté en su ruta.
Para crear los archivos de lanzamiento, que se adjuntan como descargas con cada lanzamiento, ejecute make release en macOS y Windows usando MinGW, y nmake /f NMakefile release en Windows usando Visual C++.
Simple 2D tiene varios programas de prueba para asegurarse de que todo funciona como debería.
auto.c : un conjunto de pruebas unitarias automatizadas para la interfaz pública.triangle.c : el ejemplo "Hola Triángulo" en este archivo README.testcard.c : una tarjeta gráfica, similar a las tarjetas de prueba de TV, cuyo objetivo es garantizar que las imágenes y las entradas funcionen correctamente.audio.c : prueba funciones de audio con varios formatos de archivo interpretados como muestras de sonido y música.controller.c : proporciona información visual y numérica de la entrada del controlador del juego.triangle-ios-tvos.c : un triangle.c modificado diseñado para dispositivos iOS y tvOS. Ejecute make test o nmake /f NMakefile test en Windows usando Visual C++ para compilar pruebas en el directorio test/ . Los ejecutables resultantes tendrán el mismo nombre que sus archivos fuente C. Dado que las rutas de medios se configuran relativamente en estos programas de prueba, asegúrese de cd al directorio test/ antes de ejecutar una prueba, por ejemplo:
# 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 Cada prueba también tiene un destino de archivo MAKE, por lo que puede crear y ejecutar pruebas utilizando, por ejemplo, make test testcard . O bien, desinstale todo convenientemente, reconstruya Simple 2D y las pruebas desde el código fuente, y ejecute pruebas usando make rebuild <name_of_test> , por ejemplo:
# 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 Para ejecutar las pruebas de iOS y tvOS, primero ejecute make frameworks && make install-frameworks para compilar e instalar los frameworks de iOS y tvOS. A continuación, ejecute make ios para ejecutar la prueba en un simulador de iOS y make tvos para ejecutar en un simulador de tvOS.
¡Hacer aplicaciones 2D es simple! Creemos una ventana y dibujemos un triángulo...
#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 ;
} Guarde el código anterior en un archivo llamado triangle.c y compílelo ejecutando simple2d build triangle.c en la línea de comando (en MinGW, ejecútelo en un indicador de Bash). Ahora ejecuta la aplicación usando ./triangle en macOS y Linux, o triangle.exe en Windows, ¡y disfruta de tu impresionante triángulo en una ventana de 640x480 a 60 fotogramas por segundo!
El comando simple2d build es un atajo útil para compilar un único archivo fuente. Por supuesto, también puedes utilizar un compilador directamente, por ejemplo en sistemas tipo Unix:
cc triangle.c ` simple2d --libs ` -o triangleY en Windows usando Visual C++ en un símbolo del sistema para desarrolladores:
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 ) " Aprendamos sobre aplicaciones de estructuración para dibujo 2D y más.
Todo el contenido, la entrada y el sonido renderizados están controlados por la ventana, por lo que lo primero que debe hacer es crear una ventana. Comience declarando un puntero a una estructura S2D_Window e inicialícelo usando 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
); Para establecer el ancho y alto de la ventana igual que el de la pantalla, use S2D_DISPLAY_WIDTH y S2D_DISPLAY_HEIGHT para esos valores, respectivamente.
Los indicadores de la ventana pueden ser 0 o cualquiera de los siguientes:
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 Los indicadores también se pueden combinar usando el operador OR bit a bit, por ejemplo: S2D_RESIZABLE | S2D_BORDERLESS
El tamaño de la ventana gráfica, el área donde se dibujan los gráficos en la ventana, se puede configurar independientemente del tamaño de la ventana de la siguiente manera:
window -> viewport . width = 400 ;
window -> viewport . height = 300 ; La ventana gráfica tiene varios modos de escala, como S2D_FIXED (la ventana gráfica permanece del mismo tamaño a medida que cambia el tamaño de la ventana), S2D_EXPAND (la ventana gráfica se expande para llenar la ventana cuando se cambia su tamaño), S2D_SCALE (el valor predeterminado, donde la ventana gráfica se escala proporcionalmente y está centrada en el ventana), o S2D_STRETCH (la ventana gráfica se extiende para llenar toda la ventana). Configure el modo así:
window -> viewport . mode = S2D_FIXED ;Antes de mostrar la ventana, se pueden configurar estos atributos:
window -> vsync = false; // set the vertical sync, true by default
window -> icon = "app.png" ; // set the icon for the windowUna vez que su ventana esté lista, muéstrela usando:
S2D_Show ( window );En cualquier momento antes o durante la visualización de la ventana, se pueden configurar estos atributos:
// 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 ; Las funciones de devolución de llamada también se pueden cambiar en cualquier momento; más sobre esto a continuación. Se pueden leer muchos valores desde la estructura S2D_Window ; consulte el archivo de encabezado simple2d.h para obtener más detalles.
El icono de la ventana se puede cambiar usando:
S2D_SetIcon ( window , "new_icon.png" );Tome una captura de pantalla de la ventana en formato PNG, proporcionando una ruta de archivo:
S2D_Screenshot ( window , "./screenshot.png" );Cuando hayas terminado con la ventana, libérala usando:
S2D_FreeWindow ( window ); El bucle de la ventana es donde tiene lugar toda la acción: se establece la velocidad de cuadros, se maneja la entrada, se actualiza el estado de la aplicación y se representan las imágenes. Querrá declarar dos funciones esenciales que serán llamadas por el bucle de la ventana: update() y render() . Al igual que un bucle de juego tradicional, update() se usa para actualizar el estado de la aplicación y render() se usa para dibujar la escena. Simple 2D optimiza ambas funciones en términos de rendimiento y precisión, por lo que es una buena práctica mantener separadas las tareas de actualización y renderizado.
Las funciones de actualización y renderizado deberían verse así:
void update () { /* update your application state */ }
void render () { /* draw stuff */ } Recuerde agregar estos nombres de funciones cuando llame S2D_CreateWindow() (consulte la sección "La ventana" arriba para ver un ejemplo).
Para salir del bucle de la ventana en cualquier momento, utilice:
S2D_Close ( window );En la ventana se pueden dibujar todo tipo de formas y texturas. Conozca cada uno de ellos a continuación.
Hay varias formas geométricas disponibles, como triángulos, cuadriláteros (de los que se pueden formar rectángulos y cuadrados), líneas y círculos. Cada forma contiene vértices, es decir, lugares donde dos líneas se unen para formar un ángulo (un triángulo tiene tres, por ejemplo). Para cada vértice de un triángulo y cuadrilátero, hay seis valores que deben establecerse: las coordenadas x , y cuatro valores y color. Las líneas tienen dos vértices, aunque se pueden establecer colores para cada esquina. Los círculos tienen un único punto central y un color que se puede configurar. Cuando los vértices tienen diferentes valores de color, el espacio entre ellos se mezcla en un degradado.
La abreviatura de los ejemplos siguientes es:
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 ) Usando esta notación, x2 sería la segunda coordenada x y b2 sería el valor azul en ese vértice.
Para dibujar un triángulo, use:
S2D_DrawTriangle ( x1 , y1 , r1 , g1 , b1 , a1 ,
x2 , y2 , r2 , g2 , b2 , a2 ,
x3 , y3 , r3 , g3 , b3 , a3 );Para dibujar un cuadrilátero, use:
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 );Para dibujar una línea, use:
S2D_DrawLine ( x1 , y1 , x2 , y2 ,
width ,
r1 , g1 , b1 , a1 ,
r2 , g2 , b2 , a2 ,
r3 , g3 , b3 , a3 ,
r4 , g4 , b4 , a4 );Para dibujar un círculo, use:
S2D_DrawCircle ( x , y , radius , sectors , r , g , b , a ); En la ventana se pueden dibujar imágenes en muchos formatos populares, como JPEG, PNG y BMP. A diferencia de las formas, las imágenes deben leerse desde archivos y almacenarse en la memoria. Simplemente declare un puntero a una estructura S2D_Image e inicialícelo usando S2D_CreateImage() proporcionando la ruta del archivo a la imagen.
S2D_Image * img = S2D_CreateImage ( "image.png" ); Si no se puede encontrar la imagen, devolverá NULL .
Una vez que tengas tu imagen, puedes cambiar su posición x, y así:
img -> x = 125 ;
img -> y = 350 ;Cambie el tamaño de la imagen ajustando su ancho y alto:
img -> width = 256 ;
img -> height = 512 ;Gira la imagen así:
// 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 ;También puedes ajustar el color de la imagen de esta manera:
// 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 ;Finalmente, dibuja la imagen usando:
S2D_DrawImage ( img );Dado que las imágenes se asignan dinámicamente, libérelas usando:
S2D_FreeImage ( img ); Los sprites son tipos especiales de imágenes que se pueden utilizar para crear animaciones. Para crear un sprite, declare un puntero a una estructura S2D_Sprite e inicialícelo usando S2D_CreateSprite() proporcionando la ruta del archivo a la imagen de la hoja de sprites.
S2D_Sprite * spr = S2D_CreateSprite ( "sprite_sheet.png" ); Si no se puede encontrar la imagen del sprite, devolverá NULL .
Recorte la hoja de sprites en una sola imagen proporcionando un rectángulo de recorte:
S2D_ClipSprite ( spr , x , y , width , height ); La posición x, y del propio sprite se puede cambiar así:
spr -> x = 150 ;
spr -> y = 275 ;Cambia el tamaño del sprite ajustando su ancho y alto:
spr -> width = 100 ;
spr -> height = 100 ;Gira el objeto así:
// 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 ;También puedes ajustar el color de la imagen del sprite de esta manera:
// 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 ;Finalmente, dibuja el sprite usando:
S2D_DrawSprite ( spr );Dado que los sprites se asignan dinámicamente, libéralos usando:
S2D_FreeSprite ( spr ); El texto se dibuja de forma muy parecida a las imágenes. Comience buscando su fuente OpenType favorita (con una extensión de archivo .ttf o .otf ), luego declare un puntero a una estructura S2D_Text e inicialícela usando S2D_CreateText() proporcionando la ruta del archivo a la fuente, el mensaje a mostrar y el tamaño. .
S2D_Text * txt = S2D_CreateText ( "vera.ttf" , "Hello world!" , 20 ); Si no se puede encontrar el archivo de fuente, devolverá NULL .
Luego puedes cambiar la posición x, y del texto, por ejemplo:
txt -> x = 127 ;
txt -> y = 740 ;Gire el texto así:
// 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 ;Cambia el color del texto así:
// 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 ;Finalmente, dibuja el texto usando:
S2D_DrawText ( txt );También puedes cambiar el mensaje de texto en cualquier momento:
S2D_SetText ( txt , "A different message!" );
// Format text just like `printf`
S2D_SetText ( txt , "Welcome %s!" , player );Dado que el texto se asigna dinámicamente, libérelos usando:
S2D_FreeText ( txt );Simple 2D admite varios formatos de audio populares, incluidos WAV, MP3, Ogg Vorbis y FLAC. Hay dos tipos de conceptos de audio: sonidos y música. Los sonidos están pensados para ser muestras cortas, reproducidas sin interrupción, como un efecto. La música es para piezas más largas que se pueden reproducir, pausar, detener, reanudar y atenuar, como una banda sonora de fondo.
Cree un sonido declarando primero un puntero a una estructura S2D_Sound e inicialícelo usando S2D_CreateSound() proporcionando la ruta al archivo de audio.
S2D_Sound * snd = S2D_CreateSound ( "sound.wav" ); Si no se puede encontrar el archivo de audio, devolverá NULL .
Reproduce el sonido así:
S2D_PlaySound ( snd );Puede obtener y configurar el volumen de un sonido de esta manera:
int volume = S2D_GetSoundVolume ( snd );
S2D_SetSoundVolume ( snd , 50 ); // set volume 50%Además, obtenga y configure el volumen de todos los sonidos de esta manera, donde el volumen está en un rango entre 0 (el más suave) y 100 (el más alto):
int volume = S2D_GetSoundMixVolume ();
S2D_SetSoundMixVolume ( 50 ); // set volume 50%Dado que los sonidos se asignan dinámicamente, libérelos usando:
S2D_FreeSound ( snd ); De manera similar, cree algo de música declarando un puntero a una estructura S2D_Music e inicialícela usando S2D_CreateMusic() proporcionando la ruta al archivo de audio.
S2D_Music * mus = S2D_CreateMusic ( "music.ogg" ); Si no se puede encontrar el archivo de audio, devolverá NULL .
Reproduzca la música de esta manera, donde el segundo parámetro es un valor booleano que indica si la música debe repetirse:
S2D_PlayMusic ( mus , true); // play on a loopSólo se puede reproducir una pieza musical a la vez. Las siguientes funciones para pausar, reanudar, subir y configurar el volumen, detener y atenuar se aplican a cualquier música que se esté reproduciendo actualmente:
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 );Dado que la música se asigna dinámicamente, libérela usando:
S2D_FreeMusic ( mus );El 2D simple puede capturar información de casi cualquier cosa. Aprendamos a capturar eventos de entrada desde el mouse, el teclado y los controladores de juegos.
Hay tres tipos de eventos de teclado capturados por la ventana: cuando se presiona una tecla, se mantiene presionada una tecla y se suelta una tecla. Cuando se produce un evento de teclado, la ventana llama a su función on_key() .
Para capturar la entrada del teclado, primero defina la función on_key() y lea los detalles del evento de la estructura S2D_Event , por ejemplo:
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 ;
}
}Luego, adjunte la devolución de llamada a la ventana:
window -> on_key = on_key ; La posición del cursor del mouse o trackpad se puede leer en cualquier momento desde la ventana. Tenga en cuenta que la esquina superior izquierda es el origen, (0, 0) .
window -> mouse . x ;
window -> mouse . y ; Para capturar la entrada del botón del mouse, primero defina la función on_mouse() y lea los detalles del evento de la estructura S2D_Event , por ejemplo:
// `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 ;
}
}Luego, adjunte la devolución de llamada a la ventana:
window -> on_mouse = on_mouse ;Oculte el cursor sobre la ventana (y muéstrelo nuevamente) usando:
S2D_HideCursor ();
S2D_ShowCursor (); Todos los dispositivos de juego se detectan, agregan y eliminan automáticamente. Hay dos tipos de eventos capturados por la ventana: movimiento del eje y pulsaciones de botones. Cuando se presiona un botón o se mueve un joystick, la ventana llama a su función on_controller() . Los botones y ejes están asignados a un diseño genérico de controlador Xbox.
Para capturar la entrada del controlador, primero defina la función on_controller() y lea los detalles del evento de la estructura S2D_Event , por ejemplo:
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 ;
}
}Luego, adjunte la devolución de llamada a la ventana:
window -> on_controller = on_controller ; Consulte la prueba controller.c para ver un ejemplo exhaustivo de cómo interactuar con los controladores de juegos.
Seguramente encontrará controladores que aún no tienen asignaciones de botones, especialmente si son nuevos. Consulte la base de datos de asignaciones de controladores de origen comunitario para obtener ejemplos de cómo generar cadenas de asignación. Una vez que tenga la cadena de asignación, puede registrarla usando S2D_AddControllerMapping() o agregar varias asignaciones desde un archivo usando S2D_AddControllerMappingsFromFile() y proporcionando la ruta del archivo.
"Lo simple puede ser más difícil que lo complejo: tienes que trabajar duro para aclarar tu pensamiento y hacerlo simple. Pero al final vale la pena porque una vez que llegas allí, puedes mover montañas". —Steve Jobs
A pesar de los continuos avances en hardware y software de gráficos por computadora, comenzar con la programación de gráficos simple no es tan fácil ni accesible. Estamos trabajando para cambiar eso.
Si te gusta el proyecto, ¡considera contribuir! Consulte los números abiertos para obtener ideas o sugiera las suyas propias. Siempre estamos buscando formas de hacer que el proyecto sea más atractivo y mejorar la experiencia del desarrollador en cada plataforma. No se preocupe si no es un experto en C o API de gráficos: estaremos encantados de explicarle todo.
Si eres un hacker incondicional de C y OS, deberías considerar seriamente contribuir a SDL para que podamos continuar escribiendo juegos sin preocuparte por los detalles de la plataforma que se encuentran debajo. Eche un vistazo a las charlas de Steam Dev Days, especialmente la charla de Ryan C. Gordon sobre desarrollo de juegos con SDL 2.0.
simple2d.shdeps (siga las instrucciones en el archivo README) y ejecute git submodule update --remote en este repositorio para actualizar el submódulo.simple2d.sh y simple2d.cmd , confirme los cambiosrelease make/nmake targetv#.#.# ; adjunte instaladores de Windows y bibliotecas de Apple a las notas de la versiónsha256 para el archivo de lanzamiento y marcos, usando shasum -a 256 <file>brew audit --strict ./simple2d.rb para detectar cualquier problema con la fórmula.brew install ./simple2d.rbSimple 2D fue creado por Tom Black, quien pensó que la programación de gráficos simples era demasiado difícil y decidió hacer algo al respecto.
Todo tiene licencia del MIT, así que hazlo.
¡Disfrutar!
