Quali versioni di OpenGL imparare e / o usare?

Quindi, sono nuovo di OpenGL ... Ho una conoscenza generale della programmazione del gioco ma poca esperienza pratica.

Ho cercato vari articoli e libri e ho cercato di immergermi in OpenGL, ma ho trovato confuse le varie versioni e il vecchio e il nuovo modo di fare le cose.

Immagino che la mia prima domanda sia: qualcuno conosce alcune cifre sulle percentuali di giocatori che possono eseguire ogni versione di OpenGL. Qual è la quota di mercato? 2.x, 3.x, 4.x ...

Ho esaminato i requisiti per Half Life 2 poiché so che Valve lo ha aggiornato con OpenGL per funzionare su Mac e so che di solito cercano di raggiungere una base di utenti molto ampia, e dicono un minimo di GeForce 8 Series. Ho esaminato la 8800 GT sul sito Web di Nvidia ed elencato il supporto per OpenGL 2.1. Il che, forse mi sbaglio, mi sembra antico poiché c'è già 4.x. Ho cercato un driver per 8800 GT e dice che supporta 4.2! Un po 'di discrepanza lì, lol.

Ho anche letto cose come XP supporta solo fino a una determinata versione, oppure OS X supporta solo 3.2, o qualsiasi altra cosa. Nel complesso, sono solo confuso su quanto supporto c'è per le varie versioni e quale versione imparare / usare.

Sto anche cercando risorse per l'apprendimento. I miei risultati di ricerca finora mi hanno indirizzato al SuperBible OpenGL. La 4a edizione ha ottime recensioni su Amazon, ma insegna 2.1. La quinta edizione insegna 3.3 e ci sono un paio di cose nelle recensioni che menzionano la quarta edizione è migliore e che la quinta edizione non insegna correttamente le nuove funzionalità o qualcosa del genere? Fondamentalmente, anche all'interno del materiale didattico vedo discrepanze e non so nemmeno da dove cominciare.

Da quello che ho capito, 3.x ha iniziato un modo completamente nuovo di fare le cose e ho letto da vari articoli e recensioni che vuoi "stare lontano da funzionalità obsolete come glBegin (), glEnd ()" eppure molti libri e tutorial che ho visto usare quel metodo. Ho visto persone dire che, fondamentalmente, il nuovo modo di fare le cose è più complicato, ma il vecchio modo è cattivo>.>

Solo una nota a margine, personalmente, so che ho ancora molto da imparare in anticipo, ma sono interessato alla tassellatura; quindi immagino che anche in questo ci siano fattori, perché, per quanto ho capito, è solo in 4.x?

[solo a proposito, il mio desktop supporta 4.2]

Se ti stai chiedendo la copertura OpenGL, un buon punto di partenza è Steam Hardware Survey.

http://store.steampowered.com/hwsurvey?platform=pc

Sfortunatamente, sembra essere rotto in questo momento e non mostra alcuna statistica per i videocards. : \

Ho anche letto cose come XP supporta solo fino a una determinata versione

DirectX 9 è paragonabile a OpenGL 2.1, DirectX 10 a OpenGL 3.0 e DirectX 11 a OpenGL 4.0. È qui che nasce la confusione.

XP supporta tutte le versioni di OpenGL, ma non supporta DirectX 10 o versioni successive. Questo è il modo in cui Microsoft voleva forzare le persone a eseguire l'aggiornamento a Vista, ma non ha funzionato molto bene. OpenGL è uno standard aperto, quindi finché i produttori di videocard sono disposti a produrre driver per XP, supporterà le versioni più recenti di OpenGL.

Da quello che ho capito, 3.x ha iniziato un modo completamente nuovo di fare le cose e ho letto da vari articoli e recensioni che vuoi "stare lontano da funzionalità obsolete come glBegin (), glEnd ()" eppure molti libri e tutorial che ho visto usare quel metodo. Ho visto persone dire che, fondamentalmente, il nuovo modo di fare le cose è più complicato, ma il vecchio modo è cattivo>.>

Questo è un grosso problema per OpenGL. Fondamentalmente, ai vecchi tempi, si inviava roba al videocard utilizzando "modalità immediata". Inizia con glBegin, fai alcune cose, finisci con glEnd. Tuttavia, ai driver della scheda video non piace affatto . Come possono sapere quante cose invierai? Saranno 4 vertici per un quad testurizzato o 100.000 per un modello con skin? Questo è il motivo per cui hanno introdotto oggetti buffer vertici (VBO). Mentre la modalità immediata è un elenco collegato, un VBO è un array statico. Lo sviluppatore sa quanto è grande, il guidatore sa quanto è grande. Tutti sono felici. Quindi la scheda standard OpenGL (Khronos Group) ha deciso di deprecare la modalità immediata per OpenGL 3.0 e versioni successive. Tuttavia, questo è problematico, come mostrerò con un semplice esempio.

