[Any] 2D Game programming, nudo e crudo

[AngeL)]

Salve a tutti,
è da un po' che ho lo sfizio di programmarmi un piccolo motore grafico (roba 2d, top-down, niente di che) e farci qualche giochino.
Diciamo che il mio obiettivo è qualcosa di questo tipo, per rendere l'idea:

http://sandbox.yoyogames.com/extras/image/name/san1/129/49129/screenshot101.jpg

Non sono assolutamente interessato alla grafica avanzata, ai suoni, alla trama, la roba che fa "perdere tempo", insomma; mi interessa soltanto la programmazione che c'è sotto, collision checking, fisica, eventuali moduli che implementerò, magari mantenere il motore e cambiare totalmente il sistema di rendering, così da esercitarmi anche con l'encapsulation, capire come funziona una libreria grafica, i driver grafici, ho sete di conoscenza, insomma.

Detto questo, ho sbattuto la testa contro C++/OpenGL per trovarmi davanti una miriade di tutorials o outdated o che saltavano le basi, l'effettiva "inizializzazione" del contesto OGL, per passare direttamente al 3D, allo shading e ai concetti avanzati.

La mia idea era di partire col C++ per avere a che fare davvero con lo "scheletro" del game programming, ma sono abbastanza flessibile, e nella mia vita da "casual programmer" ho provato davvero di tutto, e non mi dispiacerebbe imparare qualcosa di nuovo o approfondire qualcosa di cui ho scalfito solo la superficie.

Mi scuso per il lungo post e ringrazio in anticipo chiunque mi dedicherà un po' del suo tempo! :)

[MEMon]

Non ho capito se stai chiedendo quale linguaggio usare o no.
Nel caso fosse così io ti consiglio java, a suo tempo feci anchio un giochino (http://www.hwupgrade.it/forum/showthread.php?t=1304155) e mi trovai bene.

[AnonimoVeneziano]

Mi sembri bello deciso a imparare quello che ci sta sotto più che a produrre qualcosa di funzionante.

In tal caso OpenGL o DirectX sono sicuramente gli strumenti che fanno per te. Il C++ già lo sai o lo stai imparando?

La situazione della documentazione di OpenGL allo stato attuale non è delle più rosee ...

Il Red Book (quello ufficiale attualmente alla settima edizione) finora arriva solo a OpenGL 3.3 (siamo alla 4.2) e il nuovo libro non esce prima di marzo dell'anno prossimo. Inoltre è pieno di spiegazioni su funzioni deprecate senza che sia specificato in maniera chiara cosa è deprecato e cosa no (c'è solo un laconico avviso ad inizio capitolo che alcune delle funzioni contenute nel capitolo sono deprecate), nonostante ciò rimane comunque il miglior strumento su cui studiare allo stato attuale, perchè i vari tutorial come "NeHe" o altri ormai sono veramente vecchissimi. Ce ne sono anche di nuovi (un po' meno completi), che però ti obbligano ad usare gli shaders e per quello che devi fare tu (a meno che non devi applicare dei particolari effetti speciali implementati via fragment shader) è una complicazione abbastanza inutile, anche se però è il futuro della grafica moderna e visto che il tuo scopo è di imparare forse vale la pena fare questo sforzo. Questo tutorial spiega abbastanza bene i concetti base di opengl 3/4 , (per i concetti più avanzati sarà necessario il Red Book): http://www.arcsynthesis.org/gltut/index.html .

PS = Ho notato che non spiega granchè riguardo al Blending che potrebbe essere utile in un gioco 2D (il tutorial è ancora in costruzione/espansione), per quello puoi guardare da un altra parte o sul red book

[AngeL)]

