OpenGL-നെ പരിചയപ്പെടാൻ, നിങ്ങൾ OpenGL എന്ന വസ്തുതയിൽ നിന്ന് ആരംഭിക്കേണ്ടതുണ്ട് സ്പെസിഫിക്കേഷൻ. ആ. ഓപ്പൺജിഎൽ ആവശ്യമായ കഴിവുകളുടെ ഒരു കൂട്ടം നിർവചിക്കുന്നു. നടപ്പാക്കൽ നിർദ്ദിഷ്ട പ്ലാറ്റ്ഫോമിനെ ആശ്രയിച്ചിരിക്കുന്നു.
OpenGL ക്രോസ്-പ്ലാറ്റ്‌ഫോമാണ്, ഭാഷ സ്വതന്ത്രമാണ് API പ്രോഗ്രാമിംഗ്ഗ്രാഫിക്സിൽ പ്രവർത്തിക്കുന്നതിന്. ഓപ്പൺജിഎൽ ഒരു ലോ-ലെവൽ API ആണ്, അതിനാൽ ഗ്രാഫിക്‌സിനെ കുറിച്ച് പൊതുവായും ചില അടിസ്ഥാന ലീനിയർ ആൾജിബ്രയുമായി പ്രവർത്തിക്കാൻ ചില ധാരണകളും ഉണ്ടായിരിക്കുന്നത് നല്ലതാണ്.

പേരിടൽ

ഓപ്പൺജിഎല്ലിൽ ഫംഗ്‌ഷനുകൾക്ക് പേരിടുന്നതിനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ പറയാം. ആദ്യം, OpenGL നേരിട്ട് നൽകുന്ന എല്ലാ ഫംഗ്‌ഷനുകളുടെയും പേരുകൾ പ്രിഫിക്‌സിൽ ആരംഭിക്കുന്നു gl. രണ്ടാമതായി, ഒരു കൂട്ടം സംഖ്യകൾ (ഉദാഹരണത്തിന്, ഒരു കോർഡിനേറ്റ് അല്ലെങ്കിൽ നിറം) സ്വഭാവമുള്ള ഒരു നിശ്ചിത പാരാമീറ്റർ വ്യക്തമാക്കുന്ന ഫംഗ്‌ഷനുകൾക്ക് ഫോമിന്റെ ഒരു പ്രത്യയം ഉണ്ട് [പാരാമീറ്ററുകളുടെ എണ്ണം + പാരാമീറ്ററുകളുടെ തരം + പാരാമീറ്ററുകളുടെ പ്രാതിനിധ്യം].

• പാരാമീറ്ററുകളുടെ എണ്ണം - അംഗീകരിച്ച പരാമീറ്ററുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു. സ്വീകരിക്കുന്നു ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ: 1 , 2 , 3 , 4
• പാരാമീറ്റർ തരം - സ്വീകരിച്ച പരാമീറ്ററുകളുടെ തരം സൂചിപ്പിക്കുന്നു. ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ സാധ്യമാണ്: ബി, എസ്, ഐ, എഫ്, ഡി, ub, ഞങ്ങളെ, ui. ആ. ബൈറ്റ് (C-ലെ ചാർ, 8-ബിറ്റ് പൂർണ്ണസംഖ്യ), ഹ്രസ്വ (16-ബിറ്റ് പൂർണ്ണസംഖ്യ), ഇന്റർ (32-ബിറ്റ് പൂർണ്ണസംഖ്യ), ഫ്ലോട്ട് (ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ), ഇരട്ട (ഡബിൾ പ്രിസിഷൻ ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ), ഒപ്പിടാത്ത ബൈറ്റ്, ഒപ്പിടാത്ത ഷോർട്ട്, ഒപ്പിടാത്ത സംഖ്യ (അവസാനത്തെ മൂന്നെണ്ണം ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യകളാണ്)
• പാരാമീറ്റർ പ്രാതിനിധ്യം - പാരാമീറ്ററുകൾ ഏത് രൂപത്തിലാണ് കടന്നുപോകുന്നതെന്ന് സൂചിപ്പിക്കുന്നു; ഓരോ നമ്പറും വ്യക്തിഗതമാണെങ്കിൽ, ഒന്നും എഴുതില്ല; പരാമീറ്ററുകൾ ഒരു അറേ ആയി നൽകിയാൽ, ഫംഗ്ഷൻ നാമത്തിൽ ഒരു അക്ഷരം ചേർക്കും. വി

ഉദാഹരണം: glVertex3ivഒരു അറേയിലേക്ക് ഒരു പോയിന്ററായി പാസ്സാക്കിയ മൂന്ന് പൂർണ്ണസംഖ്യകൾ അടങ്ങുന്ന വെർട്ടെക്സ് കോർഡിനേറ്റ് വ്യക്തമാക്കുന്നു.

ഗ്രാഫിക് ആർട്ട്സ്

എല്ലാം ഗ്രാഫിക് വസ്തുക്കൾ OpenGL-ൽ അവ പോയിന്റുകളുടെയും വരികളുടെയും ബഹുഭുജങ്ങളുടെയും ഒരു ശേഖരമാണ്. എല്ലാ വസ്തുക്കളും നിർമ്മിച്ചിരിക്കുന്ന 10 വ്യത്യസ്ത പ്രാകൃതങ്ങളുണ്ട്. ദ്വിമാനവും ത്രിമാനവും. എല്ലാ പ്രാകൃതങ്ങളും, അതാകട്ടെ, പോയിന്റുകളാൽ വ്യക്തമാക്കുന്നു - ലംബങ്ങൾ.

• GL_POINTS- ഓരോ ശീർഷകവും ഒരു പോയിന്റ് നിർവചിക്കുന്നു
• GL_LINES- ഓരോ ജോഡി ലംബങ്ങളും ഒരു വരി നിർവചിക്കുന്നു
• GL_LINE_STRIP- ഓരോ ജോടി ലംബങ്ങളും ഒരു വരിയെ നിർവചിക്കുന്നു (അതായത്, മുമ്പത്തെ വരിയുടെ അവസാനം അടുത്തതിന്റെ തുടക്കമാണ്)
• GL_LINE_LOOP- മുമ്പത്തേതിന് സമാനമായത്, അവസാനത്തെ ശീർഷകം ആദ്യത്തേതുമായി ബന്ധിപ്പിച്ച് ഒരു അടച്ച ചിത്രം ലഭിക്കുന്നു എന്നതൊഴിച്ചാൽ
• GL_TRIANGLES- ഓരോ ട്രിപ്പിൾ ശീർഷങ്ങളും ഒരു ത്രികോണത്തെ നിർവചിക്കുന്നു
• GL_TRIANGLE_STRIP- ഓരോ അടുത്ത ശീർഷകവും മുമ്പത്തെ രണ്ട് ത്രികോണങ്ങളുമായി ചേർന്ന് ഒരു ത്രികോണത്തെ നിർവചിക്കുന്നു (അത് മാറുന്നു റിബൺത്രികോണങ്ങളിൽ നിന്ന്)
• GL_TRIANGLE_FAN- ഓരോ ത്രികോണവും നിർവചിച്ചിരിക്കുന്നത് ആദ്യത്തെ ശീർഷവും തുടർന്നുള്ള ജോഡികളുമാണ് (അതായത്, ത്രികോണങ്ങൾ ആദ്യത്തെ ശീർഷത്തിന് ചുറ്റും നിർമ്മിച്ചിരിക്കുന്നത്, ഒരു ഡയഫ്രം പോലെയുള്ള ഒന്ന് ഉണ്ടാക്കുന്നു)
• GL_QUADS- ഓരോ നാല് ലംബങ്ങളും ഒരു ചതുർഭുജം ഉണ്ടാക്കുന്നു
• GL_QUAD_STRIP- ഓരോന്നും അടുത്ത ജോഡിശീർഷങ്ങൾ മുമ്പത്തെ ഒരു ജോഡിയുമായി ചേർന്ന് ഒരു ചതുർഭുജം ഉണ്ടാക്കുന്നു
• GL_POLYGON- നൽകിയിരിക്കുന്ന ലംബങ്ങളുടെ എണ്ണത്തിന് തുല്യമായ കോണുകളുടെ എണ്ണമുള്ള ഒരു ബഹുഭുജത്തെ നിർവചിക്കുന്നു

ഒരു പ്രാകൃതം നിർവ്വചിക്കുന്നതിന്, നിർമ്മാണം ഉപയോഗിക്കുക glBegin(primitive_type)...glEnd(). ലംബങ്ങൾ വ്യക്തമാക്കിയിട്ടുണ്ട് glVertex*. ലംബങ്ങൾ എതിർ ഘടികാരദിശയിൽ സജ്ജീകരിച്ചിരിക്കുന്നു. വിൻഡോയുടെ മുകളിൽ ഇടത് കോണിൽ നിന്നാണ് കോർഡിനേറ്റുകൾ സജ്ജീകരിച്ചിരിക്കുന്നത്. കമാൻഡ് അനുസരിച്ചാണ് വെർട്ടെക്സ് നിറം സജ്ജീകരിച്ചിരിക്കുന്നത് glColor*. RGB അല്ലെങ്കിൽ RGBA ആയി നിറം വ്യക്തമാക്കിയിരിക്കുന്നു. മറ്റൊരു glColor* കമാൻഡ് നേരിടുന്നതുവരെ glColor* കമാൻഡ് അതിന് ശേഷം വരുന്ന എല്ലാ വെർട്ടിസുകളിലും അല്ലെങ്കിൽ മറ്റ് glColor* കമാൻഡുകൾ ഇല്ലെങ്കിൽ എല്ലാ വെർട്ടീസുകളിലും പ്രവർത്തിക്കുന്നു.
വ്യത്യസ്‌ത നിറങ്ങളുള്ള ഒരു ചതുരം വരയ്ക്കുന്ന കോഡ് ഇതാ:

1. ആരംഭിക്കുക (GL_QUADS) ;
2. glVertex2i(250, 450);
3. glVertex2i(250, 150);
4. glVertex2i(550, 150) ;
5. glVertex2i(550, 450) ;
6. glEnd();

ഓപ്പൺജിഎൽ പ്രോഗ്രാം അടിസ്ഥാനങ്ങൾ