Supponiamo che tu voglia visualizzare un quad testurizzato, partendo da zero.

In OpenGL 2.1:

• Imposta la matrice di proiezione e inseriscila GL_PROJECTION.
• Imposta la matrice modelview e inseriscila GL_MODELVIEW.
• Carica un'immagine e mettila in una GL_TEXTURE_2Dmaniglia.
• Definisci le posizioni, le coordinate delle trame e i colori per i tuoi vertici.
• Lega la trama.
• glBegin... glVertex2f... glTexCoord2f... glEnd.

In OpenGL 3.0:

• Crea una matrice per proiezione e vista modello.
• Carica un'immagine e mettila in una GL_TEXTURE_2Dmaniglia.
• Definisci le posizioni, le coordinate delle trame e i colori per i tuoi vertici e inseriscili nei VBO.
• Crea un oggetto array di vertici (VAO) e collega i tuoi VBO.
• Scrivi uno shader per produrre un quad testurizzato e inserirlo in un programma shader.
• Collegare le matrici al programma shader usando le uniformi.
• Lega la trama.
• Collega la trama al programma shader.
• glDrawArrays.

Quindi cosa potrebbe andare storto nella prima versione?

• Le tue posizioni sono errate.
• L'avvolgimento del vertice è il modo sbagliato.
• La trama non viene caricata correttamente.
• La trama non si lega correttamente.
• La tua matrice di proiezione è sbagliata.
• La tua matrice modelview è sbagliata.
• Non stai inviando i vertici giusti.

E nella seconda versione, puoi avere problemi con quanto sopra e :

• I tuoi VBO sono sbagliati.
• Il tuo VAO è sbagliato.
• Il tuo shader è sbagliato.
• La tua texture che si lega allo shader è sbagliata.

Senza strumenti di debug adeguati, questo diventa un problema serio. Questo è il motivo per cui le persone dicono che dovresti attenersi alla modalità immediata. Fortunatamente, ora abbiamo il gDEBugger gratuito ed eccellente ora, ma non è un proiettile magico.

Per rispondere alla tua domanda: dipende dal tuo gioco. Se vuoi raggiungere un vasto pubblico (ad esempio un gioco casual o un platform 2D), dovresti scegliere come target 2.1. Se stai realizzando un epico gioco spaziale che non funzionerà su hardware di sei anni, scegli come target 3.3. E se hai bisogno dell'ultimo e del massimo per la compatibilità futura, target 4.0.

Per alcune statistiche sulla compatibilità hardware è possibile consultare il sondaggio Steam: http://store.steampowered.com/hwsurvey/ Anche se elenca DX10 e DX11, la compatibilità hardware è la stessa di OpenGL 3 e OpenGL 4 rispettivamente. Si noti che lo stato di installazione del driver OpenGL sulle persone è generalmente peggiore di DX.

Windows XP non supporta DX10 o DX11, ma OpenGL 3 e 4 dovrebbero andare bene, a condizione che i driver siano ok. OSX supporta OpenGL 3 (al massimo), su Linux ottieni OpenGL 4 con i driver del fornitore ATI / NVIDIA (ovviamente solo se l'hardware lo supporta).

Poi ci sono anche le versioni ES mobili di OpenGL. In effetti suggerirei di esaminare OpenGL ES 2.0, perché è più piccolo, quindi più facile da imparare, ma è anche necessario utilizzare pratiche moderne, ad esempio shader e VBO. È anche ciò che viene utilizzato sulla maggior parte dei dispositivi mobili (quindi potresti iniziare a creare giochi per dispositivi mobili) e WebGL è sostanzialmente lo stesso, quindi potresti effettivamente fare tutto il tuo apprendimento nel browser web con i suoi rapidi vantaggi di sviluppo. OpenGL ES 3.0 è previsto per l'estate.

La tessellazione è una funzionalità di OpenGL 4.0. Dovresti prima imparare gli altri tipi di shader, figuriamoci tutte le basi, ma sono d'accordo che sia interessante - in effetti ho scritto un piccolo test con esso: http://blog.tapiov.net/post/15189341463/playing- con-opengl-4-tassellatura