Opengl graafikateek. Interaktiivsed OpenGL-i rakendused

OpenGL-iga tutvumist tuleb alustada sellest, et OpenGL on spetsifikatsioon. Need. OpenGL määratleb lihtsalt nõutavate võimaluste komplekti. Rakendamine sõltub konkreetsest platvormist.
OpenGL on platvormideülene, keelest sõltumatu API programmeerimine graafikaga töötamiseks. OpenGL on madala taseme API, seega on hea mõte omada graafikat üldiselt ja sellega töötamiseks mõnda põhilist lineaaralgebrat.

Nime panemine

Ütleme paar sõna funktsioonide nimetamise kohta OpenGL-is. Esiteks algavad kõigi OpenGL-i otse pakutavate funktsioonide nimed eesliitega gl. Teiseks, funktsioonidel, mis määravad teatud parameetri, mida iseloomustab arvude hulk (näiteks koordinaat või värv), on järelliide kujul [parameetrite arv + parameetrite tüüp + parameetrite esitus].

Parameetrite arv – näitab aktsepteeritud parameetrite arvu. Võtab vastu järgmised väärtused: 1 , 2 , 3 , 4
Parameetri tüüp – näitab aktsepteeritud parameetrite tüüpi. Võimalikud on järgmised väärtused: b, s, i, f, d, ub, meie, ui. Need. bait (char C-s, 8-bitine täisarv), lühike (16-bitine täisarv), int (32-bitine täisarv), ujuk (ujukomaarv), double (topelttäpsus ujukomaarv), märgita bait, märgita lühike, unsigned int (viimased kolm on märgita täisarvud)
Parameetri esitus - näitab, millisel kujul parameetreid edastatakse; kui iga number on individuaalne, siis ei kirjutata midagi; kui parameetrid edastatakse massiivina, siis lisatakse funktsiooni nimele täht v

Näide: glVertex3iv määrab tipu koordinaadi, mis koosneb kolmest täisarvust, mis on antud massiivi osutina.

Graafika

Kõik graafilised objektid OpenGL-is on need punktide, joonte ja hulknurkade kogum. Seal on 10 erinevat primitiivi, millega kõik objektid on ehitatud. Nii kahe- kui ka kolmemõõtmeline. Kõik primitiivid on omakorda täpsustatud punktide - tippude abil.

GL_POINTS- iga tipp määrab punkti
GL_LINES- iga üksiku tipupaar määrab joone
GL_LINE_STRIP- iga tipupaar määrab joone (st eelmise rea lõpp on järgmise algus)
GL_LINE_LOOP- sarnaselt eelmisele, ainult et viimane tipp ühendatakse esimesega ja saadakse suletud kujund
GL_TRIANGLES- iga üksiku tipu kolmik määrab kolmnurga
GL_TRIANGLE_STRIP- iga järgmine tipp määratleb kolmnurga koos kahe eelmisega (selgub Pael kolmnurkadest)
GL_TRIANGLE_FAN- iga kolmnurk on määratletud esimese tipu ja järgnevate paaridega (st kolmnurgad on ehitatud ümber esimese tipu, moodustades midagi diafragma sarnast)
GL_QUADS- iga neli tippu moodustavad nelinurga
GL_QUAD_STRIP- iga järgmine paar tipud moodustab koos eelneva paariga nelinurga
GL_POLYGON- määrab hulknurga, mille nurkade arv on võrdne antud tippude arvuga

Primitiivi määratlemiseks kasutage konstruktsiooni glBegin(primitive_type)...glEnd(). Tipud on täpsustatud glVertex*. Tipud on seatud vastupäeva. Koordinaadid määratakse akna ülemisest vasakust nurgast. Tipu värv määratakse käsuga glColor*. Värviks on määratud RGB või RGBA. Käsk glColor* toimib kõikidele tippudele, mis tulevad pärast seda, kuni tekib teine käsk glColor*, või kõikidele tippudele, kui teisi glColor* käske pole.
Siin on kood, mis joonistab erinevat värvi tippudega ruudu:

glBegin (GL_QUADS) ;

glVertex2i(250, 450);

glVertex2i(250, 150);

glVertex2i(550 , 150 );

glVertex2i(550 , 450 );

glEnd() ;

OpenGL-i programmi põhitõed