വിൻഡോകൾക്കൊപ്പം പ്ലാറ്റ്ഫോം-സ്വതന്ത്ര പ്രവർത്തനത്തിന്, നിങ്ങൾക്ക് ഉപയോഗിക്കാം. GLUT OpenGL-നൊപ്പം പ്രവർത്തിക്കുന്നത് എളുപ്പമാക്കുന്നു.
പ്രോഗ്രാമിന്റെ തുടക്കത്തിൽ GLUT ആരംഭിക്കുന്നതിന് നിങ്ങൾ വിളിക്കേണ്ടതുണ്ട് glutInit(&argc, argv). ഡിസ്പ്ലേ മോഡ് സജ്ജമാക്കാൻ, വിളിക്കുക glutInitDisplayMode(മോഡ്), മോഡിന് ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ എടുക്കാം:

• GLUT_RGBA- നാല് ഘടകങ്ങളുടെ നിറം ഉൾപ്പെടുന്നു (സ്ഥിരസ്ഥിതി)
• GLUT_RGB- GLUT_RGBA പോലെ തന്നെ
• GLUT_INDEX- സൂചികയിലുള്ള നിറം ഉൾപ്പെടുന്നു
• GLUT_DOUBLE- ഇരട്ട സ്‌ക്രീൻ ബഫർ പ്രവർത്തനക്ഷമമാക്കുന്നു
• GLUT_SINGLE- സിംഗിൾ സ്‌ക്രീൻ ബഫർ പ്രവർത്തനക്ഷമമാക്കുന്നു (സ്ഥിരസ്ഥിതി)
• GLUT_DEPTH- Z-ബഫർ പ്രവർത്തനക്ഷമമാക്കുന്നു (ഡെപ്ത് ബഫർ)
• GLUT_STENCIL- സ്റ്റെൻസിൽ ബഫർ ഉൾപ്പെടുന്നു
• GLUT_ACCUM- അക്യുമുലേഷൻ ബഫർ പ്രവർത്തനക്ഷമമാക്കുന്നു
• GLUT_ALPHA- ആൽഫ മിശ്രിതം (സുതാര്യത) പ്രാപ്തമാക്കുന്നു
• GLUT_MULTISAMPLE- മൾട്ടിസാംപ്ലിംഗ് (ആന്റി-അലിയാസിംഗ്) പ്രവർത്തനക്ഷമമാക്കുന്നു
• GLUT_STEREO- സ്റ്റീരിയോ ഇമേജ് ഉൾപ്പെടുന്നു

ഒരേ സമയം ഒന്നിലധികം മോഡുകൾ തിരഞ്ഞെടുക്കുന്നതിന്, ബിറ്റ്വൈസ് അല്ലെങ്കിൽ "|" ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്: glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH) ഇരട്ട ബഫറിംഗ്, Z-ബഫർ, ക്വാഡ് കളർ എന്നിവ പ്രവർത്തനക്ഷമമാക്കുന്നു. വിൻഡോ വലുപ്പങ്ങൾ സജ്ജീകരിച്ചിരിക്കുന്നു glutInitWindowSize (വീതി, ഉയരം). എന്നതാണ് അദ്ദേഹത്തിന്റെ നിലപാട് glutInitWindowPosition(x, y). ഫംഗ്‌ഷൻ വഴി ഒരു വിൻഡോ സൃഷ്‌ടിക്കുന്നു glutCreateWindow(window_title).
GLUT ഒരു ഇവന്റ്-ഡ്രൈവ് മെക്കാനിസം നടപ്പിലാക്കുന്നു. ആ. സമാരംഭിച്ചതിന് ശേഷം ആരംഭിക്കുന്ന ഒരു പ്രധാന ലൂപ്പ് ഉണ്ട്, എല്ലാ പ്രഖ്യാപിത ഇവന്റുകളും ഇതിനകം അതിൽ പ്രോസസ്സ് ചെയ്തിട്ടുണ്ട്. ഉദാഹരണത്തിന്, കീബോർഡിൽ ഒരു കീ അമർത്തുകയോ മൗസ് കഴ്സർ ചലിപ്പിക്കുകയോ ചെയ്യുക. ഇനിപ്പറയുന്ന കമാൻഡുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇവന്റ് ഹാൻഡ്‌ലർ ഫംഗ്‌ഷനുകൾ രജിസ്റ്റർ ചെയ്യാൻ കഴിയും:

• void glutDisplayFunc (അസാധു (*func) (അസാധു))- ഒരു ചിത്രം വരയ്ക്കുന്നതിനുള്ള പ്രവർത്തനം സജ്ജമാക്കുന്നു
• void glutReshapeFunc (അസാധു (*func) (int വീതി, int ഉയരം))- വിൻഡോ വലുപ്പം മാറ്റുന്നതിനുള്ള പ്രവർത്തനം ക്രമീകരിക്കുന്നു
• void glutVisibilityFunc (അസാധു (*func)(int state))- വിൻഡോ ദൃശ്യപരത അവസ്ഥയിലെ മാറ്റങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം സജ്ജമാക്കുന്നു
• void glutKeyboardFunc (അസാധുവായ (*func)(ഒപ്പ് ചെയ്യാത്ത ചാർ കീ, int x, int y))- കീബോർഡ് കീസ്ട്രോക്കുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം സജ്ജമാക്കുന്നു (ascii പ്രതീകങ്ങൾ സൃഷ്ടിക്കുന്നവ മാത്രം)
• void glutSpecialFunc (അസാധുവായ (*func)(int കീ, int x, int y))- കീബോർഡ് കീ അമർത്തലുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം സജ്ജമാക്കുന്നു (ascii പ്രതീകങ്ങൾ സൃഷ്ടിക്കാത്തവ)
• ശൂന്യമായ glutIdleFunc (അസാധു (*func) (അസാധു))- മറ്റ് ഇവന്റുകൾ ഇല്ലാത്തപ്പോൾ വിളിക്കുന്ന ഒരു ഫംഗ്ഷൻ വ്യക്തമാക്കുന്നു
• void glutMouseFunc (അസാധുവായ (*func) (int ബട്ടൺ, int സ്റ്റേറ്റ്, int x, int y))- മൗസ് കമാൻഡുകൾ പ്രോസസ്സ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു
• void glutMotionFunc (അസാധു (*func)(int x, int y))- ഏതെങ്കിലും മൗസ് ബട്ടൺ അമർത്തുമ്പോൾ മൗസ് കഴ്സറിന്റെ ചലനം പ്രോസസ്സ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു
• void glutPassiveMotionFunc (അസാധു (*func)(int x, int y))- മൗസ് ബട്ടണൊന്നും അമർത്താത്തപ്പോൾ മൗസ് കഴ്‌സറിന്റെ ചലനം പ്രോസസ്സ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കുന്നു
• ശൂന്യമായ glutEntryFunc (അസാധുവായ (*func)(int state))- വിൻഡോയ്ക്ക് പുറത്ത് കഴ്‌സർ ചലനവും അതിന്റെ റിട്ടേണും കൈകാര്യം ചെയ്യുന്ന ഒരു ഫംഗ്‌ഷൻ നിർവചിക്കുന്നു
• void glutTimerFunc (അൺ സൈൻ ചെയ്യാത്ത int msecs, void (*func)(int value), മൂല്യം)- ഒരു ടൈമറിൽ വിളിക്കപ്പെടുന്ന ഒരു ഫംഗ്ഷൻ വ്യക്തമാക്കുന്നു

അപ്പോൾ നിങ്ങൾക്ക് പ്രധാന ലൂപ്പ് ആരംഭിക്കാം glutMainLoop().

ആദ്യ പരിപാടി

OpenGL-ൽ പ്രവർത്തിക്കുന്നതിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ ഇപ്പോൾ നമുക്കറിയാം. നിങ്ങൾക്ക് എഴുതാം ഒരു ലളിതമായ പ്രോഗ്രാംഅറിവ് ഏകീകരിക്കാൻ.
GLUT ഹെഡർ ഫയൽ ഉൾപ്പെടുത്തിക്കൊണ്ട് നമുക്ക് ആരംഭിക്കാം:

പ്രധാനമായും എന്താണ് എഴുതേണ്ടതെന്ന് ഇപ്പോൾ നമുക്കറിയാം. നമുക്ക് രണ്ട് ഹാൻഡ്ലറുകൾ രജിസ്റ്റർ ചെയ്യാം: വിൻഡോയുടെ ഉള്ളടക്കങ്ങൾ വരയ്ക്കുന്നതിനും വലുപ്പം മാറ്റുന്നതിനും. OpenGL ഉം GLUT ഉം ഉപയോഗിക്കുന്ന ഏതൊരു പ്രോഗ്രാമിലും ഈ രണ്ട് ഹാൻഡ്‌ലറുകൾ പ്രധാനമായും ഉപയോഗിക്കുന്നു.

1. int main (int argc, char * argv)
2. glutInit(& argc, argv) ;
3. glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*ഡബിൾ ബഫറിംഗും നാല്-ഘടക വർണ്ണവും പ്രവർത്തനക്ഷമമാക്കുക*/
4. glutInitWindowSize(800, 600) ;
5. glutCreateWindow("OpenGL പാഠം 1" );
6. glutReshapeFunc(reshape) ;
7. glutDisplayFunc(ഡിസ്പ്ലേ) ;
8. glutMainLoop() ;
9. തിരികെ 0;

വിൻഡോ വലുപ്പം മാറ്റുന്നതിനായി ഇപ്പോൾ നമ്മൾ ഒരു ഹാൻഡ്ലർ ഫംഗ്ഷൻ എഴുതേണ്ടതുണ്ട്. കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് ഇമേജ് ഔട്ട്പുട്ട് ഏരിയ മുഴുവൻ വിൻഡോയുടെയും വലുപ്പത്തിൽ സജ്ജമാക്കാം glViewport(x, y, വീതി, ഉയരം). തുടർന്ന് പ്രൊജക്ഷൻ മാട്രിക്സ് ലോഡ് ചെയ്യുക glMatrixMode(GL_PROJECTION), അത് യൂണിറ്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക ഗ്ലോഡ് ഐഡന്റിറ്റി()കൂടാതെ ഓർത്തോഗണൽ പ്രൊജക്ഷൻ സജ്ജമാക്കുക. അവസാനം, മോഡൽ-വ്യൂ മാട്രിക്സ് ലോഡ് ചെയ്യുക glMatrixMode(GL_MODELVIEW)ഒരു യൂണിറ്റ് ഉപയോഗിച്ച് അത് മാറ്റിസ്ഥാപിക്കുക.
ഫലമായി നമുക്ക് ലഭിക്കുന്നത്:

1. ശൂന്യമായ പുനർരൂപം (int w, int h)
2. glViewport(0 , 0 , w, h) ;
3. glMatrixMode(GL_PROJECTION) ;
4. glLoadIdentity() ;
5. gluOrtho2D(0 , w, 0 , h) ;
6. glMatrixMode(GL_MODELVIEW) ;
7. glLoadIdentity() ;

വിൻഡോയുടെ ഉള്ളടക്കങ്ങൾ വരയ്ക്കുന്നതിന് ഒരു ഫംഗ്ഷൻ എഴുതുക മാത്രമാണ് അവശേഷിക്കുന്നത്. ഒരു ഉദാഹരണമായി ഞാൻ മുകളിൽ നൽകിയ ചതുരം ഞങ്ങൾ വരയ്ക്കും. നിങ്ങൾ വളരെ കുറച്ച് കോഡ് ചേർക്കേണ്ടിവരും. ആദ്യം, വരയ്ക്കുന്നതിന് മുമ്പ്, നിങ്ങൾ ഉപയോഗിച്ച് വിവിധ ബഫറുകൾ മായ്‌ക്കേണ്ടതുണ്ട് glClear (മോഡ്). glutInitDisplayMode പോലെ തന്നെ ഉപയോഗിക്കുന്നു. സാധ്യമായ മൂല്യങ്ങൾ:

• GL_COLOR_BUFFER_BIT- കളർ ബഫർ മായ്ക്കാൻ
• GL_DEPTH_BUFFER_BIT- ഡെപ്ത് ബഫർ മായ്ക്കാൻ
• GL_ACCUM_BUFFER_BIT- സഞ്ചയ ബഫർ മായ്‌ക്കാൻ
• GL_STENCIL_BUFFER_BIT- സ്ക്രീൻ ബഫർ വൃത്തിയാക്കുന്നതിന്

ഞങ്ങളുടെ കാര്യത്തിൽ, നമുക്ക് കളർ ബഫർ മായ്‌ക്കേണ്ടതുണ്ട്, കാരണം ഞങ്ങൾ മറ്റുള്ളവരെ ഉപയോഗിക്കുന്നില്ല. രണ്ടാമതായി, വരച്ച ശേഷം, സ്‌ക്രീൻ ബഫറുകൾ മാറ്റാൻ നിങ്ങൾ OpenGL-നോട് ആവശ്യപ്പെടേണ്ടതുണ്ട് glutSwapBuffers(), കാരണം ഞങ്ങൾക്ക് ഇരട്ട ബഫറിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ട്. ഉപയോക്താവിൽ നിന്ന് മറഞ്ഞിരിക്കുന്ന ഒരു ബഫറിൽ എല്ലാം വരയ്ക്കുകയും തുടർന്ന് ബഫറുകൾ മാറ്റുകയും ചെയ്യുന്നു. ലഭിക്കാനാണ് ഇത് ചെയ്യുന്നത് സുഗമമായ ആനിമേഷൻഅങ്ങനെ ഒരു ഫലവുമില്ല ഫ്ലിക്കർസ്ക്രീൻ.
നമുക്ക് ലഭിക്കുന്നത്:

1. അസാധുവായ ഡിസ്പ്ലേ()
2. glClear(GL_COLOR_BUFFER_BIT) ;
3. glBegin(GL_QUADS) ;
4. glColor3f(1.0, 1.0, 1.0) ;
5. glVertex2i(250, 450);
6. glColor3f(0.0, 0.0, 1.0) ;
7. glVertex2i(250, 150);
8. glColor3f(0.0, 1.0, 0.0) ;
9. glVertex2i(550, 150) ;
10. glColor3f(1.0, 0.0, 0.0) ;
11. glVertex2i(550, 450) ;
12. glEnd();
13. glutSwapBuffers() ;

താഴത്തെ വരി

എല്ലാം! സമാഹരിക്കാൻ കഴിയും. ഇത് ഇതുപോലെയായിരിക്കണം:

സാധാരണഗതിയിൽ, വസ്തുക്കളുടെ സാന്നിധ്യം (ഒബ്ജക്റ്റ് സെലക്ഷൻ ഏരിയ) നിർണ്ണയിക്കാൻ ആവശ്യമായ പ്രദേശം സീൻ പ്രൊജക്ഷന്റെ ഒരു ശകലമായി നിർവചിക്കപ്പെടുന്നു. ഉദാഹരണത്തിന്, ഉപയോക്താവ് ഒരു മാനിപ്പുലേറ്റർ (ഉദാഹരണത്തിന്, ഒരു മൗസ് പോയിന്റർ) ഉപയോഗിച്ച് പ്രൊജക്ഷൻ ഇമേജിൽ ഒരു ചതുരാകൃതിയിലുള്ള പ്രദേശം തിരഞ്ഞെടുക്കുന്നു അല്ലെങ്കിൽ മൗസ് ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക, അങ്ങനെ തിരഞ്ഞെടുക്കൽ ഏരിയ നിർവചിക്കുന്നു.

ഈ സന്ദർഭങ്ങളിൽ ത്രിമാന സീനിന്റെ പ്രൊജക്ഷനിലാണ് സെലക്ഷൻ ഏരിയ നിർണ്ണയിക്കുന്നത് എന്നതിനാൽ, ത്രിമാന സീനിന്റെ (സെലക്ഷൻ രംഗം) അനുബന്ധ പ്രദേശം നിർണ്ണയിക്കേണ്ടത് ആവശ്യമാണ്. നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന രംഗം പല ഘടകങ്ങളെ ആശ്രയിച്ചിരിക്കും: ഉപയോഗിച്ച പ്രൊജക്ഷൻ, സീനിന്റെ വലുപ്പം, ഔട്ട്പുട്ട് ഏരിയ.

സീൻ പ്രൊജക്ഷന്റെ ചതുരാകൃതിയിലുള്ള ഭാഗത്തെ അടിസ്ഥാനമാക്കി ഒരു 3D സെലക്ഷൻ ഏരിയ നിർണ്ണയിക്കാൻ, പ്രൊജക്ഷൻ മാട്രിക്സിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ആവശ്യമാണ്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾക്ക് GLUT ലൈബ്രറിയിൽ നിന്ന് ചില പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കാം, ഇത് OpenGL ലൈബ്രറിയിലേക്കുള്ള ഒരു ആഡ്-ഓൺ ആണ് കൂടാതെ നിരവധി അധിക കഴിവുകൾ നൽകുന്നു.