Non ho capito se stai chiedendo quale linguaggio usare o no.
Nel caso fosse così io ti consiglio java, a suo tempo feci anchio un giochino (http://www.hwupgrade.it/forum/showthread.php?t=1304155) e mi trovai bene.
Ottimo spunto, sembra ci abbia lavorato un bel po'!
Per quanto riguarda il Java, non è che magari "wrappa" un po' troppe cose, nascondendomi ciò che in realtà viene fatto?
Mi sembri bello deciso a imparare quello che ci sta sotto più che a produrre qualcosa di funzionante.

In tal caso OpenGL o DirectX sono sicuramente gli strumenti che fanno per te. Il C++ già lo sai o lo stai imparando? [/url]

Ho fatto un po' di ruggine sul template programming e sugli header della STL che non uso spesso, ma il resto lo so abbastanza bene. Purtroppo non ho mai trovato un bel progettino o una bella community, quindi ho solo scritto programmini stupidi da solo :(

Comunque, inizio a dare un'occhiata a questi due tutorial, thanks for the tip! :)

EDIT: ecco, mi sono bloccato dove mi ero bloccato anche ieri: ho gli header gl.h, glu.h e glext.h inclusi di default in MinGW, ma non ho capito come funziona la storia delle library, vengono fornite dal manutentore della gpu? E col makefile, che devo fare? Non c'è una sorta di pre-tutorial?

E per quanto riguarda il redbook, è questo (http://fly.cc.fer.hr/~unreal/theredbook/)? Perchè ci sono 3/4 manuali, tutorial e reference diversi su opengl.org!

[gugoXX]

Io consiglio XNA

Ho fatto anche io un giochino (ispirato).
La corsa dei controller.

Prendi 2-4 controller wireless, li piazzi su un lato di un tavolo inclinato abbastanza.
Schiacci start, e i controller iniziano a vibrare.
Vibrando si muovono perche' il tavolo e' inclinato, e iniziano a scendere.
Il primo controller che cade dal tavolo vince.

Ovviamente tu intanto prendi le scommesse, fai da allibratore, mentre i tuoi amici sbracciano e incitano il proprio favorito a correre.

Alla fine chi vince offre a tutti gli altri una birra.

[AnonimoVeneziano]

Ottimo spunto, sembra ci abbia lavorato un bel po'!
Per quanto riguarda il Java, non è che magari "wrappa" un po' troppe cose, nascondendomi ciò che in realtà viene fatto?


Ho fatto un po' di ruggine sul template programming e sugli header della STL che non uso spesso, ma il resto lo so abbastanza bene. Purtroppo non ho mai trovato un bel progettino o una bella community, quindi ho solo scritto programmini stupidi da solo :(

Comunque, inizio a dare un'occhiata a questi due tutorial, thanks for the tip! :)

EDIT: ecco, mi sono bloccato dove mi ero bloccato anche ieri: ho gli header gl.h, glu.h e glext.h inclusi di default in MinGW, ma non ho capito come funziona la storia delle library, vengono fornite dal manutentore della gpu? E col makefile, che devo fare? Non c'è una sorta di pre-tutorial?

Per quanto riguarda OpenGL funziona così (anch'io all'inizio sono rimasto un po' confuso, non ti preoccupare ;) ):

OpenGL è una specifica e viene implementata dai vari vendors di hardware grafico che sono principalmente i vari AMD , Nvidia e Intel ... etc. In pratica installi il runtime OpenGL quando installi i drivers grafici che contengono anche l'implementazione opengl.

Per quanto riguarda l'SDK ... questo è più problematico. I drivers contengono solo il runtime (la libreria per l' esecuzione dei programmi) , ma non contengono header files per la programmazione.
Per quanto riguarda Windows Microsoft ha incluso una propria versione degli headers file OpenGL nel proprio sistema operativo che però arrivano fino a OpenGL 1.2/1.4 e quindi l'utilizzo di ogni funzione non presente in queste versioni di opengl darà un errore.
Il modo UFFICIALE per utilizzare le funzioni OpenGL su qualsiasi sistema è quello di richiedere un puntatore alla funzione utilizzando la funzione "wglGetProcAddress()" per Windows , "glXGetProcAddress()" per Unix e "cglGetProcAddress()" per Mac. In pratica si passa il nome della funzione che si vuole a queste funzioni (ad esempio "wglGetProcAddress("glDrawElements") ) e questa ritorna un puntatore a tale funzione che dovrà essere memorizzato in un puntatore a funzione e chiamato attraverso il puntatore. Questo permette di utilizzare tutte le funzioni messe a disposizione dalle varie implementazioni di OpenGL (che non è una, ma sono tante) e che possono esporre solo un subset di tutti i metodi OpenGL o addirittura funzioni in più utilizzando il meccanismo delle estensioni.

Da usare in pratica questo metodo è un delirio :) Il mio consiglio è di usare una libreria che faccia l'inizializzazione e l'incapsulamento delle varie funzioni nei corrispettivi puntatori in maniera automatica, come ad esempio la OpenGL Extension Wrangler Library (GLEW) (http://glew.sourceforge.net/). Sono molto facili da usare. Basta includere l'header file glew.h e compilare insieme al tuo progetto il file glew.c e all'inizializzazione del tuo programma ( prima di chiamare ogni funzione OpenGL) chiamare la funzione "glewInit" che si occuperà di inizializzare i puntatori (che hanno lo stesso nome delle funzioni opengl) , le istruzioni molto semplici da seguire le trovi sul sito, ma se hai dei problemi chiedi pure ;)


E per quanto riguarda il redbook, è questo (http://fly.cc.fer.hr/~unreal/theredbook/)? Perchè ci sono 3/4 manuali, tutorial e reference diversi su opengl.org!

Beh ... quella è la prima edizione, l'unica gratuita :sofico:

Ti assicuro che non vuoi imparare opengl su quello, visto che si ferma a OpenGL 1.1 ed è FORTEMENTE deprecato :)

L'ultima versione del libro è la settima e l'unico modo legale per averla è comprarla :)

[AngeL)]

Per quanto riguarda Windows Microsoft ha incluso una propria versione degli headers file OpenGL nel proprio sistema operativo che però arrivano fino a OpenGL 1.2/1.4 e quindi l'utilizzo di ogni funzione non presente in queste versioni di opengl darà un errore.
Dove sono? Io ho trovato soltanto quelli nella cartella include di MinGW (gl.h, glu.h, glext.h)

Il mio consiglio è di usare una libreria che faccia l'inizializzazione e l'incapsulamento delle varie funzioni nei corrispettivi puntatori in maniera automatica, come ad esempio la OpenGL Extension Wrangler Library (GLEW) (http://glew.sourceforge.net/). Sono molto facili da usare. Basta includere l'header file glew.h e compilare insieme al tuo progetto il file glew.c e all'inizializzazione del tuo programma ( prima di chiamare ogni funzione OpenGL) chiamare la funzione "glewInit" che si occuperà di inizializzare i puntatori (che hanno lo stesso nome delle funzioni opengl) , le istruzioni molto semplici da seguire le trovi sul sito, ma se hai dei problemi chiedi pure ;)
ho dato un'occhiata e capito come funziona, ma non vorrei semplicemente includere tutta 'sta valanga di header e chiamare le funzioni, vorrei capire anche dove sono definite, vorrei includere solo quelle che mi servono... so che è pura follia, ma in fondo non devo essere produttivo, mi basta capire ciò che faccio :)

Oppure, mi sta bene usare glut per gestire la parte os-related delle finestre (serve a questo, giusto?) ma vorrei prima fare a mano la procedura, almeno su windows, per capire cosa succede. Stesso discorso per glew.

Grazie mille per la disponibilità e gentilezza! :D

[AnonimoVeneziano]

ciao , wglGetProcAddress() è definita in wingdi.h che è inclusa a sua volta da windows.h.

Se vuoi gestire il tutto tu allora quello che devi fare è:

Per ogni funzione che vuoi chiamare devi creare un puntatore a funzione (possibilmente globale , così lo inizializzi una volta per tutto il programma) e assegnargli il valore ritornato da wglGetProcAddress().
I prototipi di questi puntatori a funzione sono in genere in un file "glext.h" che ti fornisce o la tua implementazione o trovi in giro (ad esempio sul sito di opengl che contiene l'ultima versione con tutti i simboli opengl aggiornati). Devi ottenere con questa funzione solo le funzioni che sono state introdotte con una versione di OpenGL superiore alla 1.1 . Tutte le funzioni OpenGL 1.1 (che è la versione "base" di ogl) sono chiamabili già direttamente .

Ogni funzione opengl appartiene a una determinata "estensione" opengl . Se la tua implementazione OpenGL non supporta una certa estensione allora chiamare wglGetProcAddress() per quella funzione ritornerà NULL. Il formato del nome delle funzioni opengl da passare a getprocaddress è "glNomeFunzioneVENDOR_ESTENSIONE" (ad esempio "glGenVertexArraysARB" dove il vendor dell'estensione è l'ARB che indica che è una funzione standard opengl) . Quindi dovresti verificare anche che la tua implementazione supporti alcune estensioni OpenGL che vuoi usare. Le varie versioni di opengl non sono altro che una collezione di estensioni "ufficializzate" dall'ARB opengl.

Per sapere se la tua implementazione supporta una certa estensione devi usare la funzione "glGetString(GL_EXTENSIONS)" che ritorna una stringa molto grossa con il nome di tutte le estensioni supportate (glGetString è già inclusa in gl.h e supportata dall'implementazione base di MS, quindi non devi ottenerla tramite wglGetProcAddress) e parsare la stringa per cercare il nome della estensione che ti interessa. Questa cosa ti serve, perchè alcune funzioni sono implementate attraverso estensioni diverse a seconda del vendor e se usi un'implementazione NVidia a getprocaddress dovrai passare un certo nome di funzione, mentre ad una AMD dovrai passare un altro nome (questo perchè cambia la parte finale della stringa, ossia il VENDOR_ESTENSIONE a seconda del vendor). All'inizio tutte le funzioni che chiamerai comunque saranno funzioni standard e quindi con estensione ARB.

Quindi in sostanza per inizializzare una funzione che sai essere supportata dalla tua implementazione (nell'esempio "glGenVertexArrays" dell'estensione "GL_ARB_vertex_array_object") :


#include <GL/gl.h>
#include "glext.h"

...
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
...

void init_function()
{
....
glGenVertexArrays = wglGetProcAddress("glGenVertexArraysARB");
....
}


Prima di poter chiamare wglGetProcAddress devi aver inizializzato il contesto opengl o attraverso GLUT o attraverso altre funzioni wgl se non usi glut e usi direttamente Win32.

Ciao

[AngeL)]

Dunque... sto seguendo principalmente questo (http://www.cprogramming.com/tutorial.html#opengltutorial) tutorial, più roba googlata qua e là.

Ho creato un environment unix-like con msys, e sto impazzendo per capire tutte le dipendenze, cosa si appoggia a cosa... è praticamente impossibile, ma è anche nella mia indole :D mi sa che alla fine scriverò un mattone di codice che crollerà alla minima modifica, ma almeno avrò imparato qualcosa :D

P.S. mica hai idea di qualche progetto a cui posso aggregarmi, qualche community, risorsa da cui prendere spunto, così, per non essere "solo"? E' orribile dialogare con google :muro:

[AnonimoVeneziano]

Dunque... sto seguendo principalmente questo (http://www.cprogramming.com/tutorial.html#opengltutorial) tutorial, più roba googlata qua e là.

Ho creato un environment unix-like con msys, e sto impazzendo per capire tutte le dipendenze, cosa si appoggia a cosa... è praticamente impossibile, ma è anche nella mia indole :D mi sa che alla fine scriverò un mattone di codice che crollerà alla minima modifica, ma almeno avrò imparato qualcosa :D

P.S. mica hai idea di qualche progetto a cui posso aggregarmi, qualche community, risorsa da cui prendere spunto, così, per non essere "solo"? E' orribile dialogare con google :muro:

Un consiglio: se hai intenzione di usare Win32 e di aprirti la finestra , creare il contesto, agganciarlo e gestire i messaggi di input a mano anzichè usare qualche toolkit allora usa Visual Studio.

Ti risparmia diversi grattacapi.

Per il resto non conosco gruppi del genere, sorry.

[AngeL)]

Sto iniziando a pensare che forse, per quello che devo fare, le OpenGL sono troppo potenti. Il fatto di dover creare oggetti in un contesto 3d per poi proiettarli su un "mero" piano 2d mi sembra un po' uno spreco di tutto il calcolo matriciale che c'è dietro... ma in fondo neanche posso mettermi a blittare bitmap, no?

A questo punto, mi conviene creare un piccolo header con funzioni tipo
Rect(x, y, width, height);
Circle(x, y, radius);
sfruttando sempre le ogl, ma "semplificandole", oppure toglierle di mezzo completamente e passare ad un qualcosa tipo... processing (http://processing.org/)? o SDL?

[Tommo]

Si, se vuoi proprio scendere alla base, blittare manualmente tutto a schermo (senza usare la GPU) è sempre un gran esercizio :D

Le prestazioni saranno ovviamente alcune decine di volte sotto OpenGL, ma forse si impara anche di più :D
Specie se ti dai a vari livelli di parallasse, sprite che ruotano, linee vettoriali, animazioni e trasparenze, che con OpenGL sono gratis, ma a mano devi saperle fare :ahsisi:

Poi probabilmente OGL sarà molto più semplice da imparare!

[AngeL)]

Alla fine mi sono buttato su SDL. Rimane molto più complesso di altri approcci, però sento di star iniziando a capirci qualcosa :D

Gli unici problemi che sto avendo sono di tipo pratico: se mi conviene definire variabili globali o locali, molti moduli o pochi, classi all-purpose o codice specifico... però credo di dovermi fare le ossa leggendo altro codice, e scrivendone, ovviamente :D

[Z80Fan]

Da quello che hai scritto, io ti consiglierei la libreria Allegro (http://www.talula.demon.co.uk/allegro/).
È fatta molto bene, bastano poche righe per l'inizializzazione, hai tutte le funzioni per creare forme geometriche e testo (come rect e circle ;)), e hai anche funzioni per gestire gli input.
Io la uso sempre in C++ quando ho bisogno di fare roba 2D.
SDL e OpenGL (che usate assieme sono veramente una bomba) sono molto potenti, ma anche complesse per un beginner. :)

[AngeL)]

Ci avevo già dato (più di) un'occhiata, ma mi sembra un po' troppo basica... con le SDL mi tocca sicuramente scrivere qualche riga di codice in più, però sento di avere più controllo. Sarò sadico... :D

Comunque ho seguito il classico path: tris, pong e tra oggi e domani inizio l'ennesimo clone di space invaders :D