Platvormist sõltumatuks tööks akendega saate kasutada . GLUT muudab OpenGL-iga töötamise lihtsamaks.
GLUT-i lähtestamiseks programmi alguses peate helistama glutInit(&argc, argv). Kuvarežiimi määramiseks helistage glutInitDisplayMode(režiim), kus režiim võib võtta järgmisi väärtusi:

GLUT_RGBA- sisaldab neljakomponendilist värvi (vaikimisi)
GLUT_RGB- sama mis GLUT_RGBA
GLUT_INDEX- sisaldab indekseeritud värvi
GLUT_DOUBLE- võimaldab topeltekraani puhvrit
GLUT_SINGLE- lubab ühe ekraani puhvri (vaikimisi)
GLUT_DEPTH- lubab Z-puhvri (sügavuse puhver)
GLUT_STENCIL- sisaldab šabloonipuhvrit
GLUT_ACCUM- võimaldab akumulatsioonipuhvrit
GLUT_ALPHA- võimaldab alfa segamist (läbipaistvus)
GLUT_MULTISAMPLE- võimaldab multisamplingut (antialiasing)
GLUT_STEREO- sisaldab stereopilti

Mitme režiimi samaaegseks valimiseks kasutage biti kaupa VÕI "|". Näiteks: glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH) võimaldab topeltpuhverdamist, Z-puhvrit ja neljavärvilist puhverdamist. Akende suurused on määratud glutInitWindowSize(laius, kõrgus). Tema positsioon on glutInitWindowPosition(x, y). Funktsiooni abil luuakse aken glutCreateWindow(akna_pealkiri).
GLUT rakendab sündmustest juhitud mehhanismi. Need. Seal on põhitsükkel, mis algab pärast initsialiseerimist ja kõik deklareeritud sündmused on selles juba töödeldud. Näiteks klaviatuuri klahvi vajutamine või hiirekursori liigutamine jne. Sündmuste töötleja funktsioone saate registreerida järgmiste käskude abil:

void glutDisplayFunc (tühine (*func) (void))- määrab pildi joonistamise funktsiooni
tühine glutReshapeFunc (tühine (*func) (int laius, sisemine kõrgus))- määrab akna suuruse muutmise töötlemise funktsiooni
void glutVisibilityFunc (kehtetu (*func)(int state))- määrab akna nähtavuse oleku muudatuste töötlemise funktsiooni
void glutKeyboardFunc (kehtetu (*func) (allkirjata täheklahv, int x, int y))- määrab funktsiooni klaviatuuri klahvivajutuste töötlemiseks (ainult need, mis genereerivad ASCII-märke)
void glutSpecialFunc (void (*func)(int-klahv, int x, int y))- määrab funktsiooni klaviatuuri klahvivajutuste töötlemiseks (need, mis ei genereeri ascii-märke)
tühine glutIdleFunc (tühine (*func) (void))- määrab funktsiooni, mida kutsutakse välja, kui muid sündmusi pole
void glutMouseFunc (tühine (*func) (nupp int, sisemine olek, int x, int y))- määratleb funktsiooni, mis töötleb hiirekäske
void glutMotionFunc (tühi (*func)(int x, int y))- määratleb funktsiooni, mis töötleb hiirekursori liikumist mis tahes hiirenupu vajutamisel
void glutPassiveMotionFunc (tühi (*func)(int x, int y))- määratleb funktsiooni, mis töötleb hiirekursori liikumist, kui ühtegi hiirenuppu ei vajutata
tühine glutEntryFunc (void (*func)(int state))- määratleb funktsiooni, mis käsitleb kursori liikumist väljaspool akent ja selle tagastamist
void glutTimerFunc (signed int msec, void (*func)(int value), väärtus)- määrab taimeriga kutsutava funktsiooni

Seejärel saate alustada peamist ringi glutMainLoop().

Esimene programm

Nüüd teame OpenGL-iga töötamise põhitõdesid. Sa võid kirjutada lihtne programm teadmiste kinnistamiseks.
Alustame GLUT-i päisefaili lisamisega:

Nüüd me juba teame, mida kirjutada. Registreerime kaks töötlejat: akna sisu joonistamiseks ja suuruse muutmise töötlemiseks. Neid kahte töötlejat kasutatakse sisuliselt kõigis programmides, mis kasutavad OpenGL-i ja GLUT-i.

int main (int argc, char * argv)

