విషయము

• దశలు
• పార్ట్ 1 ఆఫ్ 3: ప్రారంభ సంస్థాపన
• పార్ట్ 2 ఆఫ్ 3: డిస్‌ప్లే () ఫంక్షన్
• పార్ట్ 3 ఆఫ్ 3: ప్రోగ్రామ్ ఇంటరాక్టివిటీ

OpenGL అనేది ఒక 3D ప్రోగ్రామింగ్ సాధనం, ఇది సాధారణ ఆకారాల నుండి సంక్లిష్టమైన 3D చిత్రాలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఈ వ్యాసంలో, అతని సహాయంతో మూడు కోణాలలో తిప్పగలిగే ఒక సాధారణ క్యూబ్‌ను ఎలా గీయాలి అని మీరు నేర్చుకుంటారు!

దశలు

పార్ట్ 1 ఆఫ్ 3: ప్రారంభ సంస్థాపన

1. 1 OpenGL ని ఇన్‌స్టాల్ చేయండి. మీ కంప్యూటర్‌లో OpenGL ని ఎలా ఇన్‌స్టాల్ చేయాలో ట్యుటోరియల్‌తో ప్రారంభించండి. మీరు ఇప్పటికే OpenGL మరియు C కంపైలర్ కలిగి ఉంటే, మీరు ఈ దశను దాటవేసి, తదుపరి దశకు వెళ్లవచ్చు.
2. 2 ఒక పత్రాన్ని సృష్టించండి. మీకు ఇష్టమైన కోడ్ ఎడిటర్‌లో కొత్త ఫైల్‌ను క్రియేట్ చేయండి మరియు దానిని mycube.c గా సేవ్ చేయండి
3. 3 #చేర్చండి. మీకు అవసరమైన ప్రాథమిక #చేర్చబడిన ఆదేశాలు ఇక్కడ ఉన్నాయి. విభిన్న ఆపరేటింగ్ సిస్టమ్‌ల కోసం ఆదేశాలు విభిన్నంగా ఉన్నాయని గుర్తుంచుకోవడం ముఖ్యం, అందువల్ల ప్రోగ్రామ్ సార్వత్రికంగా మరియు ఏ సిస్టమ్‌లోనైనా అమలు చేయడానికి మీరు ప్రతిదాన్ని ఎంచుకోవాలి.

   // #స్టూడియోను చేర్చండి.

4. 4 ఫంక్షనల్ ప్రోటోటైప్స్ మరియు గ్లోబల్స్ జోడించండి. తదుపరి దశ ఫంక్షనల్ ప్రోటోటైప్‌లను ప్రకటించడం.

   // ఫంక్షనల్ ప్రోటోటైప్స్ శూన్య ప్రదర్శన (); శూన్యమైన ప్రత్యేక కీలు (); // గ్లోబల్ వేరియబుల్స్ డబుల్ రొటేట్_ y = 0; డబుల్ రొటేట్_ఎక్స్ = 0;

5. 5 ప్రధాన () ఫంక్షన్‌ను నిర్వచించండి.

   int ప్రధాన (int argc, char * argv []) // GLUT ని ప్రారంభించండి మరియు కస్టమ్ పారామితులను గ్లూట్ఇనిట్ ప్రాసెస్ చేయండి (& argc, argv); // డబుల్ బఫరింగ్, Z- బఫరింగ్ మరియు ట్రూ కలర్ గ్లుట్ కోసం మద్దతుతో విండోను అభ్యర్థించండిInitDisplayMode (GLUT_DOUBLE

పార్ట్ 2 ఆఫ్ 3: డిస్‌ప్లే () ఫంక్షన్