OpenTK ലൈബ്രറിയിൽ, GLUT ലൈബ്രറി ഫംഗ്‌ഷനുകൾ നെയിംസ്‌പെയ്‌സിലെ Glu ക്ലാസിലാണ്. Tao.OpenGL(C#). ഒബ്‌ജക്റ്റ് പാസ്കലിൽ, എല്ലാ GLUT ലൈബ്രറി ഫംഗ്‌ഷനുകളും നടപടിക്രമങ്ങളും ഓപ്പൺജിഎൽ നടപടിക്രമങ്ങളിൽ നിന്നും ഫംഗ്‌ഷനുകളിൽ നിന്നും വേർതിരിച്ചറിയാൻ "glu" ഉപയോഗിച്ച് പ്രിഫിക്‌സ് ചെയ്‌തിരിക്കുന്നു.

സീൻ പ്രൊജക്ഷന്റെ തിരഞ്ഞെടുത്ത ശകലത്തെ അടിസ്ഥാനമാക്കി ഒരു പ്രൊജക്ഷൻ മാട്രിക്സ് സൃഷ്ടിക്കുന്നതിന്, നിങ്ങൾക്ക് GLUT ലൈബ്രറിയുടെ PickMatrix കമാൻഡ് ഉപയോഗിക്കാം:

C#: അസാധുവായ gluPickMatrix (ഇരട്ട x, ഇരട്ട y, ഇരട്ട വീതി, ഇരട്ട ഉയരം, ഇന്റ് വ്യൂപോർട്ട്); ഒബ്ജക്റ്റ് പാസ്കൽ: നടപടിക്രമം gluPickMatrix(x,y,width,height: GLdouble; viewport: PGLint);

GLUT ലൈബ്രറിയുടെ PickMatrix കമാൻഡ് നിലവിലെ മാട്രിക്‌സ് പരിഷ്‌ക്കരിക്കുന്നു, അതുവഴി സീൻ റീജിയന്റെ വലുപ്പം ആ സീനിന്റെ പ്രൊജക്ഷൻ കോർഡിനേറ്റുകളിൽ നിർവചിച്ചിരിക്കുന്ന തിരഞ്ഞെടുപ്പ് മേഖലയുമായി പൊരുത്തപ്പെടുന്നു. കമാൻഡിന് ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ഉണ്ട്:

• x, y - 3D സീനിന്റെ പ്രൊജക്ഷൻ പ്രദർശിപ്പിച്ചിരിക്കുന്ന വിൻഡോയുടെ കോർഡിനേറ്റുകളിലെ സെലക്ഷൻ ഏരിയയുടെ തിരശ്ചീനവും ലംബവുമായ കോർഡിനേറ്റുകൾ.
• വിൻഡോ കോർഡിനേറ്റുകളിൽ 3D സീനിന്റെ തിരഞ്ഞെടുത്ത ദീർഘചതുരാകൃതിയിലുള്ള പ്രൊജക്ഷൻ ഏരിയയുടെ വീതി, ഉയരം - വീതിയും ഉയരവും.
• നാല് പൂർണ്ണസംഖ്യ ഘടകങ്ങളുടെ ഒരു നിരയാണ് വ്യൂപോർട്ട്. C#-ൽ, ഒരു അറേ ഒരു പാരാമീറ്ററായി നേരിട്ട് കൈമാറുന്നു; ഒബ്ജക്റ്റ് പാസ്കലിൽ, അറേയിലേക്കുള്ള ഒരു പോയിന്റർ ഒരു പാരാമീറ്ററായി കൈമാറുന്നു. 3D സീൻ പ്രൊജക്ഷന്റെ ഔട്ട്‌പുട്ട് ഏരിയ അറേ നിർവ്വചിക്കുന്നു. അറേ മൂല്യങ്ങൾ ViewPort കമാൻഡ് ഉപയോഗിച്ച് നിർവചിച്ചിരിക്കുന്ന ഔട്ട്പുട്ട് ഏരിയ കോർഡിനേറ്റുകളുമായി പൊരുത്തപ്പെടണം. ഈ അറേയുടെ ഘടകങ്ങൾക്ക് ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ ഉണ്ടായിരിക്കണം: 1-ഉം 2-ഉം ഘടകങ്ങൾ ഇടത് വശത്തെ x, y കോർഡിനേറ്റുകളാണ് മുകളിലെ മൂലസ്ക്രീൻ കോർഡിനേറ്റുകളിൽ തിരഞ്ഞെടുത്ത ഏരിയ, 3, 4 ഘടകങ്ങൾ - ഈ ഏരിയയുടെ വീതിയും ഉയരവും.

പ്രൊജക്ഷൻ മാട്രിക്സ് സൃഷ്ടിക്കുന്ന Ortho അല്ലെങ്കിൽ Frushtum കമാൻഡുകൾ നടപ്പിലാക്കുന്നതിന് മുമ്പ് കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യണം.

OpenGL ലൈബ്രറി സെലക്ഷൻ മോഡിലേക്ക് മാറ്റുന്നു

ലൈബ്രറി സെലക്ഷൻ മോഡിലേക്ക് മാറ്റാൻ, RenderMode കമാൻഡ് ഉപയോഗിക്കുക:

C#: int RenderMode(റെൻഡറിംഗ് മോഡ് മോഡ്); ഒബ്ജക്റ്റ് പാസ്കൽ: ഫംഗ്ഷൻ glRenderMode(മോഡ്: GLenum): GLint;

മോഡ് പാരാമീറ്റർ OpenGL ലൈബ്രറിയുടെ ഓപ്പറേറ്റിംഗ് മോഡ് നിർണ്ണയിക്കുന്നു കൂടാതെ മൂന്ന് മൂല്യങ്ങളിൽ ഒന്ന് എടുക്കാം:

പട്ടിക 10.1. RenderMode കമാൻഡിന്റെ മോഡ് പാരാമീറ്ററിനുള്ള സാധ്യമായ മൂല്യങ്ങൾ

വിവരണം	അർത്ഥം
	OpenTK ലൈബ്രറി, C#	ഒബ്ജക്റ്റ് പാസ്കൽ
തിരഞ്ഞെടുക്കൽ മോഡ് നൽകിയ മൂല്യംലൈബ്രറി സെലക്ഷൻ മോഡിൽ ഉൾപ്പെടുത്താൻ ഉപയോഗിക്കുന്നു.	RenderingMode.Select	GL_SELECT
സീൻ ഇമേജിംഗ് മോഡ്. OpenGL ലൈബ്രറി ആരംഭിച്ചതിന് ശേഷം ഈ മോഡ് സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കുന്നു. ഈ മോഡിൽ ആണ് ചിത്രം OpenGL ലൈബ്രറി ജനറേറ്റ് ചെയ്യുന്നത്.	റെൻഡറിംഗ് മോഡ്.റെൻഡർ	GL_RENDER
ഫീഡ്ബാക്ക് മോഡ്.	റെൻഡറിംഗ് മോഡ്.ഫീഡ്ബാക്ക്	GL_FEEDBACK

സെലക്ഷൻ മോഡിലേക്ക് മാറിയതിന് ശേഷം, RenderingMode മൂല്യമുള്ള RenderMode കമാൻഡ് ഉപയോഗിച്ച് മോഡ് സീൻ റെൻഡറിംഗ് മോഡിലേക്ക് മാറ്റുന്നത് വരെ OpenGL ചിത്രം റെൻഡർ ചെയ്യുന്നില്ല. C#-ൽ Render, Object Pascal-ൽ GL_RENDER.

സീൻ ഒബ്‌ജക്‌റ്റുകൾക്ക് പേരിടുകയും രൂപപ്പെടുത്തുകയും ചെയ്യുന്നു

മുകളിൽ ചർച്ച ചെയ്തതുപോലെ, തിരഞ്ഞെടുക്കൽ മോഡിൽ ഒരു ചിത്രവും സൃഷ്ടിക്കപ്പെടുന്നില്ല. സെലക്ഷൻ ഏരിയയിൽ വരുന്ന ഒബ്‌ജക്‌റ്റുകൾ നിർവചിക്കാൻ ഈ മോഡിലെ ഇമേജിംഗ് കമാൻഡുകൾ ഉപയോഗിക്കുന്നു.

ഉപയോക്താവ് പ്രവർത്തിക്കുന്ന ഒബ്‌ജക്‌റ്റുകൾ സാധാരണയായി വിവിധ പ്രാകൃതങ്ങളിൽ നിന്ന് രൂപപ്പെടുന്നതിനാൽ, തിരഞ്ഞെടുത്ത ഒബ്‌ജക്റ്റ് നിർണ്ണയിക്കാൻ പേരുകളുടെ ഒരു കൂട്ടം ഉപയോഗിക്കുന്നു. പേരുകൾ പൂർണ്ണസംഖ്യ മൂല്യങ്ങളാണ്. അടുത്ത ഒബ്ജക്റ്റ് ഔട്ട്പുട്ട് ചെയ്യുന്നതിന് മുമ്പ്, ഈ വസ്തുവിന്റെ പേര് (നമ്പർ) നെയിം സ്റ്റാക്കിൽ സ്ഥാപിച്ചിരിക്കുന്നു. ഒരു ഒബ്‌ജക്‌റ്റ് രൂപീകരിക്കുമ്പോൾ, ഈ ഒബ്‌ജക്‌റ്റിന്റെ പ്രാകൃതങ്ങൾ സെലക്ഷൻ ഏരിയയിൽ വീഴുന്നതായി ലൈബ്രറി കണ്ടെത്തുകയാണെങ്കിൽ, നെയിം സ്റ്റാക്കിന്റെ ഉള്ളടക്കങ്ങൾ സെലക്ഷൻ ബഫറിലേക്ക് പകർത്തുന്നു (ചിലതോടൊപ്പം അധിക വിവരം) SelectBuffer കമാൻഡ് ഉപയോഗിച്ച് സമാരംഭിച്ചു. മറ്റൊരു പേരുള്ള ഒബ്‌ജക്റ്റിന്റെ പ്രാകൃതങ്ങൾ സീൻ ഏരിയയിൽ പ്രവേശിക്കുമ്പോൾ, നെയിം സ്റ്റാക്കിന്റെ ഉള്ളടക്കങ്ങളും സെലക്ഷൻ ബഫറിലേക്ക് പകർത്തപ്പെടും. അങ്ങനെ, സെലക്ഷൻ ഏരിയയിൽ പൂർണ്ണമായോ ഭാഗികമായോ ഉള്ള വസ്തുക്കളുടെ പേരുകൾ (നമ്പറുകൾ) ലഭിക്കും. തിരഞ്ഞെടുത്ത ഒബ്‌ജക്റ്റുകൾ ശരിയായി നിർണ്ണയിക്കുന്നതിന്, വസ്തുക്കളുടെ കോർഡിനേറ്റ് പരിവർത്തനങ്ങൾ സീൻ ഇമേജ് രൂപീകരിക്കുമ്പോൾ നടത്തിയവയുമായി പൊരുത്തപ്പെടേണ്ടത് ആവശ്യമാണെന്ന് കണക്കിലെടുക്കണം.

നെയിം സ്റ്റാക്കിനൊപ്പം പ്രവർത്തിക്കാൻ നിരവധി കമാൻഡുകൾ ഉപയോഗിക്കുന്നു. നെയിം സ്റ്റാക്ക് മായ്‌ക്കുന്നത് InitNames കമാൻഡ് ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്:

C#: അസാധുവായ InitNames(); ഒബ്ജക്റ്റ് പാസ്കൽ: നടപടിക്രമം glInitNames;

ഒരു പേര് സ്റ്റാക്കിലേക്ക് തള്ളുന്നത് PushName കമാൻഡ് ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്:

C#: PushName (int name); ഒബ്ജക്റ്റ് പാസ്കൽ: നടപടിക്രമം glPushName(പേര്: GLuint);

പേര് ഒരു കമാൻഡ് പാരാമീറ്ററായി കൈമാറുന്നു.

ഒരു നെയിം സ്റ്റാക്ക് ഉപയോഗിക്കുന്നതിന് മുമ്പ്, അത് InitNames കമാൻഡ് ഉപയോഗിച്ച് ആരംഭിക്കേണ്ടതാണ്. PushName കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾ ഒരു ഘടകം സ്റ്റാക്കിലേക്ക് തള്ളേണ്ടതുണ്ട്. ഓരോ ഒബ്‌ജക്‌റ്റും രൂപപ്പെടുന്നതിന് മുമ്പ്, നെയിം സ്റ്റാക്കിന്റെ ഒരൊറ്റ ഘടകം, ലോഡ്‌നെയിം കമാൻഡ് ഉപയോഗിച്ച് രൂപപ്പെടുന്ന ഒബ്‌ജക്റ്റിന്റെ പേര് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും. നെയിം സ്റ്റാക്കിലെ അവസാന ഘടകത്തെ ഒരു പാരാമീറ്ററായി നൽകിയിരിക്കുന്നത് ഉപയോഗിച്ച് നടപടിക്രമം മാറ്റിസ്ഥാപിക്കുന്നു. അതിനാൽ, നെയിം സ്റ്റാക്കിന്റെ സമാരംഭവും ഉപയോഗവും ഇനിപ്പറയുന്ന രീതിയിൽ പ്രതിനിധീകരിക്കാം:

InitNames; പുഷ് നെയിം(0); ...ലോഡ് നെയിം(1); ഒബ്‌ജക്റ്റ് നമ്പർ 1 ന്റെ രൂപീകരണം LoadName(2); ഒബ്‌ജക്റ്റ് നമ്പർ 2 ന്റെ രൂപീകരണം LoadName(3); //വസ്തു നമ്പർ 3 ന്റെ രൂപീകരണം // etc. ലിസ്റ്റിംഗ് 10.7. ഒബ്ജക്റ്റുകൾ തിരഞ്ഞെടുക്കുന്നതിന് ഒരു നെയിം സ്റ്റാക്ക് ഉപയോഗിക്കുന്നതിനുള്ള ഡയഗ്രം

OpenGL പഠിക്കാൻ തീരുമാനിച്ചു, എന്നാൽ എവിടെ തുടങ്ങണമെന്ന് അറിയാമോ? ഞങ്ങൾ മെറ്റീരിയലുകളുടെ ഒരു തിരഞ്ഞെടുപ്പ് നടത്തി.

എന്താണ് OpenGL

OpenGL (തുറക്കുക ഗ്രാഫിക്സ് ലൈബ്രറി) ഗ്രാഫിക്സുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഏറ്റവും ജനപ്രിയമായ ഗ്രാഫിക് മാനദണ്ഡങ്ങളിൽ ഒന്നാണ്. അതിന്റെ സഹായത്തോടെ എഴുതിയ പ്രോഗ്രാമുകൾ ഏതാണ്ട് ഏത് പ്ലാറ്റ്ഫോമിലേക്കും മാറ്റാം, അതേ ഫലം ലഭിക്കും. ഹാർഡ്‌വെയറിനായി പ്രോഗ്രാമുകൾ എഴുതാനല്ല, ഉപയോഗിക്കാൻ ഓപ്പൺജിഎൽ നിങ്ങളെ അനുവദിക്കുന്നു നിലവിലുള്ള വികസനങ്ങൾ. മറ്റ് സാങ്കേതിക ഭീമന്മാരുമായി സഹകരിച്ച് സിലിക്കൺ ഗ്രാഫിക്സാണ് ഓപ്പൺജിഎൽ വികസിപ്പിച്ചെടുത്തത്.

ഒരു പ്രോഗ്രാമിംഗ് വീക്ഷണകോണിൽ നിന്ന്, OpenGL ആണ് സോഫ്റ്റ്വെയർ ഇന്റർഫേസ്വേണ്ടി റാസ്റ്റർ ഗ്രാഫിക്സ്, ഗ്രാഫിക്സ് ആക്സിലറേറ്ററുകൾ പോലുള്ളവ. പ്രോഗ്രാമർക്ക് വിവിധ ഒബ്ജക്റ്റുകൾ നിർവചിക്കാനും റെൻഡർ ചെയ്യാനും കഴിയുന്ന 150 വ്യത്യസ്ത കമാൻഡുകൾ ഇതിൽ ഉൾപ്പെടുന്നു.

പഠന സാമഗ്രികൾ

ട്യൂട്ടോറിയലുകൾ

ഓൺലൈൻ കോഴ്സുകൾ

• ലിൻഡ - "ഓപ്പൺജിഎൽ കോഴ്സ്";
• ടോക്കിയോ യൂണിവേഴ്സിറ്റി - "ഇന്ററാക്ടീവ് കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ്";
• സാൻ ഡീഗോ യൂണിവേഴ്സിറ്റി - "കമ്പ്യൂട്ടർ ഗ്രാഫിക്സിന്റെ അടിസ്ഥാനങ്ങൾ."

പുസ്തകങ്ങൾ

റഷ്യൻ ഭാഷയിൽ

1. D. Shreiner - OpenGL Redbook - ഡൗൺലോഡ്;

ഓപ്പൺജിഎൽ പഠിക്കുന്നതിനുള്ള ഔദ്യോഗിക വഴികാട്ടിയാണ് പുസ്തകം. ഏറ്റവും പുതിയ പതിപ്പുകൾ യഥാർത്ഥ പതിപ്പുകളിൽ നിന്ന് തികച്ചും വ്യത്യസ്തമാണ്; പതിപ്പുകളിലെ മാറ്റങ്ങൾക്ക് അനുസൃതമായി രചയിതാവ് അത് അപ്ഡേറ്റ് ചെയ്യുന്നു. ഓപ്പൺ ജിഎല്ലിൽ പ്രവർത്തിക്കുന്ന നൂറുകണക്കിന് വിദഗ്ധരുടെ അഭിപ്രായത്തിൽ, സാങ്കേതികവിദ്യ പഠിക്കാൻ ആഗ്രഹിക്കുന്ന ഏതൊരാളും ആദ്യം എടുക്കേണ്ടത് ഈ പുസ്തകമാണ്.

2. ഡി വുൾഫ് - ഓപ്പൺ ജിഎൽ 4. ഷേഡർ ഭാഷ. പാചകക്കുറിപ്പ് പുസ്തകം (2015) - ഡൗൺലോഡ്;

ഈ പുസ്തകം GLSL പ്രോഗ്രാമിംഗ് ടെക്നിക്കുകളുടെ മുഴുവൻ ശ്രേണിയും ഉൾക്കൊള്ളുന്നു അടിസ്ഥാന തരങ്ങൾഷേഡറുകൾ - ശീർഷവും ശകലവും - ജ്യാമിതി, കമ്പ്യൂട്ട്, ടെസ്സലേഷൻ ഷേഡറുകൾ. ഇത് വായിച്ചതിനുശേഷം, വൈവിധ്യമാർന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ നിങ്ങൾക്ക് ജിപിയു ഉപയോഗിക്കാനാകും.

3. D. Ginsburg - OpenGL ES 3.0. ഡെവലപ്പറുടെ ഗൈഡ് (2014) - വാങ്ങുക;

ഈ പുസ്തകത്തിൽ, ഷേഡറുകൾ എഴുതുന്നതിനുള്ള മുഴുവൻ എപിഐയും ഭാഷയും രചയിതാവ് അവലോകനം ചെയ്യുന്നു. പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനും കാര്യക്ഷമത വർദ്ധിപ്പിക്കുന്നതിനുമുള്ള നുറുങ്ങുകളും നിങ്ങൾ കണ്ടെത്തും API വർക്ക്ഒപ്പം ജിപിയുവും പൂർണ്ണ ഉപയോഗംവിപുലമായ ആപ്ലിക്കേഷനുകളിൽ OpenGL ES.

4. വി പോരേവ് - കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ് (2002) - ഡൗൺലോഡ്;

പ്രവർത്തിക്കാനുള്ള വഴികൾ പുസ്തകം ചർച്ച ചെയ്യുന്നു കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ്, സാധാരണ പ്രശ്നങ്ങൾ, C++ ലെ പ്രോഗ്രാമുകളുടെ ഉദാഹരണങ്ങൾ നൽകിയിരിക്കുന്നു.

ഇംഗ്ലീഷിൽ

1. പി. ഷേർലി - കമ്പ്യൂട്ടർ ഗ്രാഫിക്‌സിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ (2009) - ;

കമ്പ്യൂട്ടർ ഗ്രാഫിക്‌സിന്റെ ആമുഖം എന്ന നിലയിലാണ് പുസ്തകം ഉദ്ദേശിച്ചിരിക്കുന്നത് അടിസ്ഥാന നില. കാര്യക്ഷമമായ കോഡ് വികസിപ്പിക്കുന്നതിന് ഈ അടിസ്ഥാനങ്ങൾ എങ്ങനെ പ്രയോഗിക്കണം എന്നതിന് ഊന്നൽ നൽകിക്കൊണ്ട് രചയിതാക്കൾ കമ്പ്യൂട്ടർ ഗ്രാഫിക്സിന്റെ ഗണിതശാസ്ത്ര അടിത്തറകൾ ഉൾക്കൊള്ളുന്നു.

2. ഇ. ഏഞ്ചൽ - ഇന്ററാക്ടീവ് കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ് - വാങ്ങുക;

കമ്പ്യൂട്ടർ സയൻസും പ്രോഗ്രാമിംഗും ആഴത്തിൽ പഠിക്കുന്ന എല്ലാ വിദ്യാർത്ഥികൾക്കും വേണ്ടിയുള്ളതാണ് ഈ പുസ്തകം. കമ്പ്യൂട്ടർ ആനിമേഷൻകൂടാതെ ഗ്രാഫിക്സ് പഴയത് പോലെ സങ്കീർണ്ണമല്ല. അദ്ദേഹത്തിന്റെ പ്രസ്താവനയെ തുടർന്ന്, ഗ്രന്ഥകാരൻ ഏറ്റവും മനസ്സിലാക്കാവുന്ന ഭാഷയിൽ പുസ്തകം എഴുതി.

ഈ വിഭാഗത്തിൽ, ഓപ്പൺജിഎൽ ലൈബ്രറി ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് 3D ഇമേജുകൾ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ഞങ്ങൾ പഠിക്കും, അതിനാൽ അടുത്ത അധ്യായത്തിൽ നമുക്ക് ഒരു വിൻഡോസ് ആപ്ലിക്കേഷൻ വികസിപ്പിക്കാം, അത് ശാസ്ത്രീയ കണക്കുകൂട്ടലുകളുടെ ഫലങ്ങൾ കാണുന്നതിനുള്ള ഒരു ഉപകരണമായി കണക്കാക്കാം. ഈ വിഭാഗത്തിലെ മെറ്റീരിയൽ നിങ്ങളെ ക്രമേണ വേഗത കൈവരിക്കാനും ത്രിമാന ഇമേജുകൾ സൃഷ്ടിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനുമുള്ള ആകർഷകമായ സാങ്കേതികവിദ്യയിൽ വൈദഗ്ദ്ധ്യം നേടാനും നിങ്ങളെ അനുവദിക്കും. ആദ്യം നമ്മൾ ഓപ്പൺജിഎൽ ലൈബ്രറിയുടെ അടിസ്ഥാന കഴിവുകൾ നോക്കും, തുടർന്ന് എങ്ങനെ നിയന്ത്രിക്കാമെന്ന് ഞങ്ങൾ പഠിക്കും OpenGL പ്രവർത്തനങ്ങൾഉദാഹരണത്തിന് ലളിതമായ ആപ്ലിക്കേഷനുകൾകൺസോൾ തരം, അതിനുശേഷം മാത്രമേ ഞങ്ങൾ ഒരു വിൻഡോസ് ആപ്ലിക്കേഷൻ വികസിപ്പിക്കാൻ തുടങ്ങുകയുള്ളൂ.

ഓപ്പൺജിഎൽ ഫംഗ്‌ഷനുകളുടെയും ഡാറ്റാ തരങ്ങളുടെയും ഒപ്റ്റിമൈസ് ചെയ്‌തതും ഉയർന്ന പ്രകടനമുള്ളതുമായ ഗ്രാഫിക്‌സ് ലൈബ്രറിയാണെന്ന് വായനക്കാരന് ഒരുപക്ഷേ അറിയാം. 3D ഗ്രാഫിക്സ്. ഓപ്പൺജിഎൽ സ്റ്റാൻഡേർഡ് 1992-ൽ അംഗീകരിച്ചു. സിലിക്കൺ ഗ്രാഫിക്സ് (www.sgi.com) വികസിപ്പിച്ച IRIS GL ലൈബ്രറിയെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഇത്. എല്ലാ പ്ലാറ്റ്ഫോമുകളിലും OpenGL പിന്തുണയ്ക്കുന്നു. കൂടാതെ, ഹാർഡ്‌വെയറിൽ OpenGL പിന്തുണയ്ക്കുന്നു. ഹാർഡ്‌വെയറിൽ ഓപ്പൺജിഎൽ പ്രിമിറ്റീവുകൾ നിർവഹിക്കുന്ന ആക്‌സിലറേറ്ററുകളുള്ള വീഡിയോ കാർഡുകളും പ്രത്യേക SD കാർഡുകളും ഉണ്ട്.

"ഓപ്പൺജിഎൽ പ്രോഗ്രാമിംഗ് ഗൈഡ്, ഓപ്പൺജിഎൽ പഠിക്കുന്നതിനുള്ള ഔദ്യോഗിക ഗൈഡ്" എന്ന അഡിസൺ-വെസ്ലിയിൽ നിന്നുള്ള വളരെ നല്ല പുസ്തകത്തിൽ നിന്ന് (ഓൺലൈനിൽ ലഭ്യമാണ്) ഈ പാഠത്തിന്റെ ആദ്യ ഭാഗത്തിലെ മെറ്റീരിയൽ പ്രചോദനം ഉൾക്കൊണ്ടതാണ്. വായനക്കാരൻ സ്വന്തമാക്കിയാൽ ആംഗലേയ ഭാഷ, അപ്പോൾ ഞങ്ങൾ അത് വായിക്കാൻ ശുപാർശ ചെയ്യുന്നു.

ലിങ്ക്ഡ് ലൈബ്രറികൾ

മൈക്രോസോഫ്റ്റിന്റെ ഓപ്പൺജിഎൽ നടപ്പിലാക്കുന്നതിൽ ഉൾപ്പെടുന്നു മുഴുവൻ സെറ്റ് OpenGL കമാൻഡുകൾ, അതായത് ആഗോള പ്രവർത്തനങ്ങൾ, OPENGL32.LIB ലൈബ്രറിയുടെ കോർ ഉൾപ്പെടുത്തി പ്രിഫിക്‌സ് ഉണ്ട് gl(ഉദാ. glLineWidth). കോർ ലൈബ്രറി ഫംഗ്‌ഷനുകൾക്ക് ഒന്നിലധികം പതിപ്പുകൾ ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക, നിങ്ങൾക്ക് ഇഷ്ടമുള്ള രീതിയിൽ ആവശ്യമുള്ള പാരാമീറ്റർ അല്ലെങ്കിൽ ക്രമീകരണം വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. glColor* കുടുംബത്തിലെ പ്രവർത്തനങ്ങൾക്കുള്ള സഹായം കാണുക. നിങ്ങൾക്ക് നിലവിലെ നിറം 32 വഴികളിൽ സജ്ജമാക്കാൻ കഴിയുമെന്ന് ഇത് മാറുന്നു. ഉദാഹരണത്തിന്, പ്രവർത്തനം:

അസാധുവായ glColorSb (GLbyte ചുവപ്പ്, GLbyte പച്ച, GLbyte നീല);

GLbyte തരത്തിന്റെ മൂന്ന് ഘടകങ്ങളും ഫംഗ്‌ഷനും ഉപയോഗിച്ച് ഒരു നിറം നിർവചിക്കുന്നു:

അസാധുവായ glColor4dv (const GLdouble *v);

നാല് ഘടകങ്ങളുടെ ഒരു ശ്രേണിയുടെ വിലാസം ഉപയോഗിച്ച് ഇത് വ്യക്തമാക്കുന്നു.

ഈ ഓപ്ഷനുകൾ കണക്കിലെടുക്കുമ്പോൾ, കോർ ലൈബ്രറിയിൽ 300-ലധികം കമാൻഡുകൾ അടങ്ങിയിരിക്കുന്നു. കൂടാതെ, പ്രധാന കേർണലിനെ പൂരകമാക്കുന്ന യൂട്ടിലിറ്റികളുടെ GLU32.LIB ലൈബ്രറി നിങ്ങൾക്ക് ബന്ധിപ്പിക്കാൻ കഴിയും. ടെക്സ്ചറുകൾ നിയന്ത്രിക്കൽ, കോർഡിനേറ്റ് പരിവർത്തനം, ഗോളങ്ങൾ, സിലിണ്ടറുകളും ഡിസ്കുകളും സൃഷ്ടിക്കൽ, വളവുകളുടെയും പ്രതലങ്ങളുടെയും സ്പ്ലൈൻ ഏകദേശങ്ങൾ ( NURBS - നോൺ-യൂണിഫോം റേഷണൽ ബി-സ്പ്ലിൻ), അതുപോലെ പിശക് കൈകാര്യം ചെയ്യൽ. ഒരെണ്ണം കൂടി, അധിക ( സഹായകമായ) GLAUX.LIB ലൈബ്രറി അനുവദിക്കുന്നു ലളിതമായ രീതിയിൽവിൻഡോസ് വിൻഡോകൾ സൃഷ്ടിക്കുക, ചില SD ഒബ്‌ജക്റ്റുകൾ പ്രദർശിപ്പിക്കുക, ഇൻപുട്ട് ഇവന്റുകൾ കൈകാര്യം ചെയ്യുക, നിയന്ത്രിക്കുക പശ്ചാത്തല പ്രക്രിയ. നിർഭാഗ്യവശാൽ, ഈ ലൈബ്രറി രേഖപ്പെടുത്തപ്പെട്ടിട്ടില്ല. മൈക്രോസോഫ്റ്റ് കമ്പനിവാണിജ്യ പ്രോജക്റ്റുകൾ വികസിപ്പിക്കുന്നതിന് ഇത് ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നില്ല, കാരണം അതിൽ സന്ദേശ പ്രോസസ്സിംഗ് ലൂപ്പ് കോഡ് അടങ്ങിയിരിക്കുന്നു, അതിൽ മറ്റ് അനിയന്ത്രിതമായ സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നത് അസാധ്യമാണ്.

കുറിപ്പ്
GLbyte തരം സൈൻ ചെയ്ത ചാർ തരത്തിന് തുല്യമാണ്, GLdouble എന്നത് ഇരട്ട തരത്തിന് തുല്യമാണ്. മറ്റ് പ്ലാറ്റ്‌ഫോമുകളിലേക്ക് പോർട്ടബിലിറ്റി ലളിതമാക്കാൻ സ്വന്തം തരങ്ങൾ ഉപയോഗിക്കുന്നു. ഞങ്ങൾ OpenGL തരങ്ങളുടെ ഒരു ലിസ്റ്റ് ചുവടെ നൽകുന്നു. നാലാമത്തെ വർണ്ണ ഘടകം നിറത്തിന്റെ സുതാര്യത നിർണ്ണയിക്കുന്നു, അങ്ങനെയാണ് പശ്ചാത്തല വർണ്ണം ചിത്രത്തിന്റെ നിറവുമായി ലയിക്കുന്നത്. ചില ഓപ്പൺജിഎൽ കമാൻഡുകൾക്ക് അവസാനം ഒരു v ഉണ്ട്, ഇത് ആർഗ്യുമെന്റ് ഒരു അറേയുടെ (വെക്റ്റർ) വിലാസമായിരിക്കണമെന്ന് സൂചിപ്പിക്കുന്നു. ഗണിതത്തിലെ ഒരു വെക്റ്റർ എന്നത് വെക്റ്റർ സ്പേസിന്റെ ഒരു മൂലകത്തെ അദ്വിതീയമായി നിർവചിക്കുന്ന സംഖ്യകളുടെ (കോർഡിനേറ്റുകൾ) ഒരു ശ്രേണിയാണ്. പല കമാൻഡുകൾക്കും ഒന്നിലധികം പതിപ്പുകൾ ഉണ്ട്, ആത്യന്തികമായി ഒരു വെക്റ്റർ വ്യത്യസ്ത രീതികളിൽ വ്യക്തമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഓപ്പൺജിഎല്ലിൽ പ്രവർത്തിക്കാൻ ഇരുപതോളം വിൻഡോസ് ജിഡിഐ ഫംഗ്ഷനുകൾ പ്രത്യേകം സൃഷ്ടിച്ചിട്ടുണ്ട്. അവയിൽ മിക്കതിനും പ്രിഫിക്സ് ഉണ്ട് wgl(വിൻഡോസ് ജിഎൽ എന്നതിന്റെ ചുരുക്കെഴുത്ത്). ഓപ്പൺജിഎലിനെ എക്സ് വിൻഡോ സിസ്റ്റം പ്ലാറ്റ്‌ഫോമിലേക്ക് ബന്ധിപ്പിക്കുന്ന ഗ്എൽഎക്‌സ് പ്രിഫിക്‌സ് ചെയ്‌ത ഫംഗ്‌ഷനുകളുടെ അനലോഗുകളാണ് ഈ ഫംഗ്‌ഷനുകൾ. അവസാനമായി, പിക്സൽ ഫോർമാറ്റ് നിയന്ത്രിക്കുന്നതിന് നിരവധി Win32 ഫംഗ്ഷനുകൾ ഉണ്ട് ഇരട്ട ബഫർ. അവ പ്രത്യേക ഓപ്പൺജിഎൽ വിൻഡോകൾക്ക് മാത്രമേ ബാധകമാകൂ.

നിങ്ങൾ എന്റെ ആദ്യത്തെ OpenGL ട്യൂട്ടോറിയൽ വായിക്കുകയാണ്!

നിങ്ങൾ OpenGL സ്വയം പഠിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, കോഡ് എങ്ങനെ കംപൈൽ ചെയ്യാം, അത് പ്രവർത്തിപ്പിക്കുക, ഏറ്റവും പ്രധാനമായി, ഈ പാഠങ്ങളിൽ നൽകിയിരിക്കുന്ന സോഴ്‌സ് കോഡുകൾ എങ്ങനെ പരീക്ഷിക്കാം എന്ന് നിങ്ങളോട് പറയുന്നതാണ് നല്ലതെന്ന് എനിക്ക് തോന്നുന്നു.

നിങ്ങൾ അറിയേണ്ടത്

പ്രോഗ്രാമിംഗിനെക്കുറിച്ച് പ്രത്യേക അറിവില്ലാതെ ഈ പാഠങ്ങൾ വായനക്കാരനെ ലക്ഷ്യം വച്ചുള്ളതാണ്. തീർച്ചയായും, ഏതെങ്കിലും പ്രോഗ്രാമിംഗ് ഭാഷയെക്കുറിച്ചുള്ള അറിവ് (C, Java, Lisp, JavaSript) ഒരു വലിയ പ്ലസ് ആയിരിക്കും, എന്നാൽ ഇത് ആവശ്യമില്ല, നിങ്ങൾ ഒരേ സമയം രണ്ട് വിഷയങ്ങൾ പഠിക്കേണ്ടതുണ്ട് - 3D ഗ്രാഫിക്സും പ്രോഗ്രാമിംഗും.

ഈ പാഠങ്ങളിലെ എല്ലാ കോഡുകളും സാധ്യമായ ഏറ്റവും ലളിതമായ ശൈലിയിൽ C++ ൽ എഴുതിയിരിക്കുന്നു. ടെംപ്ലേറ്റുകളോ ക്ലാസുകളോ പോയിന്റർ ഗണിതമോ ഇല്ല. അതിനാൽ, കോഡ് നോക്കുമ്പോൾ, നിങ്ങൾക്ക് JavaSript പരിചയമുണ്ടെങ്കിൽ പോലും, അത് എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്ക് മനസിലാക്കാൻ കഴിയും.

OpenGL 1/2 നെ കുറിച്ച് നിങ്ങൾക്കറിയാവുന്നതെല്ലാം മറക്കുക

3D ഗ്രാഫിക്സിനെക്കുറിച്ച് നിങ്ങൾക്ക് ഒന്നും അറിയില്ലെന്ന് ഈ പാഠങ്ങൾ അനുമാനിക്കുന്നു. എന്നാൽ നിങ്ങൾ OpenGL ട്യൂട്ടോറിയലുകൾ വായിക്കുകയും glBegin() പോലെയുള്ള എന്തെങ്കിലും കാണുകയും ചെയ്താൽ അത് മറക്കുക. ഇവിടെ ഞങ്ങൾ OpenGL 3 ഉം 4 ഉം പഠിക്കും, നിങ്ങൾ വായിക്കുന്നത് OpenGL 1 അല്ലെങ്കിൽ 2 ന് ബാധകമാണ്. അതിനാൽ, നിങ്ങൾ മുമ്പ് അറിഞ്ഞിരുന്നതെല്ലാം മറക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു, അല്ലെങ്കിൽ നിങ്ങളുടെ മസ്തിഷ്കം പൊരുത്തക്കേടുകളിൽ നിന്ന് ഉരുകാൻ തുടങ്ങും.

പദ്ധതി നിർമ്മിക്കുന്നത്

ഈ പാഠങ്ങളിൽ നിന്നുള്ള കോഡ് വിൻഡോസിനും ലിനക്സിനും വേണ്ടി കംപൈൽ ചെയ്യാവുന്നതാണ്. ഏതെങ്കിലും പ്ലാറ്റ്‌ഫോമുകൾക്കായി കോഡ് കംപൈൽ ചെയ്യാൻ ആരംഭിക്കുന്നതിന്, നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യേണ്ടതുണ്ട്:

1. നിങ്ങളുടെ വീഡിയോ കാർഡിനുള്ള ഡ്രൈവറുകൾ അപ്‌ഡേറ്റ് ചെയ്യുക!! ഞാൻ നിങ്ങൾക്ക് മുന്നറിയിപ്പ് നൽകി :)
2. നിങ്ങൾക്ക് ഇതിനകം കംപൈലർ ഇല്ലെങ്കിൽ അത് ഡൗൺലോഡ് ചെയ്യുക.
3. CMake ഇൻസ്റ്റാൾ ചെയ്യുക
4. റെഡിമെയ്ഡ് പാഠ ഉറവിടങ്ങൾ ഡൗൺലോഡ് ചെയ്യുക.
5. CMake ഉപയോഗിച്ച് പ്രോജക്റ്റ് സൃഷ്ടിക്കുക
6. പദ്ധതി കൂട്ടിച്ചേർക്കുക.
7. അവിടെ എന്താണ് സംഭവിക്കുന്നതെന്ന് നന്നായി മനസ്സിലാക്കാൻ കോഡ് ഉപയോഗിച്ച് പരീക്ഷിക്കുക.