glutInit(& argc, argv) ;

glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*Luba topeltpuhverdus ja neljakomponendiline värv*/

glutInitWindowSize(800, 600) ;

glutCreateWindow("OpenGL-i õppetund 1" ) ;

glutReshapeFunc(ümberkujundamine) ;

glutDisplayFunc(kuva) ;

glutMainLoop() ;

tagasi 0 ;

Nüüd peame kirjutama akna suuruse muutmiseks käitleja funktsiooni. Määrame pildi väljundalaks käsu abil kogu akna suuruse glViewport(x, y, laius, kõrgus). Seejärel laadige projektsioonimaatriks glMatrixMode (GL_PROJECTION), asendage see seadmega glLoadIdentity() ja seadke ortogonaalprojektsioon. Ja lõpuks laadige mudelivaate maatriks glMatrixMode (GL_MODELVIEW) ja asendage see ühikaga.
Selle tulemusena saame:

tühine ümberkujundamine (int w, int h)

glViewport(0 , 0 , w, h) ;

glMatrixMode(GL_PROJECTION) ;

glLoadIdentity() ;

gluOrtho2D(0 , w, 0 , h);

glMatrixMode(GL_MODELVIEW) ;

glLoadIdentity() ;

Jääb vaid kirjutada funktsioon akna sisu joonistamiseks. Joonistame ruudu, mille ma eespool näitena tõin. Peate lisama väga vähe koodi. Esiteks peate enne joonistamist tühjendama erinevad puhvrid glClear (režiim). Kasutatakse samamoodi nagu glutInitDisplayMode. Võimalikud väärtused:

GL_COLOR_BUFFER_BIT- värvipuhvri tühjendamiseks
GL_DEPTH_BUFFER_BIT- sügavuspuhvri tühjendamiseks
GL_ACCUM_BUFFER_BIT- akumulatsioonipuhvri tühjendamiseks
GL_STENCIL_BUFFER_BIT- ekraanipuhvri puhastamiseks

Meie puhul peame ainult värvipuhvri tühjendama, sest Me ei kasuta teisi. Teiseks, pärast joonistamist peate paluma OpenGL-il ekraani puhvreid muuta glutSwapBuffers(), sest meil on topeltpuhverdus lubatud. Kõik joonistatakse kasutaja eest peidetud puhvrile ja seejärel muudetakse puhvreid. Seda tehakse selleks, et saada sujuv animatsioon ja nii et efekti ei tekiks virvendus ekraan.
Saame:

tühine kuva()

glClear(GL_COLOR_BUFFER_BIT) ;

glBegin(GL_QUADS) ;

glColor3f(1,0, 1,0, 1,0);

glVertex2i(250, 450);

glColor3f(0,0, 0,0, 1,0);

glVertex2i(250, 150);

glColor3f(0,0, 1,0, 0,0);

glVertex2i(550 , 150 );

glColor3f(1,0, 0,0, 0,0);

glVertex2i(550 , 450 );

glEnd() ;

glutSwapBuffers() ;

Alumine joon

Kõik! Saab koostada. See peaks välja nägema umbes selline:

Tavaliselt määratletakse ala, kus on vaja objektide olemasolu kindlaks teha (objektivaliku ala), stseeni projektsiooni fragmendina. Näiteks valib kasutaja projektsioonipildis manipulaatori (näiteks hiirekursori) abil ristkülikukujulise ala või klõpsab lihtsalt hiirenuppu, määratledes nii valikuala.

Kuna nendel juhtudel määratakse valikuala kolmemõõtmelise stseeni projektsiooni alusel, on vaja määrata kolmemõõtmelise stseeni vastav ala (valikustseen). Teie valitud stseen sõltub mitmest tegurist: kasutatav projektsioon, stseeni suurus ja väljundala.

Stseeni projektsiooni ristkülikukujulise osa alusel 3D-valikuala määramiseks on vaja teavet projektsioonimaatriksi kohta. Selleks saate kasutada mõnda funktsiooni GLUT teegist, mis on OpenGL teegi lisand ja pakub mitmeid lisavõimalusi.