1. 1 ప్రదర్శన () ఫంక్షన్ యొక్క ఉద్దేశ్యాన్ని అర్థం చేసుకోండి. క్యూబ్‌ను అందించే పని అంతా ఈ ఫంక్షన్ యొక్క పెళుసుగా ఉండే లైన్‌లపై పడుతుంది. సాధారణ ఆలోచన ఇది: మీరు క్యూబ్ యొక్క ఆరు ప్రత్యేక ముఖాలను గీయండి మరియు వాటిని వాటి స్థానాల్లో ఉంచుతారు.
   • ప్రతి ముఖం కోసం, మీరు నాలుగు మూలలను నిర్వచిస్తారు మరియు OpenGL వాటిని లైన్‌లతో కనెక్ట్ చేస్తుంది మరియు వాటిని మీరు ఎంచుకున్న రంగుతో నింపుతుంది. దీన్ని ఎలా చేయాలో క్రింద వివరించబడుతుంది.
2. 2 GlClear () ఫంక్షన్‌ను జోడించండి. అన్నింటిలో మొదటిది, ఈ ఫంక్షన్‌తో పనిచేసేటప్పుడు, మాకు అవసరం స్పష్టమైన రంగు మరియు z- బఫర్... ఇది లేకుండా, కొత్త చిత్రం కింద పాతది కనిపిస్తుంది మరియు ప్రోగ్రామ్ ద్వారా గీసిన వస్తువులు తప్పుగా ఉంచబడతాయి.

   శూన్య ప్రదర్శన () // స్క్రీన్ మరియు Z బఫర్ glClear క్లియర్ చేయండి (GL_COLOR_BUFFER_BIT

   • చివరి రెండు పంక్తులపై శ్రద్ధ వహించండి. ఇవి విధులు గ్లోఫ్లష్ (); మరియు గ్లుట్ స్వాప్ బఫర్స్ ();, డబుల్ బఫరింగ్ ప్రభావాన్ని ఇస్తోంది, ఇది పైన వివరించబడింది.

పార్ట్ 3 ఆఫ్ 3: ప్రోగ్రామ్ ఇంటరాక్టివిటీ

