OpenGL kwa sasa ni mojawapo ya violesura maarufu vya programu (API) kwa ajili ya kuendeleza programu katika nyanja ya michoro ya pande mbili na tatu. Kiwango cha OpenGL kilitengenezwa na kuidhinishwa mwaka wa 1992 na kampuni zinazoongoza za ukuzaji programu, na kinatokana na maktaba ya IRIS GL iliyotengenezwa na Silicon Graphics.
Kwa sasa, utekelezaji wa OpenGL unajumuisha maktaba kadhaa (maelezo ya kazi za msingi za OpenGL, GLU, GLUT, GLAUX na wengine), madhumuni ambayo yataelezwa hapa chini.
Vipengele vya tabia vya OpenGL ambavyo vilihakikisha kuenea na ukuzaji wa kiwango hiki cha picha ni:
Utulivu - nyongeza na mabadiliko kwa kiwango hutekelezwa kwa njia ya kudumisha utangamano na programu zilizotengenezwa hapo awali.
Kuegemea na kubebeka - programu zinazotumia OpenGL zinahakikisha matokeo sawa ya kuona bila kujali aina ya mfumo wa uendeshaji unaotumiwa na shirika la kuonyesha habari. Kwa kuongeza, programu hizi zinaweza kukimbia kwenye kompyuta za kibinafsi, vituo vya kazi na kompyuta kubwa.
Urahisi wa kutumia - Kiwango cha OpenGL kina muundo uliofikiriwa vizuri na kiolesura angavu, ambacho hukuruhusu kuunda programu bora na laini chache za msimbo kuliko kutumia maktaba zingine za michoro kwa gharama ya chini. Kazi zinazohitajika ili kuhakikisha utangamano na vifaa mbalimbali zinatekelezwa katika ngazi ya maktaba na kurahisisha sana maendeleo ya programu.
Vipengele vya Msingi vya OpenGL
Seti ya primitives ya msingi: pointi, mistari, polygons, nk.
Tazama na uratibu mabadiliko
Kuondoa mistari na nyuso zisizoonekana (z-bafa)
Kutumia splines kuunda mistari na nyuso
Uwekaji ramani ya muundo na utumiaji wa taa
Kuongeza athari maalum: ukungu, kubadilisha uwazi, kuchanganya rangi, kuondoa aliasing (anti-aliasing).
Kama ilivyoelezwa tayari, kuna utekelezaji wa OpenGL kwa majukwaa tofauti, ambayo ilikuwa rahisi kutenganisha kazi za msingi za mfumo wa picha na kazi za kuonyesha habari za picha na kuingiliana na mtumiaji. Maktaba ziliundwa kwa ajili ya kuonyesha habari kwa kutumia mfumo mdogo wa dirisha kwa mifumo ya uendeshaji ya Windows na Unix (WGL na GLX, mtawaliwa), pamoja na maktaba za GLAUX na GLUT, ambazo hutumiwa kuunda kinachojulikana kama programu za console.
Maktaba ya GLAUX ni duni kwa umaarufu kwa maktaba ya GLUT iliyoandikwa baadaye, ingawa hutoa takriban uwezo sawa. Maktaba ya GLU ni pamoja na utekelezaji wa kazi ngumu zaidi, kama vile seti ya primitives maarufu za kijiometri (mchemraba, mpira, silinda, diski), kazi za ujenzi wa splines, utekelezaji wa shughuli za ziada kwenye matrices, nk. Zote zinatekelezwa kupitia kazi za msingi za OpenGL.
Usanifu na sifa za syntax
Kwa mtazamo wa usanifu, mfumo wa michoro ya OpenGL ni bomba linalojumuisha hatua kadhaa za usindikaji wa data:
Ukadiriaji wa curves na nyuso
Usindikaji wa Vertex na mkusanyiko wa zamani
Rasterization na usindikaji wa vipande
Uendeshaji kwenye saizi
Kuandaa texture
Kuhamisha Data kwa Bafa ya Fremu
Kwa ujumla, OpenGL inaweza kulinganishwa na mashine ya serikali, hali ambayo imedhamiriwa na seti ya maadili ya vigezo maalum (majina yao kawaida huanza na wahusika GL_) na maadili ya kawaida ya sasa, rangi na. kuratibu texture. Habari hii yote itatumika wakati wa kuingia kwenye mfumo wa kuratibu wa vertex ili kuunda takwimu ambayo imejumuishwa. Mabadiliko ya hali hutokea kwa kutumia amri, ambazo hutolewa kama simu za kazi.
KUANZISHA MAKTABA YA OpenGL KATIKA C++
Kwanza kabisa, unahitaji kujumuisha faili za kichwa:
#pamoja na
#pamoja na
#pamoja na
· gl.h na glu.h vina vielelezo vya vitendaji vikuu vya OpenGL vilivyofafanuliwa katika opengl32.dll na glu32.dll.
· glaux.h ina vitendaji saidizi (glaux.dll).
Baada ya kuunganisha faili za kichwa, unahitaji kuweka umbizo la pixel. Kazi ifuatayo inatumika kwa kusudi hili:
BOOL bSetupPixelFormat(HDC hdc)
PIXELOFORMATDESCRIPTOR pfd, *ppfd;
muundo wa pixel wa int;
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
ppfd->nVersion = 1;
ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
ppfd->dwLayerMask = PFD_MAIN_PLANE;
ppfd->iPixelType = PFD_TYPE_RGBA;
ppfd->cColorBits = 16;
ppfd->cDepthBits = 16;
ppfd->cAccumBits = 0;
ppfd->cStencilBits = 0;
ikiwa ((pixelformat = ChaguaPixelFormat(hdc, ppfd)) == 0)
MessageBox(NULL, "ChoosePixelFormat imeshindwa", "Hitilafu", MB_OK);
ikiwa (SetPixelFormat(hdc, pixelformat, ppfd) == FALSE)
MessageBox(NULL, "SetPixelFormat imeshindwa", "Hitilafu", MB_OK);
Muundo wa PIXELFORMATDESCRIPTOR lazima usemwe.
cColorBits - kina cha rangi
cDepthBits - saizi ya bafa ya kina (Z-Buffer)
cStencilBits - saizi ya bafa ya stencil (bado hatuitumii)
iPixelType - umbizo la kubainisha rangi. Inaweza kuchukua maadili PFD_TYPE_RGBA (rangi inaonyeshwa na vigezo vinne vya RGBA - nyekundu, kijani, bluu na alpha) na PFD_TYPE_COLORINDEX (rangi inaonyeshwa na faharisi kwenye palette).
Chaguo za kukokotoa za SelectPixelFormat() huchagua umbizo la pikseli na kurudisha mpini wake, na SetPixelFormat() huiweka katika muktadha wa kifaa (dc).
Baada ya umbizo la pikseli kuwekwa katika muktadha wa kifaa, unahitaji kuunda muktadha wa uchezaji (Muktadha wa Utoaji) kwa hili, vitendakazi vifuatavyo vinafafanuliwa katika OpenGL:
HGLRC wglCreateContext(HDC hdc);
BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc);
Katika tamko la darasa la fomu, katika eneo la kibinafsi, unahitaji kuongeza yafuatayo:
ghRC - kielekezi kwa muktadha wa utoaji (Muktadha wa Utoaji)
ghDC ni kipini cha kifaa (kwetu sisi ni kielekezi kwa dirisha)
Utaratibu wa kuchora utawajibika kwa kuchora.
__fastcall TForm1::FormCreate batili (TObject *Mtumaji)
ghDC = GetDC(Hushughulikia);
ikiwa (!bSetupPixelFormat(ghDC))
ghRC = wglCreateContext(ghDC);
wglMakeCurrent(ghDC, ghRC);
glClearColor(0.0, 0.0, 0.0, 0.0);
FormResize(Mtumaji);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
kuelea p=(3,3,3,1),
glLightfv(GL_LIGHT0,GL_POSITION,p);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,d);
glViewport(0, 0, Upana, Urefu);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-5.5, -5.5, 2.12);
gluLookAt(0,0,5, 0,0,0, 0,1,0);
Modi ya glMatrix(GL_MODELVIEW);
glClearColor() huweka rangi ambayo itajaza skrini wakati wa kusafisha. Utaratibu huu una vigezo 4, ambavyo vinafanana na RGBA. Badala yake, unaweza kuandika glClearIndex(0.0) . Utaratibu huu unaweka index ya rangi katika palette.
glViewport() huweka eneo la pato - eneo ambalo OpenGL itatoa picha.
glMatrixMode() huweka hali ya matrix ya mabadiliko ya mwonekano.
glLoadIdentity() inachukua nafasi ya matrix ya mabadiliko ya mtazamo wa sasa na moja.
glOrtho() huweka hali ya makadirio ya orthogonal (mstatili). Hii inamaanisha kuwa picha itachorwa kama ilivyo kwenye isometria. Vigezo 6 vya aina ya GLdouble (au tu mara mbili): kushoto, kulia, chini, juu, karibu, mbali huamua kuratibu za ndege za kushoto, kulia, chini, juu, karibu na mbali, kwa mtiririko huo, i.e. kila kitu ambacho kiko nje ya mipaka hii hakitachorwa. Kwa kweli, utaratibu huu unaweka tu kiwango cha axes za kuratibu. Ili kuweka makadirio ya mtazamo, taratibu za glFrustum() na gluPerspective() hutumiwa.
gluLookAt() huweka vigezo vya kamera: tatu za kwanza ni kuratibu zake, pili ni vector ya mwelekeo, ya tatu ni mwelekeo wa mhimili wa Y.
Katika OpenGL, kila kitu huwashwa na kuzimwa (kuwashwa na kulemazwa) na taratibu za glEnable() na glDisable().
glLightfv() huweka sifa za "balbu za mwanga": nafasi na mwelekeo wa mwanga.
Mara tu unapomaliza kufanya kazi na OpenGL, unahitaji kuachilia rasilimali zilizochukuliwa kwa kukomboa muktadha kwa kupiga simu wglMakeCurrent na kigezo kisichofaa cha kitambulisho cha muktadha wa OpenGL na kuharibu muktadha huo na wglDeleteContext. Kwa kuongeza, unahitaji kuondoa kushughulikia ghDC. Kwa kuwa kazi na OpenGL kawaida huisha wakati programu inatoka, nambari inayolingana inahitaji kuwekwa katika FormClose:
__piga simu haraka TForm1::FomuClose(TObject *Sender, TCloseAction &Action)
wglMakeCurrent(ghDC,0);
wglDeleteContext(ghRC);
ReleaseDC(Handle, ghDC);
HITIMISHO
Wakati wa mafunzo yangu kutoka Julai 5 hadi Julai 31, 2011 katika JSC Transas, Kitengo cha Usafiri wa Anga katika idara ya programu, nilifahamu kazi ya idara ya programu. Nilifahamiana na muundo na utendakazi wa viigizaji changamano vya ndege vilivyotengenezwa katika JSC Transas. Nilijifunza kuhusu mfumo wa kuibua mandhari na vitu mbalimbali vinavyoitwa Aurora. Nilipata ujuzi wa awali wa vitendo na uwezo muhimu wa kuendeleza programu na programu kwa kutumia lugha ya kisasa ya programu na maktaba ya picha.
Tuma kazi yako nzuri katika msingi wa maarifa ni rahisi. Tumia fomu iliyo hapa chini
Wanafunzi, wanafunzi waliohitimu, wanasayansi wachanga wanaotumia msingi wa maarifa katika masomo na kazi zao watakushukuru sana.
Iliyotumwa kwenye http://www.allbest.ru/
OpenGL ni kiolesura cha programu kwa maunzi ya michoro. Kiolesura hiki kina takriban amri 250 tofauti (kama amri 200 katika OpenGL yenyewe na nyingine 50 kwenye maktaba ya matumizi) ambazo hutumiwa kubainisha vitu na utendakazi ambao lazima ufanyike ili kutoa programu shirikishi ya michoro ya 3D. opengl kiolesura cha programu cha picha
Maktaba ya OpenGL imeundwa kama kiolesura cha jumla na huru ambacho kinaweza kutekelezwa kwenye maunzi anuwai. Kwa sababu hii, OpenGL yenyewe haijumuishi vitendaji vya kuunda windows au kunasa ingizo la mtumiaji; Kwa shughuli hizi, lazima utumie zana za mfumo wa uendeshaji ambao unafanya kazi. Kwa sababu hizo hizo, OpenGL haina vitendaji vya hali ya juu vya kuelezea miundo ya vitu vya 3D. Amri kama hizo zinaweza kukusaidia kueleza maumbo changamano, kama vile magari, sehemu za mwili wa binadamu, au molekuli. Unapotumia maktaba ya OpenGL, lazima ujenge mifano muhimu kwa kutumia seti ndogo ya primitives ya kijiometri - pointi, mistari na polygons (polygons).
Walakini, maktaba ambayo hutoa uwezo ulioelezewa inaweza kujengwa juu ya OpenGL. Maktaba ya Utility ya OpenGL (GLU) hutoa zana nyingi za uundaji, kama vile nyuso za quadric, curve, na nyuso za NURBS. GLU ni sehemu ya kawaida ya utekelezaji wowote wa OpenGL. Pia kuna maktaba za kiwango cha juu, kama vile Fahrenheit Scene Graph (FSG), ambazo zimeundwa kwa kutumia OpenGL na kusambazwa kando kwa utekelezaji wake mwingi.
Orodha ifuatayo inaelezea kwa ufupi shughuli za msingi za michoro ambazo OpenGL hufanya ili kuonyesha picha kwenye skrini.
1. Huunda maumbo kutoka kwa primitives za kijiometri, kuunda maelezo ya hisabati ya vitu (primitives katika OpenGL ni pointi, mistari, polygoni, bitmaps na picha).
2. Huweka vitu katika nafasi ya pande tatu na kuchagua sehemu ya uchunguzi ili kutazama utunzi unaotokana.
3. Huhesabu rangi kwa vitu vyote. Rangi inaweza kuamua na programu, inayotokana na hali ya taa, iliyohesabiwa kwa kutumia textures kutumika kwa vitu, au mchanganyiko wowote wa mambo haya.
4. Hubadilisha maelezo ya hisabati ya vitu na maelezo ya rangi husika kuwa pikseli kwenye skrini. Utaratibu huu unaitwa rasterization (au rasterization).
Wakati wa hatua hizi zote, OpenGL inaweza kufanya shughuli zingine, kama vile kuondoa sehemu za vitu ambazo zimefichwa na vitu vingine. Kwa kuongezea hii, baada ya tukio kubadilishwa kwa njia mbaya lakini kabla ya kuonyeshwa kwenye skrini, unaweza kufanya shughuli kadhaa kwenye data ya pixel ikiwa ni lazima.
Utaratibu wa jumla wa kufanya kazi na maktaba ya OpenGl ni kama ifuatavyo.
1. Anzisha dirisha (pata eneo la kuonyesha picha)
2. Weka kamera
3. Washa taa (ikiwa ni lazima)
4. Katika kitanzi, anza kuchora primitives (pointi, mistari, polygons), kwanza kufuta dirisha kutoka kwa mchoro uliopita.
Kuanzisha dirisha.
Ikiwa unafanya kazi katika Visual C ++, basi dirisha linaundwa kwa kutumia kazi
auxInitDisplayMode
Kitanzi kikuu cha kuchora sura kinaundwa katika kazi ya Chora na kusajiliwa kwa kutumia kazi
auxMainLoop(Chora);
tuli utupu CALLBACK Chora(batili) // iliyoundwa na mtumiaji
// nafasi ya dirisha la OpenGL kwenye skrini
auxInitPosition(100, 100, windowW, windowH);
// kuweka vigezo vya msingi vya uendeshaji wa OpenGL
// Hali ya rangi ya RGB | kuwezesha Z-bafa kwa upangaji wa kina
// |Kuakibisha mara mbili
auxInitDisplayMode(AUX_RGB | AUX_DEPTH | AUX_DOUBLE);
// anzisha dirisha la OpenGL na Kichwa
if(auxInitWindow("Mfano1") ==GL_FALSE) auxQuit();
// sajili kazi ambayo inaitwa wakati wa kuchora upya
// na anza kitanzi cha tukio
// Chora () - kazi ya mtumiaji
auxMainLoop(Chora);
Ikiwa unafanya kazi katika Mjenzi wa Borland C++, basi ili kuanzisha dirisha, unahitaji kupata Handle (kitambulisho cha kipekee cha Windows) cha dirisha ambalo utachora. Handle inapatikana katika madirisha yote ya programu ya kiwango cha juu na katika madirisha mengi ya watoto. Katika mifano yetu tutachora kwenye dirisha la mtoto la StaticText.
Ifuatayo tunahitaji kuunda Muktadha wa Kuchora (muktadha wa kifaa) na kuweka muundo wake. Ili kufanya hivyo, muundo wa PIXELFORMATDESCRIPTOR (muundo wa maelezo ya pixel) umeanzishwa. Muundo huu unafafanua kama tunahitaji usaidizi wa bafa ya kina, uakibishaji maradufu, n.k.).
Kisha fuata kazi:
ChaguaPixelFormat
Muktadha wa kuchora OpenGL umeundwa:
wglCreateContext(hdc);
Na kisha muktadha wa OpenGL na Windows umeunganishwa:
wglMakeCurrent(hdc, hrc)
__fastcall TFormMain batili::FormCreate(TObject *Sender)
// chukua HANDLE ya dirisha la StaticText
Kishikio tuli cha HWND=a->Kishiko;
// unda kipini cha mahali pa kuchora kwa dirisha la StaticText
hdc = GetDC(Hushughulikia);
// weka mipangilio inayofaa ya muktadha wa kifaa
PIXELFORMATDESCRIPTOR pfd = (
saizi ya(PIXELFORMATDESCRIPTOR),
PFD_CHORA_DIRISHA | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
// chagua muundo unaofaa
PixelFormat = ChaguaPixelFormat(hdc, &pfd);
SetPixelFormat(hdc, PixelFormat, &pfd);
// unda muktadha wa kifaa kwa OpenGL
// kwa kutumia Kishikio cha Mahali pa Kuchora
hrc = wglCreateContext(hdc);
ShowMessage(":-)~ hrc == NULL");
if(wglMakeCurrent(hdc, hrc) == uongo)
ShowMessage("Haikuweza KufanyaCurrent");
Ufungaji wa Kamera
Kwa chaguo-msingi, kamera imewekwa kwenye asili (0, 0, 0), iliyoelekezwa kando ya mwelekeo hasi wa mhimili z, na vekta ya mwelekeo wa juu ni (0, 1, 0).
Ili kufunga kamera, ni rahisi kutumia kazi ya gluLookAt (). Ingawa ina vigezo 9, ni rahisi kuelewa. Wao umegawanywa katika vigezo vitatu, kwa mtiririko huo kwa pointi tatu: Jicho (Jicho), Kituo, Juu.
Jicho huamua hatua ambayo tunaangalia, Kituo huamua mahali tunapoangalia, na vector ya juu huamua wapi tunapaswa kuwa na juu (fikiria rubani katika ndege akiruka kichwa chini). Ni rahisi kuambatanisha vekta katika madarasa na shughuli zilizobatilishwa.
gluLookAt(e.x,e.y,e.z, c.x,c.y,c.z, u.x,u.y,u.z);
Kitanzi kikuu kinajumuisha hatua zifuatazo za kuchora sura:
1. Kufuta vihifadhi kutoka kwa kuchora picha iliyotangulia
2. Kazi za kuchora primitives
3. Kazi za kumaliza kuchora na kusubiri jibu kutoka kwa kadi ya video
4. Kazi za kunakili picha kutoka kwa kumbukumbu hadi skrini
Kitanzi kikuu hakijumuishi matukio ya kushughulikia kama vile mibonyezo ya vitufe na kubadilisha ukubwa wa dirisha. Ili kuchakata matukio, vipengee tofauti vinaundwa na kuambatanishwa zaidi na programu.
Ikiwa unafanya kazi katika Visual C, basi hii inafanywa kwa kutumia vitendakazi ambavyo prototypes zao zimefafanuliwa kwenye faili ya glaux.h:
auxReshapeFunc()
Ikiwa unafanya kazi katika Borland C, basi usindikaji wa tukio unafanywa kwa njia ya jadi kwa wale walioundwa na mazingira ya programu hii: unachagua tu sehemu (kwa mfano, Button1), unda kidhibiti (kwa mfano, vyombo vya habari muhimu) na ndani. kuelezea mwili wa kazi.
Kuchora primitives
Kuchora maandishi ya awali hufanywa kwa amri za glBegin() na glEnd().
Kupitisha mara kwa mara kwa kazi ya glBegin huamua aina ya primitive ambayo itachorwa
Kuratibu za pointi zinatajwa na vector ya anga ya tatu-dimensional. Rangi zinatajwa na vigezo vitatu (RGB) au vinne (RGBA). Katika mfano wetu, thamani ya sehemu ya rangi ya kila rangi inaweza kutofautishwa kutoka 0 hadi 1. Ikiwa umezoea thamani ya sehemu ya rangi kutoka 0 hadi 255 (MsPaint), basi tumia glColor3ub(255,0,0). ) kazi. Kiambishi ub kinamaanisha baiti ambayo haijasainiwa.
Taa katika Picha za Kompyuta ina vipengele 3
Mionzi ya asili ni mwanga ambayo inasambazwa sana na mazingira (vitu, kuta, nk) kwamba mwelekeo wake hauwezi kuamua - inaonekana kutoka kila mahali. Taa ya fluorescent ina sehemu kubwa ya mandharinyuma kwa sababu mwanga mwingi unaofika kwenye jicho lako huonyeshwa kwanza kutoka kwenye nyuso nyingi. Taa ya barabarani ina kipengele kidogo cha mandharinyuma: sehemu kubwa ya mwanga wake huja upande mmoja, na kwa kuwa iko nje, mwanga mdogo sana hugusa jicho lako baada ya kudondosha vitu vingine. Nuru ya usuli inapogusa uso, inasambazwa kwa usawa katika pande zote.
Sehemu inayoeneza ni mwanga unaotoka upande mmoja, kwa hivyo inaonekana kung'aa zaidi ikiwa inagonga uso kwenye pembe za kulia, na inaonekana kuwa hafifu ikiwa inaigusa kwa muda mfupi tu. Walakini, inapogonga uso, inasambazwa kwa usawa katika pande zote, ikimaanisha kuwa mwangaza wake ni sawa bila kujali ni njia gani unatazama uso. Kuna uwezekano kwamba nuru yoyote inayotoka kwa mwelekeo au nafasi fulani ina sehemu ya kuenea.
Nuru maalum hutoka kwa mwelekeo maalum na huakisi kutoka kwa uso katika mwelekeo maalum. Wakati boriti ya laser inayozingatia vizuri inaonekana kutoka kwa kioo cha ubora wa juu, karibu asilimia 100 ya kutafakari maalum hutokea. Metali inayong'aa au plastiki ina sehemu ya juu ya kipekee, lakini kipande cha carpet au toy ya kifahari haina. Unaweza kufikiria ubashiri kama jinsi nyenzo inavyong'aa.
Kando na mandharinyuma, mtawanyiko, na rangi maalum, nyenzo pia zinaweza kuwa na rangi isiyo na moshi inayoiga mwanga unaotoka kwenye kitu chenyewe. Katika muundo wa taa wa OpenGL, mwanga wa uso unaotoka huongeza nguvu kwa kitu, lakini hauathiriwi na vyanzo vyovyote vya mwanga na hautoi mwanga wa ziada kwenye eneo kwa ujumla.
Ingawa chanzo cha mwanga hutoa usambazaji mmoja wa masafa, mandharinyuma, mtawanyiko na vijenzi maalum vinaweza kuwa tofauti. Kwa mfano, ikiwa chumba chako kina kuta nyekundu na mwanga nyeupe, basi mwanga huu unaoonekana kutoka kwa kuta utakuwa nyekundu zaidi kuliko nyeupe (licha ya ukweli kwamba mwanga unaoanguka kwenye ukuta ni nyeupe). OpenGL hukuruhusu kuweka thamani nyekundu, kijani kibichi na samawati kwa kujitegemea kwa kila kipengele cha mwanga.
Amri zinazotumiwa kuweka nyenzo ni:
// matukio ya mwanga na nyenzo
// Washa chanzo cha nuru nambari sifuri
glEnable(GL_LIGHT0);
// weka nafasi na vipengele vya rangi ya chanzo cha mwanga
glLightfv(GL_LIGHT0, GL_POSITION, LL.pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, LL.amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, LL.dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, LL.spec);
// wezesha hali ya kivuli / taa
glEnable(GL_LIGHTING);
// weka vigezo vya nyenzo za kitu
// kwenye nyuso za mbele --- GL_FRONT kwa zile za nyuma GL_BACK kwa zote mbili - GL_FRONT_AND_BACK
// parameter ya pili - ni sehemu gani ya nyenzo
// inawezekana GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS
// sawia ILIYOGAIWA, ILIYOTAFAKARI, KIOO, KUJITUMIA, kiashirio mahususi cha mwali
glMaterialfv(GL_FRONT,GL_AMBIENT,MM.amb);
glMaterialfv(GL_FRONT,GL_DIFFUSE,MM.dif);
glMaterialfv(GL_FRONT,GL_SPECULAR,MM.spec);
glMaterialf(GL_FRONT,GL_SHININESS,MM.pos);
glNormal3f(0,0,1);
glAnza(GL_QUADS);
kwa(i=-10; i<20;i++)
kwa(j=-10;j<20;j++)
glVertex3f(i,j,0);
glVertex3f(i+1,j,0);
glVertex3f(i+1,j+1,0);
glVertex3f(i,j+1,0);
Hitimisho
Mfumo wa OpenGL ni kiolesura chenye kunyumbulika cha kiutaratibu ambacho humruhusu mpangaji programu kuunda programu mbalimbali kwa kutumia michoro ya pande tatu. Kiwango hicho hakina kanuni za kuelezea muundo wa vitu vya picha; umakini mkubwa hulipwa kuelezea mchakato wa taswira yao. Shukrani kwa hili, ufanisi wa vifaa vilivyopo huongezeka: kutoka kwa vifaa rahisi vinavyotumia tu buffer ya sura hadi mifumo ya kisasa ya graphics yenye uwezo wa kutoa vitu vya tatu-dimensional kwenye ngazi ya vifaa. OpenGL hutoa tu uwezo wa kutoa picha; shirika la pembejeo limeachwa kwa mfumo maalum wa dirisha, ambayo inaruhusu uhuru wa ziada wa vifaa vya programu.
Kwa sababu ya utumizi mdogo wa miundo changamano kwa kuwakilisha vitu vyenye sura tatu, inawezekana kutumia OpenGL kama msingi wa kujenga maktaba za kudhibiti vitu vilivyoundwa. Mifano ya maktaba kama hizi ni pamoja na vifurushi vya zana zenye mwelekeo wa kitu zinazotumika kuibua na kuiga miundo changamano ya picha.
Iliyotumwa kwenye Allbest.ru
Nyaraka zinazofanana
Msimbo wa OpenGL. Sintaksia ya amri ya OpenGL. OpenGL kama mashine ya serikali. Bomba la uwasilishaji la OpenGL. Maktaba zinazohusiana na OpenGL. Maktaba ya OpenGL. Faili zilizojumuishwa. GLUT, zana ya huduma za maktaba ya OpenGL.
kazi ya kozi, imeongezwa 06/01/2004
Kupanga programu kwa kutumia maktaba ya OpenGL na vitendaji vya kuchora vitu vya kijiometri. Ukuzaji wa utaratibu wa kuibua eneo la pande tatu na kiolesura cha mtumiaji. Muundo wa kimantiki na mtengano wa kazi wa mradi.
kazi ya kozi, imeongezwa 06/23/2011
Kufahamiana na kiolesura, huduma kuu na faida za kutumia programu ya OpenGL - maktaba maarufu ya kufanya kazi na picha za 2D na 3D. Kuzingatia madhumuni, vipengele vya msingi na sheria za uanzishaji wa injini ya programu ya DirectX.
wasilisho, limeongezwa 08/14/2013
Kuunda programu katika C++ kwa kutumia maktaba ya michoro ya OpenGL katika Microsoft Visual Studio. Ujenzi wa picha ya nguvu ya mfano wa tatu-dimensional wa kitu cha "Jukwaa la Mafuta". Muundo wa kimantiki na mtengano wa kazi wa mradi.
kazi ya kozi, imeongezwa 06/23/2011
Kiini cha programu kwa kutumia maktaba ya OpenGL, madhumuni yake, usanifu, faida na uwezo wa msingi. Ukuzaji wa programu ya kuunda taswira ya nguvu ya mfano wa pande tatu wa kitu cha Kompyuta, mwongozo wa mtumiaji.
kazi ya kozi, imeongezwa 06/22/2011
Kufanya kazi na rangi kwa kutumia maktaba ya michoro ya OpenGL. Mpango unaoonyesha mraba na rangi inayobadilika kulingana na mabadiliko ya gradients (R, G, B), pembetatu, wima ambayo ina rangi tofauti, ukanda wa mstatili kwa namna ya wigo.
mtihani, umeongezwa 01/21/2011
Madhumuni na viwango vya utekelezaji wa OpenGL kwa Windows, utaratibu wa kuunganisha maktaba ya michoro. Kazi za msingi na syntax ya amri. Kuchora primitives, aina na mabadiliko affine. Uundaji wa violwa vya picha zenye pande mbili na uhuishaji.
kazi ya maabara, imeongezwa 07/04/2009
Misingi ya programu kwa kutumia maktaba ya OpenGL. Maombi ya kuunda picha inayobadilika ya mfano wa kitu cha Bathyscaphe: ukuzaji wa utaratibu wa kuibua mchoro wa pande tatu, kiolesura cha mtumiaji na mfumo mdogo wa usimamizi wa hafla.
kazi ya kozi, imeongezwa 06/26/2011
Kuelewa nyanja hiyo ya vikoristannya trivimirnoy graphics. Maelezo ya uwezo wa maktaba ya OpenGL. Maelezo ya kina ya kiolesura cha programu cha Borland C++, orodha ya programu zinazoonyesha uwezo wake. Mradi wa Rozrakhunok vitrat na vikonannya.
tasnifu, imeongezwa 06/24/2015
Ukuzaji wa kijenzi cha hesabu za hisabati (operesheni kwenye matrices) kwa kutumia teknolojia ya OpenGL (kuongeza, kutoa, kuzidisha, kubadilisha, kiashiria, tumbo kinyume). Ujuzi wa kimsingi katika kufanya kazi na teknolojia katika mazingira ya .Net.
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 viendeshi vya hivi punde vya 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 kiotomatiki, jaribu kusoma mwongozo wa Ubuntu.
- Sakinisha mkusanyaji na maktaba na zana zote muhimu. 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, faili zilizokamilishwa za kutekelezwa zitawekwa 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 unamu 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. Ninarudia mara nyingine tena, usisome tu msimbo uliomalizika, lakini jaribu kuiendesha. 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
Hatuhitaji maktaba hii kwa hatua 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 kuwa 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");
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 kusimamia kazi za OpenGL kwa kutumia mfano wa maombi rahisi ya aina ya console, na tu baada ya hapo tutaanza kuendeleza programu ya Windows.
Msomaji pengine anajua kwamba OpenGL ni maktaba ya michoro ya utendaji bora na aina ya data iliyoboreshwa, yenye utendaji wa juu kwa ajili ya kuonyesha michoro ya pande mbili na tatu. 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 anazungumza Kiingereza, tunapendekeza kuisoma.
Maktaba Zilizounganishwa
Utekelezaji wa Microsoft wa OpenGL unajumuisha seti kamili ya amri za OpenGL, yaani, vitendaji vya kimataifa vilivyojumuishwa 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 hukuruhusu kuunda madirisha ya Windows kwa njia rahisi, kuonyesha baadhi ya vitu vya SD, kushughulikia matukio ya ingizo na kudhibiti mchakato wa usuli. Kwa bahati mbaya, maktaba hii haijarekodiwa. Microsoft haipendekezi kuitumia kwa ajili ya kuendeleza miradi ya kibiashara, kwa kuwa ina msimbo wa kitanzi 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 pikseli na uakibishaji mara mbili. Zinatumika tu kwa madirisha maalum ya OpenGL.
OpenGL hubatilisha aina za kawaida, ikiwa ni pamoja na zilizojengewa ndani. Hii inafanywa kwa kubebeka kwa msimbo wa programu kwa majukwaa mengine. Kimsingi, hakuna chochote ngumu kukumbuka aina hizi na maana zao.
Kwa mfano, aina ya GLint inalingana na int ya kawaida:
typedef int GLint;sawa:
typedef ambayo haijasainiwa int GLuint; typedef kuelea GLfloat; typedef mara mbili GLdouble; typedef batili GLvoid;
Aina hizi zimetangazwa katika GL.h. Majina ya aina hizi zote huanza na GL. Inapendekezwa kutumia aina hizi na kazi za OpenGL.
Vitendaji vya OpenGL
Kazi nyingi za OpenGL ni tofauti za kila mmoja, zinazotofautiana tu katika aina za data na hoja zao. Bila shaka, hii haingefanyika ikiwa OpenGL awali ilikuwa imeundwa kwa lugha ambazo ziliauni upakiaji wa utendakazi, kama vile C++.
Ili kuepuka mkanganyiko katika majina ya kazi, tumeanzisha kanuni (sheria) kadhaa ambazo jina la kazi ya OpenGL hujengwa.
Kwanza, majina yote ya kazi ya OpenGL huanza na kiambishi awali gl. Kwa mfano,
GlBegin();
glEng();
Pili, ikiwa seti ya kazi ina maana sawa na inatofautiana tu kwa idadi na aina ya vigezo, basi jina la kazi kama hizo limeandikwa kwa fomu:
GlCommon_sehemu_ya_jina_la_kazi[n],
ambapo n ni idadi ya vigezo, aina ni aina ya vigezo.
Kwa mfano:
glVertex2d(1 .0 , 0 .5); // 2d ina maana: 2 vigezo vya aina GLdouble glVertex3f(1 .0 f, 0 .5 f, 0 .0 f); // 3f ina maana: vigezo 3 vya GLfloat glColor3ub(127, 0, 255); // 3ub ina maana: vigezo 3 vya aina ya GLubyte
Jedwali hapa chini linaonyesha maana ya vifupisho vya aina:
| i | GLint |
| ui | GLuint |
| f | GLfloat |
| d | GLdouble |
| s | GLfupi |
| sisi | GLushort |
| b | GLbyte |
| ub | GLubyte |
| v | safu |
Katika nyaraka mbalimbali za OpenGL, ili sio kuorodhesha kazi zote za familia moja, ni desturi kuandika tu jina la sehemu ya kawaida ya kazi zote za familia na kuweka nyota "*" mwishoni. Kwa mfano, vitendaji vinavyobainisha viwianishi vya wima vimeandikwa kama hii:
GlVertex*
Maelezo zaidi kuhusu OpenGL
Amri za OpenGL zinafasiriwa na modeli ya mteja/seva.
Nambari ya maombi (mteja) hutoa amri ambazo zinatafsiriwa na kuchakatwa.
OpenGL (seva) inaweza au isifanye kazi kwenye kompyuta kama mteja. Seva inaweza kuwa na miktadha mingi ya OpenGL. Mteja anaweza kuunganisha kwa yoyote ya muktadha huu.
Mfumo wa dirisha hutenga bafa ya fremu. Huamua ni kiasi gani cha buffer ya muundo kinaweza kufikiwa na OpenGL kwa wakati fulani, na huiambia OpenGL jinsi vipande hivyo vimeundwa. Kwa hivyo, OpenGL haina amri zinazosanidi fremu au kuanzisha OpenGL.
Maktaba za ziada
Mbali na kazi za OpenGL na kazi zinazotolewa na mfumo wa uendeshaji, maktaba za ziada hutumiwa mara nyingi kufanya kazi na OpenGL.
Maktaba hazianzishi vipengele vipya kwa OpenGL yenyewe. Kusudi lao ni kurahisisha msimbo. Maktaba huondoa hitaji la watengeneza programu kuandika kazi zinazotumiwa mara kwa mara.
Inashauriwa kutumia maktaba ya ziada kwa tahadhari kali. Matatizo yanaweza kutokea wakati wa kuhamisha nambari yako hadi kwa jukwaa lingine. Kawaida hutumiwa kwa programu ndogo na za majaribio. Katika miradi mikubwa, maktaba hizi zimeachwa, na kuacha upendeleo kwa OpenGL safi.
Maktaba maarufu zaidi:
Maktaba ya Huduma ya OpenGL (glu)
Maktaba ya matumizi ya glu hutoa kazi zinazofanya kazi na matrices, mifumo ya kuratibu, curves na nyuso za NURBS, nk.
Maktaba hii inakuja na takriban utekelezaji wote wa OpenGL, haswa MS Visual C++.
Ili kuitumia, unahitaji kujumuisha faili ya kichwa cha glu.h kwenye faili chanzo:
#pamoja nana ujumuishe maktaba tuli glu32.lib katika mradi wako wa kuunganisha.
Majina ya kazi katika maktaba hii ya matumizi huanza na glu, kwa mfano,
GluPerspective();
Maktaba Msaidizi ya OpenGL (glaux)
Maktaba ya usaidizi ya glaux ina vitendaji ambavyo huunda vitu rahisi vya jiometri ya pande tatu, kama vile duara, mchemraba, parallelepiped, silinda, koni, n.k., vitendaji vinavyopakia picha kutoka kwa faili, vitendaji vinavyofanya kazi na dirisha la kutoa picha, n.k.
Maktaba hii haitumiki sana na utendakazi haujajumuishwa kwenye MSDN. Faili za kufanya kazi na maktaba pia hutolewa na MS Visual C++.
Ili kuitumia, unahitaji kujumuisha faili ya kichwa cha glaux.h kwenye faili chanzo:
#pamoja nana ujumuishe maktaba tuli glaux.lib katika mradi wako wa kuunganisha.
Majina ya kazi katika maktaba hii ya matumizi huanza na aux, kwa mfano,
AuxSolidCube();
Zana ya Utility ya OpenGL (GLUT)
Zana inayojitegemea ya mfumo wa uendeshaji wa dirisha kwa ajili ya kuunda programu za OpenGL. Hutoa utekelezaji rahisi wa kiolesura cha dirisha. Maktaba hii huachilia programu kutoka kwa maandalizi ya uanzishaji, inaweza kutoa vitu vya kijiometri, nk.
Ili kuitumia, unahitaji kujumuisha faili ya kichwa cha glut.h kwenye faili chanzo na ujumuishe maktaba tuli ya glut32.lib katika mradi wako wa kuunganisha.
Kwa kuongeza, lazima uwe na maktaba ya kiungo chenye nguvu glut32.dll.