OpenTK teegis on GLUT teegi funktsioonid nimeruumis Glu klassis Tao.OpenGL(C#). Object Pascalis on kõikidele GLUT teegi funktsioonidele ja protseduuridele lisatud eesliide "glu", et eristada neid OpenGL-i protseduuridest ja funktsioonidest.

Stseeni projektsiooni valitud fragmendi põhjal projektsioonimaatriksi genereerimiseks võite kasutada GLUT teegi käsku PickMatrix:

C#: void gluPickMatrix(double x, double y, double laius, double kõrgus, int vaateava); Object Pascal: protseduur gluPickMatrix(x,y,width,height: GLdouble; vaateava: PGLint);

GLUT teegi käsk PickMatrix muudab praegust maatriksit nii, et stseenipiirkonna suurus ühtiks selle stseeni projektsioonikoordinaatides määratletud valikupiirkonnaga. Käsul on järgmised parameetrid:

x, y – valikuala horisontaalsed ja vertikaalsed koordinaadid selle akna koordinaatides, milles kuvatakse 3D-stseeni projektsioon.
laius, kõrgus – 3D-stseeni valitud ristkülikukujulise projektsiooniala laius ja kõrgus akna koordinaatides.
vaateava on neljast täisarvulisest elemendist koosnev massiiv. C#-s edastatakse massiiv otse parameetrina, Object Pascalis aga parameetrina massiivi osuti. Massiiv määrab 3D-stseeni projektsiooni väljundala. Massiivi väärtused peavad vastama ViewPort käsuga määratletud väljundpiirkonna koordinaatidele. Selle massiivi elementidel peavad olema järgmised väärtused: 1. ja 2. element on vasaku külje x ja y koordinaadid ülemine nurk valitud ala ekraani koordinaatides, 3 ja 4 elementi – selle ala laius ja kõrgus.

Käsk tuleb täita enne Ortho või Frushtumi käskude täitmist, mis genereerivad projektsioonimaatriksi.

OpenGL-i teegi panemine valikurežiimi

Teegi valikurežiimi panemiseks kasutage käsku RenderMode:

C#: int RenderMode(RenderingMode mode); Objekt Pascal: funktsioon glRenderMode(mode: GLenum): GLint;

Režiimi parameeter määrab OpenGL-i teegi töörežiimi ja võib võtta ühe kolmest väärtusest:

Tabel 10.1. Käsu RenderMode režiimi parameetri võimalikud väärtused

Kirjeldus	Tähendus
Kirjeldus	OpenTK teek, C#	Objekt Pascal
Valikurežiim antud väärtus kasutatakse raamatukogu valikurežiimi panemiseks.	RenderingMode.Select	GL_SELECT
Stseeni pildistamise režiim. Seda režiimi kasutatakse vaikimisi pärast OpenGL-i teegi lähtestamist. Just selles režiimis loob pildi OpenGL-i teek.	RenderingMode.Render	GL_RENDER
Tagasiside režiim.	RenderingMode.Feedback	GL_FEEDBACK

Pärast valikurežiimile lülitumist ei renderda OpenGL pilti enne, kui režiim muudetakse stseeni renderdusrežiimiks, kasutades käsku RenderMode väärtusega RenderingMode.Render C# ja GL_RENDER Object Pascalis.

Stseeniobjektide nimetamine ja moodustamine

Nagu eespool mainitud, ei genereerita valikurežiimis pilti. Selles režiimis kuvatavaid käske kasutatakse objektide määratlemiseks, mis jäävad valikualasse.

Kuna objektid, millega kasutaja töötab, on tavaliselt moodustatud paljudest erinevatest primitiividest, kasutatakse valitud objekti määramiseks nimede virna. Nimed on täisarvud. Enne järgmise objekti väljastamise algust pannakse selle objekti nimi (number) nimevirnasse. Kui teek tuvastab objekti moodustamisel, et selle objekti primitiivid langevad valikualasse, siis kopeeritakse nimevirna sisu valikupuhvrisse (koos mõnega Lisainformatsioon) lähtestati käsuga SelectBuffer. Kui mõne teise nimega objekti primitiivid sisenevad stseenialale, kopeeritakse ka nimevirna sisu valikupuhvrisse. Seega saab täielikult või osaliselt valikualasse kuuluvate objektide nimed (numbrid). Arvestada tuleb sellega, et valitud objektide õigeks määramiseks on vajalik, et objektide koordinaatteisendused langeksid kokku nendega, mis tehti stseenipildi moodustamisel.

Nimevirnaga töötamiseks kasutatakse mitmeid käske. Nimevirna tühjendamine toimub käsu InitNames abil:

C#: void InitNames(); Object Pascal: protseduur glInitNames;

Nime virnale surumine toimub käsu PushName abil:

C#: void PushName(uint nimi); Objekt Pascal: protseduur glPushName(nimi: GLUint);

Nimi edastatakse käsuparameetrina.

Enne nimevirna kasutamist tuleb see käsuga InitNames initsialiseerida. Seejärel tuleb üks element virnasse lükata, kasutades käsku PushName. Enne iga objekti moodustamist asendatakse üks nimevirna element moodustatava objekti nimega, kasutades käsku LoadName. Protseduur asendab nimevirna viimase elemendi parameetrina antud elemendiga. Seega saab nimevirna initsialiseerimist ja kasutamist skemaatiliselt kujutada järgmiselt:

InitNames; PushName(0); ...LoadName(1); //objekti nr 1 moodustamine LoadName(2); //objekti nr 2 moodustamine LoadName(3); //objekti nr 3 moodustamine //jne. Nimekiri 10.7. Skeem nimevirna kasutamiseks objektide valimiseks

Otsustasite õppida OpenGL-i, kuid teate, kust alustada? Tegime materjalide valiku.

Mis on OpenGL

OpenGL (avatud graafika raamatukogu) on üks populaarsemaid graafikastandardeid graafikaga töötamiseks. Tema abiga kirjutatud programme saab üle kanda peaaegu igale platvormile, saades sama tulemuse. OpenGL võimaldab teil mitte kirjutada riistvara jaoks programme, vaid kasutada olemasolevaid arenguid. OpenGL-i arendab Silicon Graphics koostöös teiste tehnoloogiahiiglastega.

Programmeerimise seisukohast on OpenGL tarkvara liides Sest rastergraafika, näiteks graafikakiirendid. See sisaldab umbes 150 erinevat käsku, millega programmeerija saab defineerida erinevaid objekte ja renderdada.

Õppematerjalid

Õpetused

Interneti-kursused

Lynda - “OpenGL-i kursus”;
Tokyo Ülikool – “Interaktiivne arvutigraafika”;
San Diego ülikool – "Arvutigraafika alused".

Raamatud

Vene keeles

1. D. Shreiner – OpenGL Redbook – allalaadimine;

Raamat on OpenGL-i õppimise ametlik juhend. Viimased väljaanded erinevad peaaegu täielikult algversioonidest, autor uuendab seda vastavalt versioonide muudatustele. Sadade Open GL-iga töötavate ekspertide sõnul on see raamat esimene asi, mida igaüks, kes soovib seda tehnoloogiat õppida, peaks kätte võtma.

2. D. Wolf – Open GL 4. Varjutuskeel. Retseptiraamat (2015) - allalaadimine;

See raamat hõlmab kõiki GLSL-i programmeerimistehnikaid, alustades sellest põhitüübid varjutajad – tipp ja fragment – geomeetria, arvutamise ja tessellatsioonivarjuriteni. Pärast selle lugemist saate GPU-d kasutada mitmesuguste probleemide lahendamiseks.

3. D. Ginsburg – OpenGL ES 3.0. Arendaja juhend (2014) – osta;

Selles raamatus vaatab autor üle kogu API ja varjundite kirjutamise keele. Samuti leiate näpunäiteid jõudluse optimeerimiseks ja tõhususe maksimeerimiseks API töö ja GPU ja täielik kasutamine OpenGL ES paljudes rakendustes.

4. V. Porev - Arvutigraafika (2002) - allalaadimine;

Raamatus käsitletakse töötamise viise arvutigraafika, levinud probleemid, on toodud programmide näited C++ keeles.

Inglise keeles

1. P. Shirley - Arvutigraafika alused (2009) - ;

Raamat on mõeldud sissejuhatuseks arvutigraafikasse algtase. Autorid käsitlevad arvutigraafika matemaatilisi aluseid, keskendudes sellele, kuidas neid aluseid tõhusa koodi väljatöötamiseks rakendada.

2. E. Angel - Interaktiivne arvutigraafika - osta;

See raamat on mõeldud kõigile informaatikat ja programmeerimist süvendatult õppivatele õpilastele. Arvutianimatsioon ja graafika pole nii keeruline kui varem. Pärast tema avaldust kirjutas autor raamatu kõige arusaadavas keeles.

Selles jaotises õpime, kuidas OpenGL teegi funktsioone kasutades luua 3D-kujutisi, et järgmises peatükis saaksime välja töötada Windowsi rakenduse, mida võib pidada teaduslike arvutuste tulemuste vaatamise tööriistaks. Selle jaotise materjal võimaldab teil järk-järgult hoogu juurde saada ja omandada väga atraktiivse kolmemõõtmeliste piltide loomise ja haldamise tehnoloogia. Kõigepealt vaatame OpenGL-i teegi põhivõimalusi, seejärel õpime, kuidas seda juhtida OpenGL-i funktsioonid Näiteks lihtsad rakendused konsooli tüüpi ja alles pärast seda hakkame Windowsi rakendust arendama.

Lugeja ilmselt teab, et OpenGL on optimeeritud ja suure jõudlusega graafiline funktsioonide ja andmetüüpide teek kahe- ja 3D graafika. OpenGL-i standard kiideti heaks 1992. aastal. See põhineb Silicon Graphicsi (www.sgi.com) välja töötatud IRIS GL-i teegil. OpenGL-i toetavad kõik platvormid. Lisaks on OpenGL-i toetatud riistvaras. Seal on kiirenditega videokaardid ja spetsiaalsed SD-kaardid, mis täidavad riistvaras OpenGL-i primitiive.

Selle õppetunni esimese osa materjal on inspireeritud Addison-Wesley väga heast raamatust (veebis saadaval) "OpenGL-i programmeerimisjuhend, OpenGL-i õppimise ametlik juhend". Kui lugeja omab inglise keel, siis soovitame seda lugeda.

Lingitud raamatukogud

Microsofti OpenGL-i juurutamine hõlmab täiskomplekt OpenGL-i käsud, see tähendab globaalsed funktsioonid, mis sisaldub teegi OPENGL32.LIB tuumas ja millel on eesliide gl(nt glLineWidth). Pange tähele, et teegi põhifunktsioonidel on mitu versiooni, mis võimaldab teil soovitud parameetri või sätte määrata mis tahes viisil. Vaadake abi glColor* perekonna funktsioonide kohta. Selgub, et praegust värvi saab määrata 32 viisil. Näiteks funktsioon:

Kehtetu glColorSb (GLbyte punane, GLbyte roheline, GLbyte sinine);

Määrab värvi, kasutades kolme GLbyte tüüpi komponenti ja funktsiooni:

Kehtetu glColor4dv (const GLdouble *v);

Määrab selle neljast komponendist koosneva massiivi aadressi abil.

Neid valikuid arvesse võttes sisaldab põhiteek enam kui 300 käsku. Lisaks saate ühendada utiliitide teegi GLU32.LIB, mis täiendavad põhikernelit. Seal on funktsioone tekstuuride juhtimiseks, koordinaatide teisendamiseks, sfääride, silindrite ja ketaste genereerimiseks, kõverate ja pindade splaini lähendamiseks ( NURBS - Ebaühtlane ratsionaalne B-spliin), samuti vigade käsitlemine. Veel üks, täiendav ( abistav) GLAUX.LIB teek võimaldab lihtsal viisil luua Windowsi aknaid, kuvada mõningaid SD-objekte, hallata sisendsündmusi ja hallata taustaprotsess. Kahjuks ei ole see raamatukogu dokumenteeritud. Microsofti ettevõte Seda ei ole soovitatav kasutada kommertsprojektide arendamiseks, kuna see sisaldab sõnumitöötlustsükli koodi, millesse pole võimalik sisestada muude suvaliste sõnumite töötlemist.

Märge
GLbyte tüüp on samaväärne märgistatud tähe tüübiga ja GLdouble on samaväärne topelttüübiga. Teistele platvormidele kaasaskantavuse lihtsustamiseks kasutatakse oma tüüpe. Allpool pakume OpenGL-i tüüpide loendit. Neljas värvikomponent määrab värvi läbipaistvuse, mis tähendab, kuidas taustavärv seguneb pildi värviga. Mõne OpenGL-i käsu lõpus on v, mis näitab, et argumendiks peaks olema massiivi (vektori) aadress. Vektor on matemaatikas arvude (koordinaatide) jada, mis määratleb üheselt vektorruumi elemendi. Paljudel käskudel on mitu versiooni, mis lõpuks võimaldab teil vektorit erinevatel viisidel määrata.

Umbes kakskümmend Windowsi GDI funktsiooni on loodud spetsiaalselt OpenGL-iga töötamiseks. Enamikul neist on eesliide wgl(akronüüm Windows GL-st). Need funktsioonid on glx-i eesliitega funktsioonide analoogid, mis ühendavad OpenGL-i X window Systemi platvormiga. Lõpuks on mitu Win32 funktsiooni pikslivormingu juhtimiseks ja topeltpuhverdatud. Need kehtivad ainult spetsiaalsete OpenGL-i akende puhul.

Loed minu esimest OpenGL-i õpetust!

Enne OpenGL-i enda õppimise alustamist tundub mulle, et parem on öelda, kuidas koodi koostada, seda käivitada ja mis kõige tähtsam, kuidas katsetada nendes tundides antud lähtekoodidega.

Mida peate teadma

Need õppetunnid on suunatud lugejale, kellel pole programmeerimisest eriteadmisi. Muidugi on mis tahes programmeerimiskeele (C, Java, Lisp, JavaSript) tundmine tohutu pluss, kuid see pole vajalik, peate lihtsalt õppima korraga kahte ainet - 3D-graafikat ja programmeerimist.

Kõik nende tundide kood on kirjutatud C++ keeles võimalikult lihtsas stiilis. Ei mingeid malle, klasse ega osuti aritmeetikat. Seetõttu saate koodi vaadates aru, mida see teeb, isegi kui olete ainult JavaSriptiga tuttav.

Unustage kõik, mida teadsite OpenGL 1/2 kohta

Need õppetunnid eeldavad, et te ei tea 3D-graafikast midagi. Aga kui olete lugenud OpenGL-i õpetusi ja olete kohanud midagi sellist, nagu glBegin(), siis unustage see. Siin uurime OpenGL 3 ja 4 ning loetu kehtib OpenGL 1 või 2 kohta. Seetõttu soovitan unustada kõik, mida varem teadsid, muidu hakkab aju ebakõladest sulama.

Projekti ehitamine

Nende õppetundide koodi saab kompileerida Windowsi ja Linuxi jaoks. Mis tahes platvormi jaoks koodi koostamise alustamiseks peate tegema järgmist.

Uuenda oma videokaardi draivereid!! Ma hoiatasin sind :)
Laadige kompilaator alla, kui teil seda veel pole.
Installige CMake
Laadige alla valmis õppetundide allikad.
Genereeri projekt CMake'i abil
Pange projekt kokku.
Katsetage koodiga, et paremini mõista, mis seal toimub.

