OpenGL ni jukwaa-msingi, lugha huru Upangaji wa API kwa kufanya kazi na graphics. OpenGL ni API ya kiwango cha chini, kwa hivyo ni wazo nzuri kuwa na uelewa fulani wa michoro kwa ujumla na aljebra ya msingi ya mstari ili kufanya kazi nayo.
Kutaja
Wacha tuseme maneno machache kuhusu kazi za kutaja katika OpenGL. Kwanza, majina ya vitendaji vyote vilivyotolewa moja kwa moja na OpenGL huanza na kiambishi awali gl. Pili, kazi zinazobainisha parameta fulani inayojulikana na seti ya nambari (kwa mfano, kuratibu au rangi) zina kiambishi cha fomu [idadi ya vigezo + aina ya vigezo + uwakilishi wa vigezo].- Idadi ya vigezo - inaonyesha idadi ya vigezo vilivyokubaliwa. Inakubali maadili yafuatayo: 1 , 2 , 3 , 4
- Aina ya parameter - inaonyesha aina ya vigezo vinavyokubaliwa. Thamani zifuatazo zinawezekana: b, s, i, f, d, ub, sisi, ui. Wale. baiti (char katika C, nambari ya biti 8), fupi (nambari kamili ya biti 16), int (nambari kamili ya biti 32), kuelea (nambari ya sehemu inayoelea), mara mbili (nambari ya uhakika inayoelea mara mbili), baiti ambayo haijatiwa saini, fupi isiyo na saini, int ambayo haijatiwa saini (tatu za mwisho ni nambari kamili ambazo hazijatiwa saini)
- Uwakilishi wa parameta - inaonyesha ni kwa namna gani vigezo vinapitishwa; ikiwa kila nambari ni ya mtu binafsi, basi hakuna kitu kilichoandikwa; ikiwa vigezo vinapitishwa kama safu, basi barua inaongezwa kwa jina la kazi. v
Sanaa za picha
Wote vitu vya picha katika OpenGL ni mkusanyiko wa alama, mistari na poligoni. Kuna primitives 10 tofauti ambazo vitu vyote hujengwa. Zote mbili-dimensional na tatu-dimensional. primitives zote, kwa upande wake, ni maalum kwa pointi - vertices.- GL_POINTS- kila vertex inafafanua uhakika
- GL_LINES- kila jozi ya mtu binafsi ya wima inafafanua mstari
- GL_LINE_STRIP- kila jozi ya wima inafafanua mstari (yaani mwisho wa mstari uliopita ni mwanzo wa ijayo)
- GL_LINE_LOOP- sawa na uliopita, isipokuwa kwamba vertex ya mwisho imeunganishwa na ya kwanza na takwimu iliyofungwa inapatikana
- GL_TRIANGELI- kila mara tatu ya wima hufafanua pembetatu
- GL_TRIANGLE_STRIP- kila vertex inayofuata inafafanua pembetatu pamoja na zile mbili zilizopita (inageuka utepe kutoka kwa pembetatu)
- GL_TRIANGLE_FAN- kila pembetatu inafafanuliwa na vertex ya kwanza na jozi zinazofuata (yaani, pembetatu zimejengwa karibu na vertex ya kwanza, na kutengeneza kitu sawa na diaphragm)
- GL_QUADS- kila wima nne huunda quadrilateral
- GL_QUAD_STRIP- kila mmoja jozi inayofuata vipeo huunda pembe nne pamoja na jozi ya zilizotangulia
- GL_POLYGON- inafafanua poligoni yenye idadi ya pembe sawa na idadi ya wima iliyotolewa
Hapa kuna nambari inayochora mraba na wima za rangi tofauti:
- glAnza (GL_QUADS);
- glVertex2i(250, 450);
- glVertex2i(250, 150);
- glVertex2i(550 , 150);
- glVertex2i(550 , 450);
- glEnd();
Misingi ya Mpango wa OpenGL
Kwa kazi inayojitegemea ya jukwaa na windows, unaweza kutumia . GLUT hurahisisha kufanya kazi na OpenGL.Ili kuanzisha GLUT mwanzoni mwa programu unahitaji kupiga simu glutInit(&argc, argv). Kuweka modi ya kuonyesha, piga simu glutInitDisplayMode(modi), ambapo modi inaweza kuchukua maadili yafuatayo:
- GLUT_RGBA- inajumuisha rangi ya sehemu nne (chaguo-msingi)
- GLUT_RGB- sawa na GLUT_RGBA
- GLUT_INDEX- ni pamoja na rangi indexed
- GLUT_DOUBLE- huwezesha bafa ya skrini mbili
- GLUT_SINGLE- huwezesha bafa moja ya skrini (chaguo-msingi)
- GLUT_KINA- huwezesha Z-bafa (bafa ya kina)
- GLUT_STENCIL- inajumuisha buffer ya stencil
- GLUT_ACCUM- huwezesha bafa ya mkusanyiko
- GLUT_ALPHA- huwezesha mchanganyiko wa alpha (uwazi)
- GLUT_MULTISAMPLE- huwezesha sampuli nyingi (anti-aliasing)
- GLUT_STEREO- inajumuisha picha ya stereo
GLUT hutekeleza utaratibu unaoendeshwa na tukio. Wale. Kuna kitanzi kikuu kinachoanza baada ya kuanzishwa, na matukio yote yaliyotangazwa tayari yamechakatwa ndani yake. Kwa mfano, kubonyeza kitufe kwenye kibodi au kusonga mshale wa panya, nk. Unaweza kusajili vitendaji vya kushughulikia tukio kwa kutumia amri zifuatazo:
- utupu glutDisplayFunc (batili (* kazi) (batili))- huweka kazi ya kuchora picha
- utupu glutReshapeFunc (batili (* kazi) (upana wa int, urefu wa int))- huweka kazi ya usindikaji wa kubadilisha ukubwa wa dirisha
- utupu glutVisibilityFunc (batili (*func)(int state))- huweka kazi kwa ajili ya usindikaji mabadiliko katika hali ya mwonekano wa dirisha
- utupu glutKeyboardFunc (batili (*func)(ufunguo wa char ambao haujatiwa sahihi, int x, int y))- huweka kazi ya kusindika vibonye vya kibodi (zile tu zinazotoa herufi za ascii)
- utupu glutSpecialFunc (batili (*func)(int key, int x, int y))- huweka kazi ya kusindika vibonyezo vya kibodi (zile ambazo hazitoi herufi za ascii)
- utupu glutIdleFunc (utupu (* kazi) (utupu))- hubainisha chaguo la kukokotoa linaloitwa wakati hakuna matukio mengine
- utupu glutMouseFunc (batili (*func) (kitufe cha int, int state, int x, int y))- inafafanua kazi inayosindika amri za panya
- utupu glutMotionFunc (batili (*func)(int x, int y))- inafafanua kazi ambayo inashughulikia harakati ya mshale wa panya wakati kifungo chochote cha mouse kinasisitizwa
- utupu glutPassiveMotionFunc (batili (*func)(int x, int y))- inafafanua kazi ambayo huchakata harakati ya mshale wa panya wakati hakuna kifungo cha mouse kinachopigwa
- utupu glutEntryFunc (batili (*func)(int state))- inafafanua kazi ambayo inashughulikia harakati ya mshale nje ya dirisha na kurudi kwake
- utupu glutTimerFunc (msec zisizo na saini, utupu (*func)(thamani ya ndani), thamani)- inabainisha kazi inayoitwa kwenye kipima muda
Programu ya kwanza
Sasa tunajua misingi ya kufanya kazi na OpenGL. Unaweza kuandika programu rahisi ili kuunganisha maarifa.Wacha tuanze kwa kujumuisha faili ya kichwa cha GLUT:
Sasa tunajua tayari nini cha kuandika katika kuu. Wacha tusajili washughulikiaji wawili: kwa kuchora yaliyomo kwenye dirisha na kwa usindikaji wa kurekebisha ukubwa. Vidhibiti hivi viwili kimsingi hutumiwa katika programu yoyote inayotumia OpenGL na GLUT.
- int main (int argc, char * argv)
- glutInit(& argc, argv);
- glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*Washa uakibishaji maradufu na rangi ya vipengele vinne*/
- glutInitWindowSize(800, 600) ;
- glutCreateWindow("OpenGL somo la 1" ) ;
- glutReshapeFunc(reshape);
- glutDisplayFunc(onyesho);
- glutMainLoop() ;
- kurudi 0;
Sasa tunahitaji kuandika kazi ya kushughulikia kwa kurekebisha ukubwa wa dirisha. Wacha tuweke eneo la pato la picha kuwa saizi ya dirisha zima kwa kutumia amri glViewport(x, y, upana, urefu). Kisha pakia matrix ya makadirio Modi ya glMatrix(GL_PROJECTION), badala yake na kitengo glLoadIdentity() na kuweka makadirio ya orthogonal. Na hatimaye, pakia matrix ya mtazamo wa mfano Modi ya glMatrix(GL_MODELVIEW) na uibadilishe na kitengo kimoja.
Kama matokeo, tunapata:
- uundaji upya utupu (int w, int h)
- glViewport(0 , 0 , w, h);
- glMatrixMode(GL_PROJECTION) ;
- glLoadIdentity() ;
- gluOrtho2D(0 , w, 0 , h);
- glMatrixMode(GL_MODELVIEW) ;
- glLoadIdentity() ;
Inabakia tu kuandika kazi ya kuchora yaliyomo kwenye dirisha. Tutachora mraba ambao nilitoa hapo juu kama mfano. Utalazimika kuongeza nambari ndogo sana. Kwanza, kabla ya kuchora, unahitaji kufuta buffers mbalimbali kwa kutumia glClear (mode). Inatumika kwa njia sawa na glutInitDisplayMode. Thamani zinazowezekana:
- GL_COLOR_BUFFER_BIT- kufuta bafa ya rangi
- GL_DEPTH_BUFFER_BIT- kufuta bafa ya kina
- GL_ACCUM_BUFFER_BIT- kufuta buffer ya mkusanyiko
- GL_STENCIL_BUFFER_BIT- kwa kusafisha bafa ya skrini
Tunapata:
- onyesho tupu ()
- 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() ;
Mstari wa chini
Wote! Inaweza kukusanywa. Inapaswa kuonekana kama hii:Kwa kawaida, eneo ambalo ni muhimu kuamua uwepo wa vitu (eneo la uteuzi wa kitu) hufafanuliwa kama kipande cha makadirio ya eneo. Kwa mfano, mtumiaji huchagua eneo la mstatili kwenye picha ya makadirio kwa kutumia manipulator (kwa mfano, pointer ya panya) au bonyeza tu kitufe cha panya, na hivyo kufafanua eneo la uteuzi.
Kwa kuwa katika kesi hizi eneo la uteuzi limedhamiriwa kwa makadirio ya eneo la pande tatu, ni muhimu kuamua eneo linalolingana la eneo la tatu-dimensional (eneo la uteuzi). Tukio utalochagua litategemea mambo kadhaa: makadirio yaliyotumika, saizi ya tukio, na eneo la pato.
Ili kubainisha eneo la uteuzi wa 3D kulingana na sehemu ya mstatili ya makadirio ya tukio, taarifa kuhusu matrix ya makadirio inahitajika. Ili kufanya hivyo, unaweza kutumia baadhi ya vipengele kutoka kwa maktaba ya GLUT, ambayo ni nyongeza kwenye maktaba ya OpenGL na hutoa uwezo wa ziada.
Katika maktaba ya OpenTK, kazi za maktaba za GLUT ziko kwenye darasa la Glu kwenye nafasi ya majina Tao.OpenGL(C #). Katika Object Pascal, kazi na taratibu zote za maktaba ya GLUT zimeainishwa na "glu" ili kuzitofautisha na taratibu na utendakazi za OpenGL.
Ili kutoa matrix ya makadirio kulingana na kipande kilichochaguliwa cha makadirio ya tukio, unaweza kutumia amri ya PickMatrix ya maktaba ya GLUT:
C#: gluPickMatrix batili (mara mbili x, y mbili, upana mara mbili, urefu mara mbili, kituo cha kutazama); Kitu Pascal: utaratibu gluPickMatrix(x,y,upana,urefu: GLdouble; viewport: PGLint);
Amri ya PickMatrix ya maktaba ya GLUT hurekebisha matriki ya sasa ili ukubwa wa eneo la tukio ulingane na eneo la uteuzi lililobainishwa katika viwianishi vya makadirio ya eneo hilo. Amri ina vigezo vifuatavyo:
- x, y - kuratibu za usawa na wima za eneo la uteuzi katika kuratibu za dirisha ambalo makadirio ya eneo la 3D yanaonyeshwa.
- upana, urefu - upana na urefu wa eneo lililochaguliwa la makadirio ya mstatili ya eneo la 3D katika kuratibu za dirisha.
- viewport ni safu ya vipengele vinne kamili. Katika C #, safu hupitishwa moja kwa moja kama parameta; katika Object Pascal, pointer kwa safu hupitishwa kama parameta. Mkusanyiko hufafanua eneo la pato la makadirio ya eneo la 3D. Thamani za safu lazima zilingane na viwianishi vya eneo la pato vilivyofafanuliwa kwa kutumia amri ya ViewPort. Vipengele vya safu hii lazima viwe na maadili yafuatayo: vipengele vya 1 na 2 ni viwianishi vya x na y vya kushoto. kona ya juu eneo lililochaguliwa katika kuratibu za skrini, vipengele 3 na 4 - upana na urefu wa eneo hili.
Amri lazima itekelezwe kabla ya kutekeleza amri za Ortho au Frushtum, ambazo hutoa matrix ya makadirio.
Kuweka maktaba ya OpenGL katika hali ya uteuzi
Kuweka maktaba katika hali ya uteuzi, tumia amri ya RenderMode:
C #: int RenderMode (Modi ya Utoaji); Kitu Pascal: kazi ya glRenderMode(modi: GLenum): GLint;
Kigezo cha hali huamua hali ya uendeshaji ya maktaba ya OpenGL na inaweza kuchukua moja ya maadili matatu:
| Maelezo | Maana | |
|---|---|---|
| Maktaba ya OpenTK, C# | Kitu Pascal | |
| Hali ya uteuzi thamani iliyopewa kutumika kuweka maktaba katika hali ya uteuzi. | UtoajiModi.Chagua | GL_SELECT |
| Hali ya upigaji picha wa eneo. Hali hii inatumiwa na chaguo-msingi baada ya maktaba ya OpenGL kuanzishwa. Ni katika hali hii kwamba picha inatolewa na maktaba ya OpenGL. | UtoajiMode.Render | GL_RENDA |
| Hali ya maoni. | Utoaji.Maoni | GL_FEEDBACK |
Baada ya kubadili hali ya uteuzi, OpenGL haitoi picha hadi modi ibadilishwe hadi hali ya uonyeshaji eneo kwa kutumia amri ya RenderMode yenye thamani ya RenderingMode.Render katika C# na GL_RENDER katika Object Pascal.
Kutaja na kuunda vitu vya eneo
Kama ilivyojadiliwa hapo juu, hakuna picha inayotolewa katika hali ya uteuzi. Amri za upigaji picha katika hali hii hutumiwa kufafanua vitu vinavyoanguka ndani ya eneo la uteuzi.
Kwa kuwa vitu ambavyo mtumiaji hufanya kazi navyo kwa kawaida huundwa kutoka kwa vitu vingi vya asili tofauti, safu ya majina hutumiwa kuamua kitu kilichochaguliwa. Majina ni maadili kamili. Kabla ya kutoa kitu kinachofuata huanza, jina (nambari) ya kitu hiki huwekwa kwenye safu ya jina. Ikiwa, wakati wa kuunda kitu, maktaba itagundua kuwa vitu vya asili vya kitu hiki vinaanguka kwenye eneo la uteuzi, basi yaliyomo kwenye safu ya jina yanakiliwa kwa bafa ya uteuzi (pamoja na zingine. Taarifa za ziada) iliyoanzishwa na amri ya SelectBuffer. Wakati viasili vya kitu kingine kilichopewa jina vinapoingia eneo la tukio, yaliyomo kwenye safu ya jina pia yatanakiliwa kwenye bafa ya uteuzi. Kwa hivyo, majina (nambari) ya vitu ambavyo viko kabisa au sehemu ndani ya eneo la uteuzi vinaweza kupatikana. Inapaswa kuzingatiwa kuwa ili kuamua kwa usahihi vitu vilivyochaguliwa, ni muhimu kwamba mabadiliko ya kuratibu ya vitu sanjari na yale yaliyofanywa wakati wa kuunda picha ya eneo.
Amri kadhaa hutumiwa kufanya kazi na safu ya jina. Kufuta safu ya jina hufanywa kwa kutumia InitNames amri:
C #: batili InitNames(); Kitu Pascal: utaratibu glInitNames;
Kusukuma jina kwenye stack hufanywa kwa kutumia PushName amri:
C #: PushName batili (jina lisilofaa); Kitu Pascal: utaratibu glPushName(jina: GLuint);
Jina hupitishwa kama parameta ya amri.
Kabla ya safu ya majina kutumika, lazima ianzishwe kwa kutumia amri ya InitNames. Kisha unahitaji kushinikiza kipengele kimoja kwenye stack kwa kutumia PushName amri. Kabla ya kila kitu kuundwa, kipengele kimoja cha safu ya jina kitabadilishwa na jina la kitu kinachoundwa kwa kutumia amri ya LoadName. Utaratibu hubadilisha kipengee cha mwisho kwenye safu ya jina na kile kilichopewa kama kigezo. Kwa hivyo, uanzishaji na utumiaji wa safu ya jina inaweza kuwakilishwa kimkakati kama ifuatavyo:
InitNames; PushName(0); ...Jina la Mzigo(1); // uundaji wa kitu No. 1 LoadName (2); // uundaji wa kitu No. 2 LoadName (3); // uundaji wa kitu Nambari 3 // nk. Orodha 10.7. Mchoro wa kutumia safu ya majina kuchagua vitu
Umeamua kujifunza OpenGL, lakini unajua pa kuanzia? Tulifanya uteuzi wa nyenzo.
OpenGL ni nini
OpenGL (fungua maktaba ya michoro) ni mojawapo ya viwango maarufu vya picha vya kufanya kazi na michoro. Programu zilizoandikwa kwa msaada wake zinaweza kuhamishiwa karibu na jukwaa lolote, kupata matokeo sawa. OpenGL hukuruhusu usiandike programu za vifaa, lakini utumie maendeleo yaliyopo. OpenGL imetengenezwa na Silicon Graphics, kwa ushirikiano na makampuni mengine makubwa ya teknolojia.
Kutoka kwa mtazamo wa programu, OpenGL ni kiolesura cha programu Kwa picha za raster, kama vile vichapuzi vya michoro. Inajumuisha kuhusu amri 150 tofauti ambazo programu inaweza kufafanua vitu mbalimbali na kutoa.
Nyenzo za Kujifunza
Mafunzo
Kozi za mtandaoni
- Lynda - "Kozi ya OpenGL";
- Chuo Kikuu cha Tokyo - "Picha za Kompyuta zinazoingiliana";
- Chuo Kikuu cha San Diego - "Misingi ya Graphics ya Kompyuta."
Vitabu
Katika Kirusi
1. D. Shreiner - OpenGL Redbook - pakua;
Kitabu ndicho mwongozo rasmi wa kujifunza OpenGL. Matoleo ya hivi punde yanakaribia kuwa tofauti kabisa na matoleo asili; mwandishi huisasisha kwa mujibu wa mabadiliko katika matoleo. Kulingana na mamia ya wataalamu wanaofanya kazi na Open GL, kitabu hiki ndicho kitu cha kwanza ambacho mtu yeyote anayetaka kujifunza teknolojia anapaswa kuchukua.
2. D. Wolf - Fungua GL 4. Lugha ya Shader. Kitabu cha mapishi (2015) - pakua;
Kitabu hiki kinashughulikia anuwai kamili ya mbinu za upangaji za GLSL, kuanzia aina za msingi vivuli - vertex na fragment - kwa jiometri, compute na vivuli vya tessellation. Baada ya kuisoma, utaweza kutumia GPU kutatua aina mbalimbali za matatizo.
3. D. Ginsburg - OpenGL ES 3.0. Mwongozo wa Msanidi programu (2014) - kununua;
Katika kitabu hiki, mwandishi anahakiki API nzima na lugha kwa ajili ya kuandika vivuli. Pia utapata vidokezo vya kuboresha utendaji, kuongeza ufanisi API kazi na GPU na matumizi kamili OpenGL ES katika anuwai ya programu.
4. V. Porev - Picha za Kompyuta (2002) - kupakua;
Kitabu kinajadili njia za kufanya kazi nazo michoro za kompyuta, matatizo ya kawaida, mifano ya programu katika C ++ imetolewa.
Kwa Kingereza
1. P. Shirley - Misingi ya Michoro ya Kompyuta (2009) -;
Kitabu hiki kimekusudiwa kama utangulizi wa michoro ya kompyuta ngazi ya msingi. Waandishi hufunika misingi ya hisabati ya michoro ya kompyuta kwa msisitizo wa jinsi ya kutumia misingi hii ili kukuza msimbo mzuri.
2. E. Angel - Picha za kompyuta zinazoingiliana - kununua;
Kitabu hiki kimekusudiwa wanafunzi wote wanaosoma sayansi ya kompyuta na programu kwa kina. Uhuishaji wa kompyuta na michoro sio ngumu kama hapo awali. Kufuatia kauli yake, mwandishi aliandika kitabu kwa lugha inayoeleweka zaidi.
Katika sehemu hii, tutajifunza jinsi ya kuunda picha za 3D kwa kutumia vitendaji vya maktaba ya OpenGL, ili katika sura inayofuata tuweze kutengeneza programu ya Windows ambayo inaweza kuzingatiwa kama zana ya kutazama matokeo ya hesabu za kisayansi. Nyenzo katika sehemu hii itawawezesha hatua kwa hatua kupata kasi na ujuzi wa teknolojia ya kuvutia sana ya kuunda na kusimamia picha tatu-dimensional. Kwanza tutaangalia uwezo wa msingi wa maktaba ya OpenGL, kisha tutajifunza jinsi ya kudhibiti Vitendaji vya OpenGL Kwa mfano maombi rahisi aina ya console na tu baada ya hapo tutaanza kuendeleza programu ya Windows.
Msomaji labda anajua kuwa OpenGL ni maktaba ya michoro iliyoboreshwa, ya utendaji wa juu ya kazi na aina za data za kuonyesha mbili na Michoro ya 3D. Kiwango cha OpenGL kiliidhinishwa mwaka wa 1992. Kinatokana na maktaba ya IRIS GL iliyotengenezwa na Silicon Graphics (www.sgi.com). OpenGL inatumika kwenye mifumo yote. Kwa kuongeza, OpenGL inasaidiwa katika maunzi. Kuna kadi za video zilizo na vichapuzi na kadi maalum za SD ambazo hutekeleza kanuni za awali za OpenGL katika maunzi.
Nyenzo katika sehemu ya kwanza ya somo hili imeongozwa na kitabu kizuri sana (kinachopatikana mtandaoni) kutoka Addison-Wesley, "OpenGL Programming Guide, Mwongozo Rasmi wa Kujifunza OpenGL". Ikiwa msomaji anamiliki Lugha ya Kiingereza, basi tunapendekeza kuisoma.
Maktaba Zilizounganishwa
Utekelezaji wa Microsoft wa OpenGL unajumuisha seti kamili OpenGL amri, yaani kazi za kimataifa, iliyojumuishwa katika msingi wa maktaba ya OPENGL32.LIB na kuwa na kiambishi awali gl(km glLineWidth). Kumbuka kwamba vipengele vya msingi vya maktaba vina matoleo mengi, huku kuruhusu kubainisha kigezo au mpangilio unaotaka kwa njia yoyote unayopenda. Angalia usaidizi wa utendakazi katika familia ya glColor*. Inageuka kuwa unaweza kuweka rangi ya sasa kwa njia 32. Kwa mfano, kazi:
GlColorSb tupu(GLbyte nyekundu, GLbyte kijani, GLbyte bluu);
Inafafanua rangi kwa kutumia vipengele vitatu vya aina ya GLbyte, na kazi:
Utupu glColor4dv (const GLdouble *v);
Inabainisha kwa kutumia anwani ya safu ya vipengee vinne.
Kwa kuzingatia chaguzi hizi, maktaba ya msingi ina zaidi ya amri 300. Kwa kuongeza, unaweza kuunganisha maktaba ya GLU32.LIB ya huduma zinazosaidia kernel kuu. Kuna kazi za kudhibiti maumbo, kuratibu mabadiliko, kutengeneza tufe, silinda na diski, makadirio ya mikunjo ya mikunjo na nyuso ( NURBS - Non-Uniform Rational B-Spline), pamoja na kushughulikia makosa. Moja zaidi, ya ziada ( msaidizi) maktaba ya GLAUX.LIB inaruhusu kwa njia rahisi unda madirisha ya Windows, onyesha baadhi ya vitu vya SD, shughulikia matukio ya ingizo na udhibiti mchakato wa usuli. Kwa bahati mbaya, maktaba hii haijarekodiwa. Kampuni ya Microsoft Haipendekezi kuitumia kwa ajili ya kuendeleza miradi ya kibiashara, kwa kuwa ina msimbo wa kitanzi wa usindikaji wa ujumbe ambao haiwezekani kuingiza usindikaji wa ujumbe mwingine wa kiholela.
Kumbuka
Aina ya GLbyte ni sawa na aina ya char iliyotiwa saini, na GLdouble ni sawa na aina mbili. Aina za kibinafsi hutumiwa kurahisisha uwezo wa kubebeka kwenye mifumo mingine. Tunatoa orodha ya aina za OpenGL hapa chini. Sehemu ya rangi ya nne huamua uwazi wa rangi, ambayo ni jinsi rangi ya mandharinyuma inavyochanganyika na rangi ya picha. Amri zingine za OpenGL zina v mwishoni, ambayo inaonyesha kuwa hoja inapaswa kuwa anwani ya safu (vekta). Vekta katika hisabati ni mlolongo wa nambari (kuratibu) ambazo hufafanua kipekee kipengele cha nafasi ya vekta. Amri nyingi zina matoleo mengi, mwishowe hukuruhusu kutaja vekta kwa njia tofauti.
Takriban vitendaji ishirini vya GDI vya Windows vimeundwa mahsusi kufanya kazi na OpenGL. Wengi wao wana kiambishi awali wgl(kifupi cha Windows GL). Hizi ni mlinganisho wa chaguo za kukokotoa zilizoambishwa awali na glx, ambazo huunganisha OpenGL kwenye jukwaa la Mfumo wa dirisha la X. Hatimaye, kuna kazi kadhaa za Win32 za kudhibiti umbizo la pixel na iliyoakibishwa mara mbili. Zinatumika tu kwa madirisha maalum ya OpenGL.
Unasoma mafunzo yangu ya kwanza ya OpenGL!
Kabla ya kuanza kujifunza OpenGL yenyewe, inaonekana kwangu kuwa ni bora kukuambia jinsi ya kukusanya msimbo, kuiendesha, na muhimu zaidi, jinsi ya kufanya majaribio na misimbo chanzo iliyotolewa katika masomo haya.
Unachohitaji kujua
Masomo haya yanalenga msomaji bila ujuzi maalum wa programu. Bila shaka, ujuzi wa lugha yoyote ya programu (C, Java, Lisp, JavaSript) itakuwa pamoja na kubwa, lakini hii haihitajiki, unapaswa tu kujifunza masomo mawili kwa wakati mmoja - graphics za 3D na programu.
Nambari zote katika masomo haya zimeandikwa kwa C++ kwa mtindo rahisi zaidi. Hakuna violezo, madarasa au hesabu za kielekezi. Kwa hiyo, ukiangalia msimbo, unaweza kuelewa kile kinachofanya, hata ikiwa unajua tu JavaSript.
Sahau kila kitu ulichojua kuhusu OpenGL 1/2
Masomo haya yanachukulia kuwa hujui chochote kuhusu michoro ya 3D. Lakini ikiwa umekuwa ukisoma mafunzo ya OpenGL na ukakutana na kitu kama glBegin(), basi usahau. Hapa tutajifunza OpenGL 3 na 4, na kile unachosoma kinatumika kwa OpenGL 1 au 2. Kwa hiyo, ninapendekeza kwamba usahau kila kitu ulichojua hapo awali, vinginevyo ubongo wako utaanza kuyeyuka kutokana na kutofautiana.
Kujenga mradi
Nambari kutoka kwa masomo haya inaweza kukusanywa kwa Windows na Linux. Ili kuanza kuunda nambari ya jukwaa lolote, unahitaji kufanya yafuatayo:
- Sasisha viendeshaji vya kadi yako ya video!! Nilikuonya :)
- Pakua kikusanyaji ikiwa huna tayari.
- Weka CMake
- Pakua vyanzo vya somo vilivyotengenezwa tayari.
- Tengeneza mradi kwa kutumia CMake
- Kusanya mradi.
- Jaribu kutumia msimbo ili kuelewa vyema kinachoendelea huko.
Hapo chini nimetoa maelezo ya kina zaidi ya kukusanya miradi kwa kila jukwaa. Lakini kulingana na toleo la OS, viwambo vya skrini vinaweza kutofautiana kidogo na kile kitakachoonekana kwenye skrini yako, lakini kwa ujumla, kila kitu kinapaswa kuwa takriban sawa.
Mkutano kwa Windows
Jenga kwa ajili ya Linux
Kuna idadi kubwa ya tofauti tofauti za Linux ulimwenguni, kwa hivyo sitaki kutoa mifano ya kukusanya mradi kwa kila moja. Ikiwa kitu hakifanyiki kama ilivyoelezewa hapa chini, soma hati au utafute Mtandao.
- Sakinisha madereva wa hivi karibuni kwa kadi yako ya video. Ninapendekeza sana madereva yasiyo ya chanzo wazi. Hazijajumuishwa na GNU, lakini mara nyingi hufanya kazi vizuri zaidi. Ikiwa muundo wako wa Linux hautoi kisakinishi otomatiki, jaribu kusoma mwongozo wa Ubuntu.
- Sakinisha mkusanyaji na wote maktaba muhimu na zana. Hapa kuna orodha ya unachohitaji: cmake make g++ libx11-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev. Tumia sudo apt-get install ***** au su /yum install ******
- Pakua vyanzo vya mfano na uzifungue kwenye folda, kwa mfano ~/Projects/OpenGLTutorials/
- Nenda kwa ~/Projects/OpenGLTutorials/ na uweke amri zifuatazo:
- mkdir kujenga
- cd kujenga
- cmke..
- Ikiwa amri za awali zilitekelezwa kwa mafanikio, faili ya faili itaundwa kwenye build/folda
- ingiza "fanya yote" na baada ya hii mifano yote na utegemezi wao utakusanywa. Ikiwa hakuna makosa, basi tayari faili zinazoweza kutekelezwa itawekwa kwenye ~/Projects/OpenGLTutorials/ folda
Ninapenda sana kutumia IDE ya QtCreator. Kitambulisho hiki kinaweza kufanya kazi na CMake nje ya kisanduku na kutoa rundo la manufaa mengine, kama vile utatuzi, kukamilisha kiotomatiki, n.k.
Maagizo ya kujenga mradi katika QtCreator:
1. Katika QtCreator bonyeza Faili-> Zana-> Chaguzi-> Unganisha & Tekeleza-> CMake
2. Bainisha njia ya CMake. Hii ina uwezekano mkubwa kuwa /usr/bin/cmake
3. Faili->Fungua Mradi na uchague tutorials/CMakeLists.txt
4. Bainisha folda ya ujenzi, folda inapaswa kuwa nje ya folda ya mafunzo.
5. Seti kwa hiari -DCMAKE_BUILD_TYPE=Tatua katika sehemu ya chaguo.
6. Bofya kwenye nyundo hapa chini. Baada ya hayo, mifano inaweza kuendeshwa kutoka kwa mafunzo/ folda
7. Ili kutekeleza mifano kutoka kwa QtCreator, chagua Miradi -> Vigezo vya Utekelezaji -> Orodha ya Kazi , na uchague saraka ambapo muundo na vivuli vya mfano vinapatikana. Kwa mafunzo ya 2 itakuwa ~/opengl -tutorial /tutorial02_red_triangle/
Mifano ya Kuendesha
Mara mradi unakusanywa, programu zinaweza kuzinduliwa moja kwa moja kutoka kwa saraka.Ikiwa unahitaji kuendesha mifano moja kwa moja kutoka kwa IDE, tumia maagizo hapo juu ili kuweka kwa usahihi saraka ya kazi.
Jinsi ya kuchukua masomo haya
Kila somo huja na msimbo wa chanzo na data. Faili hizi zote zinaweza kupatikana katika mafunzo sambambaXX/ saraka.
Lakini ninapendekeza kwamba usibadilishe chochote katika faili hizi, ni za kumbukumbu tu. Ni bora kucheza katika playground/playground.cpp na kubadilisha chochote unachotaka hapo. Ukivunja kitu na huwezi kukirejesha, unaweza kurudisha faili hii kwa kuinakili kutoka kwa somo lingine lolote.
Unaposoma mafunzo haya, utaona vipande vya msimbo kila mahali. Jisikie huru kuzinakili kwenye playground.cpp ili kuziona zikifanya kazi - majaribio ni mazuri kila wakati. Nitasema tena, usisome tu. msimbo tayari, na ujaribu kuizindua. Hutajifunza mengi kwa kusoma tu msimbo wa chanzo. Hata kwa kubandika nakala rahisi, utapata ndoo yako mwenyewe ya shida, ukisuluhisha ambayo utapata uzoefu unaohitajika.
Kufungua dirisha
Hatimaye! OpenGL!
Ingawa, itabidi kusubiri kidogo. Katika masomo yote, shughuli za 3D zitafanywa kwa kiwango cha chini sana, kwa hiyo hakutakuwa na uchawi kwako. Hata hivyo, kufanya kazi na madirisha ya mfumo na ujumbe haipendezi na inachosha, kwa hivyo tutaruhusu maktaba ya GLFW itufanyie kazi chafu. Ikiwa unataka kweli, unaweza kutumia Win32 Api ya Windows au X11 API ya Linux, au utumie kitu kingine kama SFML, FreeGLUT, SDL, ... soma ukurasa wa kiungo.
Sawa, wacha tuanze tayari. Hebu tuanze na ukweli kwamba tunahitaji kuunganisha utegemezi. Kwa kuwa tunahitaji kutoa ujumbe kwa koni, tutaandika yafuatayo:
// Kuunganisha vichwa vya kawaida
#pamoja na
#pamoja na
Kisha tunaunganisha GLEW
// Hatupaswi kusahau hilo KUNG'ARA lazima iunganishwe kabla gl . h au glfw . h
#pamoja na
Kisha tunaunganisha GLFW. Maktaba hii itafanya uchawi wote wa usimamizi wa dirisha.
#pamoja na
Washa katika hatua hii hatuhitaji maktaba hii, lakini ina vipengele vya hesabu na tutaihitaji hivi karibuni. Hakuna uchawi katika GLM, na ikiwa unataka kweli, unaweza kutumia maktaba nyingine yoyote kufanya kazi na matrices na vekta. Tunajumuisha "kutumia nafasi ya majina" ili kuandika "vec3" na sio "glm::vec3"
#pamoja na
kutumia nafasi ya majina glm;
Ukinakili vipande hivi vya msimbo kwenye playground.cpp, mkusanyaji ataanza kulalamika kwamba hakuna chaguo la kukokotoa kuu(). Kwa hivyo wacha tuongeze:
int kuu())(
Itakuwa bora kuanzisha GLFW kwanza:
// Anzisha GLFW
ikiwa(!glfwInit())
{
fprintf(stderr, "Imeshindwa kuanzisha GLFW\n");
kurudi -1;
}
Sasa wacha tuunde dirisha letu la OpenGL:
glfwOpenWindowHint( GLFW_ FSAA_ SAMPULI, 4); // 4 xkulainisha
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); //sisi inahitajika OpenGL 3.3
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // sisi Sivyo inahitajika mzee OpenGL
// Wacha tufungue dirisha na kuunda muktadha
if(!glfwOpenWindow(1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW))
{
fprintf(stderr, "Imeshindwa kufungua dirisha la GLFW\n");