ഓരോ പ്ലാറ്റ്‌ഫോമിനുമുള്ള അസംബ്ലിംഗ് പ്രോജക്‌റ്റുകളുടെ കൂടുതൽ വിശദമായ വിവരണം ഞാൻ ചുവടെ നൽകിയിരിക്കുന്നു. എന്നാൽ OS പതിപ്പിനെ ആശ്രയിച്ച്, സ്ക്രീൻഷോട്ടുകൾ നിങ്ങളുടെ സ്ക്രീനിൽ ദൃശ്യമാകുന്നതിൽ നിന്ന് അല്പം വ്യത്യാസപ്പെട്ടിരിക്കാം, എന്നാൽ പൊതുവേ, എല്ലാം ഏകദേശം സമാനമായിരിക്കണം.

വിൻഡോസിനായുള്ള അസംബ്ലി

ലിനക്സിനായി നിർമ്മിക്കുക

ലോകത്ത് ലിനക്സിന്റെ വ്യത്യസ്ത വ്യതിയാനങ്ങളുടെ ഒരു വലിയ സംഖ്യയുണ്ട്, അതിനാൽ ഓരോന്നിനും ഒരു പ്രോജക്റ്റ് കൂട്ടിച്ചേർക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ നൽകാൻ ഞാൻ ആഗ്രഹിക്കുന്നില്ല. ചുവടെ വിവരിച്ചിരിക്കുന്നതുപോലെ എന്തെങ്കിലും പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ഡോക്യുമെന്റേഷൻ വായിക്കുക അല്ലെങ്കിൽ ഇന്റർനെറ്റിൽ തിരയുക.