Allpool olen andnud üksikasjalikuma kirjelduse iga platvormi komplekteerimisprojektidest. Kuid olenevalt OS-i versioonist võivad ekraanipildid teie ekraanil kuvatavast pisut erineda, kuid üldiselt peaks kõik olema ligikaudu sama.

Windowsi kokkupanek

Ehitatud Linuxi jaoks

Maailmas on tohutult palju erinevaid Linuxi variatsioone, nii et ma ei taha tuua näiteid igaühe jaoks projekti koostamise kohta. Kui miski ei toimi, nagu allpool kirjeldatud, lugege dokumentatsiooni või otsige Internetist.

Installige uusimad draiverid oma videokaardile. Soovitan tungivalt mitteavatud lähtekoodiga draivereid. Neid ei kaasata GNU-sse, kuid need töötavad sageli palju paremini. Kui teie Linuxi järg ei paku automaatne paigaldaja, proovige lugeda Ubuntu juhendit.
Installige kompilaator koos kõigega vajalikud raamatukogud ja tööriistad. Siin on vajalike asjade loend: cmake make g++ libx11-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev. Kasutage sudo apt-get install ***** või su /yum install ******
Laadige alla näidisallikad ja pakkige need lahti kausta, näiteks ~/Projects/OpenGLTutorials/
Avage ~/Projects/OpenGLTutorials/ ja sisestage järgmised käsud:

mkdir ehitada

cd ehitamine

cmake..

Kui eelmised käsud täideti edukalt, luuakse build/ kausta makefile
sisestage "make all" ja pärast seda koostatakse kõik näited ja nende sõltuvused. Kui vigu pole, siis valmis käivitatavad failid paigutatakse kausta ~/Projects/OpenGLTutorials/

Mulle meeldib väga kasutada QtCreatori IDE-d. See IDE võib töötada koos CMake'iga ja pakub palju muid eeliseid, nagu silumine, automaatne lõpetamine jne.

Juhised projekti loomiseks QtCreatoris:

1. Klõpsake QtCreatoris Fail-> Tööriistad-> Valikud-> Kompileerimine ja käivitamine-> CMake

2. Määrake CMake'i tee. Tõenäoliselt on see /usr/bin/cmake

3. Fail->Ava projekt ja vali õpetused/CMakeLists.txt

4. Määrake ehituskaust, eelistatavalt peaks kaust olema väljaspool õpetuste kausta.

5. Valikuliselt määrake –DCMAKE_BUILD_TYPE=Silu suvandite väljal.

6. Klõpsake all oleval haamril. Pärast seda saab näiteid käivitada juhendites/kaustas

7. Näidete käivitamiseks QtCreatorist valige Projektid ->Teostusparameetrid ->Töökataloog ja valige kataloog, kus asuvad tekstuuri- ja mudelivarjutajad. 2. õpetuse jaoks on see ~/opengl -õpetus /tutorial02_red_triangle/