1. 1 ప్రత్యేక కీలు () ఫంక్షన్‌ను జోడించండి. సూత్రప్రాయంగా, ప్రతిదీ దాదాపు సిద్ధంగా ఉంది, కానీ క్యూబ్ మాత్రమే డ్రా చేయబడుతుంది మరియు తిప్పబడదు. దీన్ని చేయడానికి, మీరు సృష్టించాలి ప్రత్యేక కీలు () ఫంక్షన్, బాణం కీలను నొక్కడం ద్వారా క్యూబ్‌ను తిప్పడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది!
   • ఈ ఫంక్షన్ కోసం గ్లోబల్ వేరియబుల్స్ rotate_x మరియు rotate_y ప్రకటించబడ్డాయి. మీరు ఎడమ మరియు కుడి బాణం కీలను నొక్కినప్పుడు, rotate_y విలువ ఐదు డిగ్రీలు పెరుగుతుంది లేదా తగ్గుతుంది. Rotate_x విలువ అదే విధంగా మారుతుంది, కానీ ఈసారి పైకి క్రిందికి బాణం కీలను నొక్కడం ద్వారా.

   శూన్యమైన ప్రత్యేక కీలు (int కీ, int x, int y) {// కుడి బాణం - భ్రమణాన్ని 5 డిగ్రీలు పెంచండి (కీ == GLUT_KEY_RIGHT) తిరుగుతూ_y + = 5; // ఎడమ బాణం - (కీ == GLUT_KEY_LEFT) రొటేట్_y - = 5 అయితే 5 డిగ్రీల ద్వారా భ్రమణాన్ని తగ్గించండి లేకపోతే (కీ == GLUT_KEY_UP) rotate_x + = 5; లేకపోతే (కీ == GLUT_KEY_DOWN) rotate_x - = 5; // స్క్రీన్ రిఫ్రెష్ గ్లుట్‌పోస్ట్‌రెడిస్ప్లే () కోసం అభ్యర్థన; }

2. 2 గ్లోరోటేట్ () జోడించండి. మేము చేసే చివరి విషయం ఏమిటంటే వస్తువును తిప్పడానికి అనుమతించే ఒక లైన్‌ను జోడించడం. ఫంక్షన్‌కు తిరిగి వెళ్ళు ప్రదర్శన () మరియు ముందు వైపు వివరణకు ముందు జోడించండి:

   // రీసెట్ ట్రాన్స్‌ఫార్మ్స్ గ్లోడ్ ఐడెంటిటీ (); // వినియోగదారు మారినప్పుడు తిప్పండి విలువలు rotate_x మరియు rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (రొటేట్_వై, 0.0, 1.0, 0.0); // మల్టీకలర్ సైడ్ - ఫ్రంట్ ....

   • వాక్యనిర్మాణం దయచేసి గమనించండి గ్లోరోటేఫ్ ()ఇది glColor3f () మరియు glVertex3f () యొక్క వాక్యనిర్మాణానికి సమానంగా ఉంటుంది, కానీ ఎల్లప్పుడూ నాలుగు పారామితులు అవసరం. మొదటిది డిగ్రీలలో భ్రమణ కోణం. తరువాతి మూడు భ్రమణం జరిగే అక్షాలు, x, y, z క్రమంలో. ప్రస్తుతానికి, మేము క్యూబ్‌ను రెండు అక్షాలు, x మరియు y లతో తిప్పాలి.
   • ప్రోగ్రామ్‌లో మేము నిర్వచించే అన్ని పరివర్తనలకు ఇలాంటి పంక్తులు అవసరం. ప్రాథమికంగా, x- అక్షం వెంట ఒక వస్తువు యొక్క భ్రమణాన్ని రొటేట్_ x విలువలో మార్పుగా మరియు y- అక్షం వెంట భ్రమణాన్ని రొటేట్_య్ విలువలో మార్పుగా సూచిస్తాము. అయితే, OpenGL ప్రతిదీ ఒక పరివర్తన మాతృకగా కలుపుతుంది. ప్రతిసారి మీరు డిస్‌ప్లేకి కాల్ చేసినప్పుడు, మీరు పరివర్తన మాతృకను సృష్టిస్తారు, మరియు గ్లోడ్ గుర్తింపు () ప్రతిసారి కొత్త మాతృకతో ప్రారంభించడానికి మిమ్మల్ని అనుమతిస్తుంది.
   • మీరు ఉపయోగించిన ఇతర పరివర్తన విధులు glTranslatef () మరియు glScalef (). అవి glRotatef () కు సమానంగా ఉంటాయి, వాటికి కేవలం మూడు పారామితులు మాత్రమే అవసరం: x, y మరియు z విలువలు పరిమాణాన్ని మార్చడానికి మరియు స్కేల్ చేయడానికి.
   • ఒక వస్తువుపై మూడు పరివర్తనాలు వర్తింపజేయబడినప్పుడు ప్రతిదీ సరిగ్గా ప్రదర్శించబడాలంటే, మీరు పరివర్తనలను తగిన క్రమంలో సెట్ చేయాలి, అవి glTranslate, glRotate, glScale - మరియు ఎప్పుడూ లేకపోతే. OpenGL ప్రోగ్రామ్‌ను దిగువ నుండి పైకి చదవడం ద్వారా వస్తువును మారుస్తుంది. దీన్ని బాగా అర్థం చేసుకోవడానికి, ఓపెన్‌జిఎల్ చూపిన క్రమంలో (పై నుండి క్రిందికి) వాటిని వర్తింపజేస్తే 1x1x1 క్యూబ్ అన్ని పరివర్తనలను ఎలా చూసుకుంటుందో ఊహించండి, ఆపై దిగువ నుండి పై వరకు సూచనలను చదవడం ద్వారా OpenGL క్యూబ్‌ను ఎలా ప్రాసెస్ చేస్తుందో ఆలోచించండి.
3. 3 క్యూబ్‌ను x మరియు y దిశలలో రెండుసార్లు స్కేల్ చేయడానికి, y అక్షంలో 180 డిగ్రీల క్యూబ్‌ను తిప్పడానికి మరియు క్యూబ్ 0.1 ని x అక్షంలో తరలించడానికి కింది ఆదేశాలను జోడించండి. గతంలో ఇచ్చిన గ్లోరోటేట్ () ఆదేశాలతో సహా అన్ని సంబంధిత ఆదేశాలు సరైన క్రమంలో ఉన్నాయని నిర్ధారించుకోండి. మీరు పొరపాటు చేయడానికి భయపడితే, వ్యాసం చివర ప్రోగ్రామ్ యొక్క తుది వెర్షన్ చూడండి.

   // మరిన్ని పరివర్తనాలు glTranslatef (0.1, 0.0, 0.0); గ్లోరోటేఫ్ (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 కోడ్‌ను కంపైల్ చేసి అమలు చేయండి. మీరు gcc ని మీ కంపైలర్‌గా ఉపయోగిస్తున్నారని అనుకుందాం, కాబట్టి మీ టెర్మినల్‌లో కింది ఆదేశాలను నమోదు చేయండి:

   Linux లో: gcc cube.c -o cube -lglut -lGL ./ mycube on Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32 ./ మైక్యూబ్

5. 5 తుది కోడ్‌ని తనిఖీ చేయండి. వ్యాసం రచయిత రూపొందించిన తుది కోడ్ ఇక్కడ ఉంది, ఇది వ్యాఖ్యలను అనువదించదు.

   // // ఫైల్: mycube.c // రచయిత: మ్యాట్ డైస్లీ // క్రియేట్: 4/25/2012 // ప్రాజెక్ట్: OpenGL లో ఒక క్యూబ్ తయారు చేయడానికి సోర్స్ కోడ్ // వివరణ: ఒక OpenGL విండోను రూపొందిస్తుంది మరియు ఒక 3D క్యూబ్/ / యూజర్ బాణం కీలను ఉపయోగించి తిప్పవచ్చు // // నియంత్రణలు: ఎడమ బాణం -ఎడమవైపు తిప్పండి // కుడి బాణం -కుడివైపు తిప్పు // పైకి బాణం -పైకి తిప్పు // క్రిందికి బాణం -క్రిందికి తిప్పండి // ------ ------------------------------------------------------ -// కలిగి // --------------------------------------------- -------------- #stdio.h> #చేర్చండి stdarg.h> #గణితాన్ని చేర్చండి. GL / glut.h> #endif // ----------------------------------------- ------------------ // ఫంక్షన్ ప్రోటోటైప్స్ // -------------------------- ------------------------------ శూన్య ప్రదర్శన (); శూన్యమైన ప్రత్యేక కీలు (); // ---------------------------------------------------- ---------- // గ్లోబల్ వేరియబుల్స్ // -------------------------------------- ------------------------ డబుల్ రొటేట్_ y = 0; డబుల్ రొటేట్_ఎక్స్ = 0; // ---------------------------------------------------- ---------- // ప్రదర్శన () కాల్‌బ్యాక్ ఫంక్షన్ // ------------------------------- --------------------------- శూన్య ప్రదర్శన () // క్లియర్ స్క్రీన్ మరియు Z- బఫర్ glClear (GL_COLOR_BUFFER_BIT // ------ ------------------------------------------------------ -// స్పెషల్ కీలు () కాల్‌బ్యాక్ ఫంక్షన్ // -------------------------------------------- ------------------ శూన్యమైన ప్రత్యేక కీలు (int కీ, int x, int y) {// కుడి బాణం-(కీ == GLUT_KEY_RIGHT) రొటేట్_వై + అయితే భ్రమణాన్ని 5 డిగ్రీలు పెంచండి = 5; // ఎడమ బాణం - (కీ == GLUT_KEY_LEFT) రొటేట్_y - = 5; లేకపోతే (కీ == GLUT_KEY_UP) రొటేట్_x + = 5; లేకపోతే (కీ == GLUT_KEY_DOWN) రొటేట్_x - = 5; // డిస్‌ప్లే అప్‌డేట్ గ్లూట్‌పోస్ట్ రిడిస్ప్లే ();} // ----------------------------------- ---------------------- // ప్రధాన () ఫంక్షన్ // ------------------- -------------------------------------- int ప్రధాన (int argc, char * argv [] ) GLUT_RGB