1. ഇൻസ്റ്റാൾ ചെയ്യുക ഏറ്റവും പുതിയ ഡ്രൈവറുകൾനിങ്ങളുടെ വീഡിയോ കാർഡിലേക്ക്. നോൺ-ഓപ്പൺ സോഴ്‌സ് ഡ്രൈവറുകൾ ഞാൻ വളരെ ശുപാർശ ചെയ്യുന്നു. അവ ഗ്നുവിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല, പക്ഷേ അവ പലപ്പോഴും മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു. നിങ്ങളുടെ Linux ബിൽഡ് നൽകുന്നില്ലെങ്കിൽ ഓട്ടോമാറ്റിക് ഇൻസ്റ്റാളർ, ഉബുണ്ടുവിന്റെ ഗൈഡ് വായിക്കാൻ ശ്രമിക്കുക.
2. എല്ലാം ഉപയോഗിച്ച് കമ്പൈലർ ഇൻസ്റ്റാൾ ചെയ്യുക ആവശ്യമായ ലൈബ്രറികൾഉപകരണങ്ങളും. നിങ്ങൾക്ക് ആവശ്യമുള്ളതിന്റെ ഒരു ലിസ്റ്റ് ഇതാ: cmake make g++ libx11-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev. sudo apt-get install ***** അല്ലെങ്കിൽ su /yum ഇൻസ്റ്റാൾ ****** ഉപയോഗിക്കുക
3. ഉദാഹരണ ഉറവിടങ്ങൾ ഡൗൺലോഡ് ചെയ്ത് ഒരു ഫോൾഡറിലേക്ക് അൺസിപ്പ് ചെയ്യുക, ഉദാഹരണത്തിന് ~/Projects/OpenGLTutorials/
4. ~/Projects/OpenGLTutorials/ എന്നതിലേക്ക് പോയി ഇനിപ്പറയുന്ന കമാൻഡുകൾ നൽകുക:

• mkdir ബിൽഡ്

• സിഡി ബിൽഡ്

• സിമേക്ക്..

1. മുമ്പത്തെ കമാൻഡുകൾ വിജയകരമായി നടപ്പിലാക്കുകയാണെങ്കിൽ, ബിൽഡ്/ഫോൾഡറിൽ ഒരു മേക്ക് ഫയൽ സൃഷ്ടിക്കപ്പെടും
2. "എല്ലാം ഉണ്ടാക്കുക" എന്ന് നൽകുക, അതിനുശേഷം എല്ലാ ഉദാഹരണങ്ങളും അവയുടെ ആശ്രിതത്വങ്ങളും കംപൈൽ ചെയ്യപ്പെടും. പിശകുകളൊന്നുമില്ലെങ്കിൽ, തയ്യാറാണ് എക്സിക്യൂട്ടബിൾ ഫയലുകൾ~/Projects/OpenGLTutorials/ ഫോൾഡറിൽ സ്ഥാപിക്കും

QtCreator IDE ഉപയോഗിക്കുന്നത് എനിക്ക് വളരെ ഇഷ്ടമാണ്. ഈ ഐഡിഇയ്ക്ക് CMake ഔട്ട് ഓഫ് ദി ബോക്‌സിനൊപ്പം പ്രവർത്തിക്കാനും ഡീബഗ്ഗിംഗ്, സ്വയമേവ പൂർത്തിയാക്കൽ മുതലായ മറ്റ് ഗുണങ്ങൾ നൽകാനും കഴിയും.

QtCreator-ൽ ഒരു പ്രോജക്റ്റ് നിർമ്മിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ:

1. QtCreator ക്ലിക്ക് ചെയ്യുക ഫയൽ-> ടൂളുകൾ-> ഓപ്‌ഷനുകൾ-> കംപൈൽ&എക്‌സിക്യൂട്ട്->CMake