Näited jooksmisest

Kui projekt on koostatud, saab rakendusi käivitada otse kataloogist.
Kui teil on vaja näiteid käivitada otse IDE-st, kasutage töökataloogi õigesti seadistamiseks ülaltoodud juhiseid.

Kuidas neid õppetunde võtta

Iga õppetund on kaasas lähtekood ja andmed. Kõik need failid leiate vastavast tutorialXX/ kataloogist.

Kuid ma soovitan teil nendes failides mitte midagi muuta, need on ainult viitamiseks. Parem on mängida mänguväljakul/playground.cpp ja muuta seal mida iganes tahad. Kui rikute midagi ja ei saa seda tagasi taastada, saate selle faili lihtsalt kopeerida mõnest teisest õppetunnist.

Neid õpetusi lugedes näete kõikjal koodijuppe. Kopeerige need saidile playground.cpp, et näha neid tegevuses – katsetamine on alati hea. Ma ütlen seda uuesti, ärge lihtsalt lugege. valmis kood ja proovige see käivitada. Lähtekoodi lugedes ei õpi te palju. Isegi lihtsa kopeerimis-kleepimisega saate omale ämbri probleeme, mille lahendamisel saate vajaliku kogemuse.

Akna avamine

Lõpuks ometi! OpenGL!

