simple2d
v1.2.0
Simple 2D é um mecanismo gráfico pequeno e de código aberto que fornece recursos essenciais de desenho, mídia e entrada 2D. Ele foi escrito em C e funciona em diversas plataformas, criando janelas nativas e interagindo com hardware usando SDL enquanto renderiza conteúdo com OpenGL.
Observe que este README será atualizado continuamente à medida que novos recursos são adicionados, bugs são corrigidos e outras alterações são feitas. Veja as notas de lançamento para obter um link para a documentação dessa versão.
Abra um problema no GitHub se encontrar algum problema, tiver uma solicitação de recurso ou simplesmente quiser fazer uma pergunta. Saiba mais sobre como contribuir abaixo.
Simple 2D suporta todos os principais sistemas operacionais e plataformas de hardware e é testado nas versões mais recentes do macOS, iOS, tvOS, Windows, Linux e Raspbian no Raspberry Pi.
Para instalar a versão mais recente...
Utilize o Homebrew:
brew tap simple2d/tap
brew install simple2d A fórmula Homebrew acima também instalará os frameworks iOS e tvOS em /usr/local/Frameworks/Simple2D por padrão. Após a instalação, execute o comando simple2d simulator para ver as opções disponíveis para interagir com os simuladores iOS e tvOS. Execute simple2d build para aprender como criar projetos Xcode com os SDKs iOS e tvOS. Exemplos de projetos Xcode podem ser encontrados no repositório deps .
Baixe o instalador do Windows para Visual C++ ou MinGW.
Para MinGW, recomendamos usar um ambiente MSYS2 (também disponível no Chocolatey) junto com um prompt de comando MinGW de 64 bits (geralmente mingw64.exe ). O Simple 2D também pode ser instalado no MinGW usando as instruções do Linux abaixo.
Execute o script Bash simple2d.sh . Tudo será explicado ao longo do caminho e você será avisado antes de qualquer ação ser tomada. Para executar o script da web, cole este trecho em seu 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 suporta plataformas ARM rodando Linux, como o Raspberry Pi. Como a maioria das distribuições Linux tem pacotes SDL configurados para plataformas de desktop tradicionais, o script de instalação compilará o SDL a partir do código-fonte quando o ARM for detectado, desativando sistemas de janelas (como X11) e OpenGL (forçando o OpenGL ES).
Depois de instalado, use o utilitário de linha de comando simple2d para atualizar o Simple 2D, verificar problemas, gerar as bibliotecas necessárias para compilar aplicativos e muito mais. Basta executar simple2d para ver todos os comandos e opções disponíveis.
Alternativamente, você pode compilar e instalar o Simple 2D a partir do código-fonte. Primeiro clone este repositório usando:
git clone --recursive https://github.com/simple2d/simple2d.git Para manter o tamanho deste repositório pequeno, os submódulos Git são usados para referenciar mídia de teste e dependências. O sinalizador --recursive garante que os submódulos sejam inicializados e atualizados quando este repositório for clonado. Se você clonou este repositório sem o sinalizador --recursive , ainda poderá inicializar e atualizar submódulos com:
git submodule init
git submodule update --remote Atualize esses submódulos a qualquer momento usando git submodule update --remote
Em seguida, crie e instale em sistemas do tipo Unix, incluindo Windows usando MinGW, executando:
make && make installNo Windows usando Visual C++, abra um prompt de comando do Visual Studio de 64 bits e execute:
nmake /f NMakefile all install Observe que no macOS e no Linux, o makefile não verificará ou instalará dependências, ao contrário da instalação via Homebrew ou do script simple2d.sh , respectivamente. Dependências para Windows, com suporte para Visual C++ e MinGW, estão incluídas neste repositório (referenciadas pelo submódulo deps ) e instaladas por ambos os makefiles.
No Windows usando Visual C++, o Simple 2D será instalado em %LOCALAPPDATA%simple2d , portanto, adicione-o ao seu caminho (por exemplo, com set PATH=%PATH%;%LOCALAPPDATA%simple2d ). Em todos os outros casos, ele será instalado em /usr/local/ . No Windows usando MinGW, certifique-se de que /usr/local/bin também esteja no seu caminho.
Para criar os arquivos de lançamento, que são anexados como downloads em cada versão, execute make release no macOS e Windows usando MinGW e nmake /f NMakefile release no Windows usando Visual C++.
Simple 2D possui vários programas de teste para garantir que tudo está funcionando como deveria.
auto.c — Um conjunto de testes de unidade automatizados para a interface pública.triangle.c — O exemplo "Hello Triangle" neste README.testcard.c — Uma placa gráfica, semelhante às placas de teste de TV, com o objetivo de garantir que os recursos visuais e as entradas estejam funcionando corretamente.audio.c — Testa funções de áudio com vários formatos de arquivo interpretados como amostras de som e música.controller.c — Fornece feedback visual e numérico da entrada do controlador de jogo.triangle-ios-tvos.c — Um triangle.c modificado projetado para dispositivos iOS e tvOS. Execute make test ou nmake /f NMakefile test no Windows usando Visual C++, para compilar testes no diretório test/ . Os executáveis resultantes terão o mesmo nome dos arquivos de origem C. Como os caminhos de mídia são definidos relativamente nesses programas de teste, certifique-se de inserir cd no diretório test/ antes de executar um teste, por exemplo:
# 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 teste também possui um alvo makefile, para que você possa construir e executar testes usando, por exemplo, make test testcard . Ou desinstale tudo convenientemente, reconstrua o Simple 2D e os testes a partir do código-fonte e execute os testes usando make rebuild <name_of_test> , por exemplo:
# 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 executar os testes de iOS e tvOS, primeiro execute make frameworks && make install-frameworks para construir e instalar as estruturas iOS e tvOS. Em seguida, execute make ios para executar o teste em um simulador iOS e make tvos para executar em um simulador tvOS.
Criar aplicativos 2D é simples! Vamos criar uma janela e desenhar um 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 ;
} Salve o código acima em um arquivo chamado triangle.c e compile-o executando simple2d build triangle.c na linha de comando (no MinGW, execute-o em um prompt do Bash). Agora execute o aplicativo usando ./triangle no macOS e Linux, ou triangle.exe no Windows e aproveite seu impressionante triângulo em uma janela de 640x480 a 60 quadros por segundo!
O comando simple2d build é um atalho útil para compilar um único arquivo fonte. Claro, você também pode usar um compilador diretamente, por exemplo, em sistemas do tipo Unix:
cc triangle.c ` simple2d --libs ` -o triangleE no Windows usando Visual C++ em um prompt de comando do desenvolvedor:
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 ) " Vamos aprender como estruturar aplicativos para desenho 2D e muito mais.
Todo o conteúdo renderizado, entrada e som são controlados pela janela, portanto, criar uma janela é a primeira coisa que você fará. Comece declarando um ponteiro para uma estrutura S2D_Window e inicialize-a 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 definir a largura e a altura da janela iguais às da exibição, use S2D_DISPLAY_WIDTH e S2D_DISPLAY_HEIGHT para esses valores, respectivamente.
Os sinalizadores de janela podem ser 0 ou qualquer um dos seguintes:
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 Os sinalizadores também podem ser combinados usando o operador OR bit a bit, por exemplo: S2D_RESIZABLE | S2D_BORDERLESS
O tamanho da janela de visualização, a área onde os gráficos são desenhados na janela, pode ser definido independentemente do tamanho da janela, da seguinte forma:
window -> viewport . width = 400 ;
window -> viewport . height = 300 ; A viewport tem vários modos de escala, como S2D_FIXED (a viewport permanece do mesmo tamanho conforme o tamanho da janela muda), S2D_EXPAND (a viewport se expande para preencher a janela quando redimensionada), S2D_SCALE (o padrão, onde a viewport é dimensionada proporcionalmente e é centralizada no janela) ou S2D_STRETCH (a viewport se estende para preencher a janela inteira). Defina o modo assim:
window -> viewport . mode = S2D_FIXED ;Antes de mostrar a janela, estes atributos podem ser definidos:
window -> vsync = false; // set the vertical sync, true by default
window -> icon = "app.png" ; // set the icon for the windowQuando sua janela estiver pronta, mostre-a usando:
S2D_Show ( window );A qualquer momento antes ou durante a exibição da janela, estes atributos podem ser definidos:
// 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 ; As funções de retorno de chamada também podem ser alteradas a qualquer momento – mais sobre isso abaixo. Muitos valores podem ser lidos na estrutura S2D_Window , consulte o arquivo de cabeçalho simple2d.h para obter detalhes.
O ícone da janela pode ser alterado usando:
S2D_SetIcon ( window , "new_icon.png" );Faça uma captura de tela da janela em formato PNG, fornecendo um caminho de arquivo:
S2D_Screenshot ( window , "./screenshot.png" );Quando terminar a janela, libere-a usando:
S2D_FreeWindow ( window ); O loop da janela é onde toda a ação ocorre: a taxa de quadros é definida, a entrada é tratada, o estado do aplicativo é atualizado e os recursos visuais são renderizados. Você desejará declarar duas funções essenciais que serão chamadas pelo loop da janela: update() e render() . Como um loop de jogo tradicional, update() é usado para atualizar o estado do aplicativo e render() é usado para desenhar a cena. O 2D simples otimiza ambas as funções para desempenho e precisão, por isso é uma boa prática manter as tarefas de atualização e renderização separadas.
As funções de atualização e renderização devem ficar assim:
void update () { /* update your application state */ }
void render () { /* draw stuff */ } Lembre-se de adicionar esses nomes de função ao chamar S2D_CreateWindow() (veja a seção "A janela" acima para ver um exemplo).
Para sair do loop da janela a qualquer momento, use:
S2D_Close ( window );Todos os tipos de formas e texturas podem ser desenhados na janela. Conheça cada um deles abaixo.
Várias formas geométricas estão disponíveis, como triângulos, quadriláteros (dos quais retângulos e quadrados podem ser feitos), linhas e círculos. Cada forma contém vértices, ou seja, locais onde duas linhas se encontram para formar um ângulo (um triângulo tem três, por exemplo). Para cada vértice de um triângulo e quadrilátero, existem seis valores que precisam ser definidos: as coordenadas x e quatro valores y cores. As linhas têm dois vértices, embora possam ser definidas cores para cada canto. Os círculos têm um único ponto central e uma cor que pode ser definida. Quando os vértices têm valores de cores diferentes, o espaço entre eles é mesclado em um gradiente.
A abreviação dos exemplos abaixo é:
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 notação, x2 seria a segunda coordenada x e b2 seria o valor azul naquele vértice.
Para desenhar um triângulo, use:
S2D_DrawTriangle ( x1 , y1 , r1 , g1 , b1 , a1 ,
x2 , y2 , r2 , g2 , b2 , a2 ,
x3 , y3 , r3 , g3 , b3 , a3 );Para desenhar um quadrilá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 desenhar uma linha, 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 desenhar um círculo, use:
S2D_DrawCircle ( x , y , radius , sectors , r , g , b , a ); Imagens em muitos formatos populares, como JPEG, PNG e BMP podem ser desenhadas na janela. Ao contrário das formas, as imagens precisam ser lidas de arquivos e armazenadas na memória. Simplesmente declare um ponteiro para uma estrutura S2D_Image e inicialize-a usando S2D_CreateImage() fornecendo o caminho do arquivo para a imagem.
S2D_Image * img = S2D_CreateImage ( "image.png" ); Se a imagem não for encontrada, ela retornará NULL .
Depois de ter sua imagem, você pode alterar sua posição x, y da seguinte forma:
img -> x = 125 ;
img -> y = 350 ;Altere o tamanho da imagem ajustando sua largura e altura:
img -> width = 256 ;
img -> height = 512 ;Gire a imagem assim:
// 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 ;Você também pode ajustar a cor da imagem assim:
// 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, desenhe a imagem usando:
S2D_DrawImage ( img );Como as imagens são alocadas dinamicamente, libere-as usando:
S2D_FreeImage ( img ); Sprites são tipos especiais de imagens que podem ser usadas para criar animações. Para criar um sprite, declare um ponteiro para uma estrutura S2D_Sprite e inicialize-a usando S2D_CreateSprite() fornecendo o caminho do arquivo para a imagem da planilha sprite.
S2D_Sprite * spr = S2D_CreateSprite ( "sprite_sheet.png" ); Se a imagem do sprite não puder ser encontrada, ela retornará NULL .
Recorte a planilha sprite em uma única imagem fornecendo um retângulo de recorte:
S2D_ClipSprite ( spr , x , y , width , height ); A posição x, y do próprio sprite pode ser alterada assim:
spr -> x = 150 ;
spr -> y = 275 ;Altere o tamanho do sprite ajustando sua largura e altura:
spr -> width = 100 ;
spr -> height = 100 ;Gire o sprite assim:
// 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 ;Você também pode ajustar a cor da imagem do sprite assim:
// 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, desenhe o sprite usando:
S2D_DrawSprite ( spr );Como os sprites são alocados dinamicamente, libere-os usando:
S2D_FreeSprite ( spr ); O texto é desenhado como imagens. Comece encontrando sua fonte OpenType favorita (com extensão de arquivo .ttf ou .otf ), em seguida, declare um ponteiro para uma estrutura S2D_Text e inicialize-a usando S2D_CreateText() fornecendo o caminho do arquivo para a fonte, a mensagem a ser exibida e o tamanho .
S2D_Text * txt = S2D_CreateText ( "vera.ttf" , "Hello world!" , 20 ); Se o arquivo da fonte não for encontrado, ele retornará NULL .
Você pode então alterar a posição x, y do texto, por exemplo:
txt -> x = 127 ;
txt -> y = 740 ;Gire o texto assim:
// 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 ;Mude a cor do texto assim:
// 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 ;Por fim, desenhe o texto usando:
S2D_DrawText ( txt );Você também pode alterar a mensagem de texto a qualquer momento:
S2D_SetText ( txt , "A different message!" );
// Format text just like `printf`
S2D_SetText ( txt , "Welcome %s!" , player );Como o texto é alocado dinamicamente, libere-os usando:
S2D_FreeText ( txt );Simple 2D suporta vários formatos de áudio populares, incluindo WAV, MP3, Ogg Vorbis e FLAC. Existem dois tipos de conceitos de áudio: sons e música. Os sons pretendem ser amostras curtas, tocadas sem interrupção, como um efeito. A música é para peças mais longas que podem ser reproduzidas, pausadas, interrompidas, retomadas e desvanecidas, como uma trilha sonora de fundo.
Crie um som declarando primeiro um ponteiro para uma estrutura S2D_Sound e inicialize-o usando S2D_CreateSound() fornecendo o caminho para o arquivo de áudio.
S2D_Sound * snd = S2D_CreateSound ( "sound.wav" ); Se o arquivo de áudio não for encontrado, ele retornará NULL .
Toque o som assim:
S2D_PlaySound ( snd );Você pode obter e definir o volume de um som assim:
int volume = S2D_GetSoundVolume ( snd );
S2D_SetSoundVolume ( snd , 50 ); // set volume 50%Além disso, obtenha e defina o volume de todos os sons assim, onde o volume varia entre 0 (mais baixo) e 100 (mais alto):
int volume = S2D_GetSoundMixVolume ();
S2D_SetSoundMixVolume ( 50 ); // set volume 50%Como os sons são alocados dinamicamente, libere-os usando:
S2D_FreeSound ( snd ); Da mesma forma, crie alguma música declarando um ponteiro para uma estrutura S2D_Music e inicialize-a usando S2D_CreateMusic() fornecendo o caminho para o arquivo de áudio.
S2D_Music * mus = S2D_CreateMusic ( "music.ogg" ); Se o arquivo de áudio não for encontrado, ele retornará NULL .
Toque a música assim, onde o segundo parâmetro é um valor booleano que indica se a música deve ser repetida:
S2D_PlayMusic ( mus , true); // play on a loopApenas uma peça musical pode ser tocada por vez. As seguintes funções para pausar, retomar, obter e definir o volume, parar e diminuir gradualmente se aplicam a qualquer música que esteja tocando no momento:
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 );Como as músicas são alocadas dinamicamente, libere-as usando:
S2D_FreeMusic ( mus );O 2D simples pode capturar informações de praticamente qualquer coisa. Vamos aprender como capturar eventos de entrada do mouse, teclado e controladores de jogo.
Existem três tipos de eventos de teclado capturados pela janela: quando uma tecla é pressionada, uma tecla é pressionada e uma tecla é liberada. Quando ocorre um evento de teclado, a janela chama sua função on_key() .
Para capturar a entrada do teclado, primeiro defina a função on_key() e leia os detalhes do evento na estrutura S2D_Event , por exemplo:
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 ;
}
}Em seguida, anexe o retorno de chamada à janela:
window -> on_key = on_key ; A posição do cursor do mouse ou trackpad pode ser lida a qualquer momento na janela. Observe que o canto superior esquerdo é a origem, (0, 0) .
window -> mouse . x ;
window -> mouse . y ; Para capturar a entrada do botão do mouse, primeiro defina a função on_mouse() e leia os detalhes do evento na estrutura S2D_Event , por exemplo:
// `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 ;
}
}Em seguida, anexe o retorno de chamada à janela:
window -> on_mouse = on_mouse ;Oculte o cursor sobre a janela (e mostre-o novamente) usando:
S2D_HideCursor ();
S2D_ShowCursor (); Todos os controladores de jogo são detectados, adicionados e removidos automaticamente. Existem dois tipos de eventos capturados pela janela: movimento do eixo e pressionamento de botão. Quando um botão é pressionado ou um joystick é movido, a janela chama sua função on_controller() . Botões e eixos são mapeados para um layout genérico de controlador do Xbox.
Para capturar a entrada do controlador, primeiro defina a função on_controller() e leia os detalhes do evento na estrutura S2D_Event , por exemplo:
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 ;
}
}Em seguida, anexe o retorno de chamada à janela:
window -> on_controller = on_controller ; Consulte o teste controller.c para obter um exemplo completo de como interagir com controladores de jogo.
Você certamente encontrará controladores que ainda não possuem mapeamentos de botões, especialmente se forem novos. Consulte o banco de dados de mapeamentos de controladores de origem comunitária para obter exemplos de como gerar cadeias de mapeamento. Depois de ter a string de mapeamento, você pode registrá-la usando S2D_AddControllerMapping() ou adicionar vários mapeamentos de um arquivo usando S2D_AddControllerMappingsFromFile() e fornecendo o caminho do arquivo.
"O simples pode ser mais difícil do que o complexo: você tem que trabalhar duro para deixar seu pensamento limpo e torná-lo simples. Mas no final vale a pena porque, quando você chegar lá, poderá mover montanhas." -Steve Jobs
Apesar dos avanços contínuos em hardware e software de computação gráfica, começar com programação gráfica simples não é tão fácil ou acessível. Estamos trabalhando para mudar isso.
Se você gosta do projeto, considere contribuir! Confira as questões em aberto para ter ideias ou sugira as suas próprias. Estamos sempre procurando maneiras de tornar o projeto mais convidativo e melhorar a experiência do desenvolvedor em todas as plataformas. Não se preocupe se você não for um especialista em APIs C ou gráficas — teremos prazer em orientá-lo em tudo.
Se você é um hacker hardcore de C e OS, deveria considerar seriamente contribuir com o SDL para que possamos continuar escrevendo jogos sem nos preocupar com os detalhes da plataforma abaixo. Dê uma olhada nas palestras do Steam Dev Days, especialmente a palestra de Ryan C. Gordon sobre Desenvolvimento de Jogos com SDL 2.0.
simple2d.shdeps (siga as instruções no README) e execute git submodule update --remote neste repositório para atualizar o submódulosimple2d.sh e simple2d.cmd , confirme as alteraçõesrelease make/nmake targetv#.#.# ; anexe instaladores do Windows e bibliotecas da Apple às notas de lançamentosha256 para o arquivo de release e frameworks, usando shasum -a 256 <file>brew audit --strict ./simple2d.rb para detectar quaisquer problemas com a fórmulabrew install ./simple2d.rbO Simple 2D foi criado por Tom Black, que achava que a programação gráfica simples era muito difícil e decidiu fazer algo a respeito.
Tudo é licenciado pelo MIT, então comece a trabalhar.
Aproveitar!