2. CMake-ലേക്കുള്ള പാത വ്യക്തമാക്കുക. ഇത് മിക്കവാറും /usr/bin/cmake ആയിരിക്കും

3. ഫയൽ->പ്രോജക്റ്റ് തുറന്ന് ട്യൂട്ടോറിയലുകൾ/CMakeLists.txt തിരഞ്ഞെടുക്കുക

4. ബിൽഡ് ഫോൾഡർ വ്യക്തമാക്കുക, ഫോൾഡർ ട്യൂട്ടോറിയൽ ഫോൾഡറിന് പുറത്തായിരിക്കണം.

5. ഓപ്ഷണലായി സജ്ജീകരിക്കുക –DCMAKE_BUILD_TYPE=ഓപ്‌ഷൻ ഫീൽഡിൽ ഡീബഗ് ചെയ്യുക.

6. ക്ലിക്ക് ചെയ്യുക താഴെ ചുറ്റികയിൽ.ഇതിനുശേഷം, ട്യൂട്ടോറിയലുകൾ/ഫോൾഡറിൽ നിന്ന് ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കാം

7. QtCreator-ൽ നിന്നുള്ള ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിന്, Projects ->Execution parameters ->Working Directory തിരഞ്ഞെടുക്കുക, ടെക്സ്ചറും മോഡൽ ഷേഡറുകളും സ്ഥിതി ചെയ്യുന്ന ഡയറക്ടറി തിരഞ്ഞെടുക്കുക. ട്യൂട്ടോറിയൽ 2-ന് ഇത് ~/opengl -tutorial /tutorial02_red_triangle/ ആയിരിക്കും

റണ്ണിംഗ് ഉദാഹരണങ്ങൾ

പ്രോജക്റ്റ് കംപൈൽ ചെയ്തുകഴിഞ്ഞാൽ, ഡയറക്ടറിയിൽ നിന്ന് നേരിട്ട് ആപ്ലിക്കേഷനുകൾ സമാരംഭിക്കാനാകും.
നിങ്ങൾക്ക് IDE-യിൽ നിന്ന് നേരിട്ട് ഉദാഹരണങ്ങൾ പ്രവർത്തിപ്പിക്കണമെങ്കിൽ, പ്രവർത്തിക്കുന്ന ഡയറക്ടറി ശരിയായി സജ്ജീകരിക്കുന്നതിന് മുകളിലുള്ള നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുക.

ഈ പാഠങ്ങൾ എങ്ങനെ എടുക്കാം

ഓരോ പാഠവും വരുന്നു സോഴ്സ് കോഡ്ഡാറ്റയും. ഈ ഫയലുകളെല്ലാം അനുബന്ധ ട്യൂട്ടോറിയൽXX/ ഡയറക്ടറിയിൽ കാണാം.

എന്നാൽ ഈ ഫയലുകളിൽ ഒന്നും മാറ്റരുതെന്ന് ഞാൻ ശുപാർശ ചെയ്യുന്നു, അവ റഫറൻസിനായി മാത്രം. പ്ലേഗ്രൗണ്ട്/പ്ലേഗ്രൗണ്ട്.സിപിപിയിൽ കളിക്കുന്നതും അവിടെ നിങ്ങൾക്ക് ആവശ്യമുള്ളത് മാറ്റുന്നതും നല്ലതാണ്. നിങ്ങൾ എന്തെങ്കിലും തകർക്കുകയും അത് വീണ്ടെടുക്കാൻ കഴിയാതെ വരികയും ചെയ്താൽ, മറ്റേതെങ്കിലും പാഠത്തിൽ നിന്ന് പകർത്തി നിങ്ങൾക്ക് ഈ ഫയൽ തിരികെ നൽകാം.

നിങ്ങൾ ഈ ട്യൂട്ടോറിയലുകൾ വായിക്കുമ്പോൾ, നിങ്ങൾ എല്ലായിടത്തും കോഡിന്റെ ബിറ്റുകൾ കാണും. അവ പ്രവർത്തനക്ഷമമായി കാണുന്നതിന് playground.cpp-ലേക്ക് പകർത്താൻ മടിക്കേണ്ടതില്ല - പരീക്ഷണം എപ്പോഴും നല്ലതാണ്. ഞാൻ വീണ്ടും പറയാം, വെറുതെ വായിക്കരുത്. തയ്യാറായ കോഡ്, അത് സമാരംഭിക്കാൻ ശ്രമിക്കുക. സോഴ്സ് കോഡ് വായിച്ചുകൊണ്ട് നിങ്ങൾക്ക് കാര്യമായൊന്നും പഠിക്കാൻ കഴിയില്ല. ലളിതമായ കോപ്പി-പേസ്റ്റിംഗ് ഉപയോഗിച്ച് പോലും, നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം ബക്കറ്റ് പ്രശ്നങ്ങൾ ലഭിക്കും, അത് പരിഹരിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് ആവശ്യമായ അനുഭവം ലഭിക്കും.

ജനൽ തുറക്കുന്നു

ഒടുവിൽ! ഓപ്പൺജിഎൽ!

എന്നിരുന്നാലും, നിങ്ങൾ കുറച്ച് കൂടി കാത്തിരിക്കേണ്ടിവരും. എല്ലാ പാഠങ്ങളിലും, 3D പ്രവർത്തനങ്ങൾ വളരെ താഴ്ന്ന നിലയിലായിരിക്കും, അതിനാൽ നിങ്ങൾക്ക് മാന്ത്രികത ഉണ്ടാകില്ല. എന്നിരുന്നാലും, സിസ്റ്റം വിൻഡോകളും സന്ദേശങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് താൽപ്പര്യമില്ലാത്തതും വിരസവുമാണ്, അതിനാൽ ഞങ്ങൾക്ക് വേണ്ടി വൃത്തികെട്ട ജോലി ചെയ്യാൻ ഞങ്ങൾ GLFW ലൈബ്രറിയെ അനുവദിക്കും. നിങ്ങൾക്ക് ശരിക്കും താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് Windows-നായി Win32 Api അല്ലെങ്കിൽ Linux-ന് X11 API ഉപയോഗിക്കാം, അല്ലെങ്കിൽ SFML, FreeGLUT, SDL, ... ലിങ്ക് പേജ് വായിക്കുക.

ശരി, നമുക്ക് ഇതിനകം ആരംഭിക്കാം. നമുക്ക് ഡിപൻഡൻസികളെ ബന്ധിപ്പിക്കേണ്ടതുണ്ട് എന്ന വസ്തുതയിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം. ഞങ്ങൾക്ക് കൺസോളിലേക്ക് സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യേണ്ടതിനാൽ, ഞങ്ങൾ ഇനിപ്പറയുന്നവ എഴുതും:

// സാധാരണ തലക്കെട്ടുകൾ ബന്ധിപ്പിക്കുന്നു

#ഉൾപ്പെടുന്നു

#ഉൾപ്പെടുന്നു

അപ്പോൾ നമ്മൾ GLEW കണക്ട് ചെയ്യുന്നു

//അത് നമ്മൾ മറക്കരുത് GLEW മുമ്പ് ബന്ധിപ്പിച്ചിരിക്കണം gl . എച്ച് അഥവാ glfw . എച്ച്

#ഉൾപ്പെടുന്നു

അപ്പോൾ നമ്മൾ GLFW കണക്ട് ചെയ്യുന്നു. ഈ ലൈബ്രറി എല്ലാ വിൻഡോ മാനേജ്‌മെന്റ് മാജിക്കും ചെയ്യും.

#ഉൾപ്പെടുന്നു

ഓൺ ഈ ഘട്ടത്തിൽഞങ്ങൾക്ക് ഈ ലൈബ്രറി ആവശ്യമില്ല, പക്ഷേ അതിൽ ഗണിത പ്രവർത്തനങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ഞങ്ങൾക്ക് ഇത് ഉടൻ ആവശ്യമാണ്. GLM-ൽ മാജിക് ഒന്നുമില്ല, നിങ്ങൾക്ക് ശരിക്കും വേണമെങ്കിൽ, മെട്രിക്സുകളിലും വെക്റ്ററുകളിലും പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് മറ്റേതെങ്കിലും ലൈബ്രറി ഉപയോഗിക്കാം. "glm::vec3" എന്നല്ല "vec3" എന്ന് എഴുതാൻ "നെയിംസ്പേസ് ഉപയോഗിക്കുന്നത്" ഞങ്ങൾ ഉൾപ്പെടുത്തുന്നു.

#ഉൾപ്പെടുന്നു

നെയിംസ്പേസ് glm ഉപയോഗിക്കുന്നു;

നിങ്ങൾ ഈ കോഡിന്റെ ഭാഗങ്ങൾ playground.cpp-ലേക്ക് പകർത്തുകയാണെങ്കിൽ, പ്രധാന() ഫംഗ്‌ഷൻ ഇല്ലെന്ന് കംപൈലർ പരാതിപ്പെടാൻ തുടങ്ങും. അതിനാൽ നമുക്ക് കൂട്ടിച്ചേർക്കാം:

int main())(

ആദ്യം GLFW ആരംഭിക്കുന്നതാണ് നല്ലത്:

// ആരംഭിക്കുക GLFW

എങ്കിൽ(!glfwInit())

{

fprintf(stderr, "GLFW ആരംഭിക്കുന്നതിൽ പരാജയപ്പെട്ടു\n");

മടക്കം -1;

}

ഇനി നമുക്ക് നമ്മുടെ OpenGL വിൻഡോ സൃഷ്ടിക്കാം:

glfwOpenWindowHint( GLFW_ എഫ്എസ്എഎ_ സാമ്പിളുകൾ, 4); // 4 xമിനുസപ്പെടുത്തുന്നു

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); //ഞങ്ങളെ ആവശ്യമുണ്ട് OpenGL 3.3

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);

glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // ഞങ്ങളെ അല്ല ആവശ്യമുണ്ട് പഴയത് ഓപ്പൺജിഎൽ

// നമുക്ക് ഒരു വിൻഡോ തുറന്ന് ഒരു സന്ദർഭം സൃഷ്ടിക്കാം

if(!glfwOpenWindow(1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW))

{

fprintf(stderr, "GLFW വിൻഡോ തുറക്കുന്നതിൽ പരാജയപ്പെട്ടു\n");