Kuigi peate veel veidi ootama. Kõigis tundides tehakse 3D-toiminguid väga madalal tasemel, nii et teie jaoks pole võlu. Süsteemi akende ja sõnumitega töötamine on aga ebahuvitav ja igav, seega laseme GLFW teegil musta töö enda eest ära teha. Kui sa tõesti tahad, võid kasutada Win32 API for Windows või X11 API for Linux või kasutada midagi muud nagu SFML, FreeGLUT, SDL, ... loe lingilehte.

Olgu, alustame juba. Alustame sellest, et peame sõltuvused ühendama. Kuna peame sõnumid konsooli väljastama, kirjutame järgmise:

// Standardpäiste ühendamine

#kaasa

Seejärel ühendame GLEW

// Seda ei tohi unustada GLEW tuleb enne ühendada gl . h või glfw . h

#kaasa

Seejärel ühendame GLFW. See teek teeb kogu aknahalduse maagia.

#kaasa

Peal selles etapis me ei vaja seda teeki, kuid see sisaldab matemaatilisi funktsioone ja me vajame seda varsti. GLM-is pole maagiat ja kui sa tõesti tahad, võid maatriksite ja vektoritega töötamiseks kasutada mis tahes muud teeki. Lisame sõna "kasutades nimeruumi", et kirjutada "vec3", mitte "glm::vec3"

#kaasa

kasutades nimeruumi glm;

Kui kopeerida need koodijupid saidi playground.cpp, hakkab kompilaator kurtma, et puudub main() funktsioon. Nii et lisame:

int main())(

Parem oleks esmalt lähtestada GLFW:

// Initsialiseeri GLFW

if(!glfwInit())

{

fprintf(stderr, "GLFW initsialiseerimine nurjus\n");

tagasi -1;

}

Nüüd loome oma OpenGL-i akna: