การทำความคุ้นเคยกับ OpenGL คุณต้องเริ่มต้นด้วยข้อเท็จจริงที่ว่า OpenGL เป็น ข้อกำหนด- เหล่านั้น. OpenGL เพียงกำหนดชุดความสามารถที่จำเป็น การใช้งานขึ้นอยู่กับแพลตฟอร์มเฉพาะ
OpenGL เป็นแพลตฟอร์มข้ามแพลตฟอร์ม ไม่ขึ้นอยู่กับภาษา การเขียนโปรแกรม APIสำหรับการทำงานกับกราฟิก OpenGL เป็น API ระดับต่ำ ดังนั้นจึงเป็นความคิดที่ดีที่จะมีความเข้าใจเกี่ยวกับกราฟิกโดยทั่วไป และพีชคณิตเชิงเส้นพื้นฐานบางประการเพื่อใช้งาน

การตั้งชื่อ

ลองพูดสักสองสามคำเกี่ยวกับการตั้งชื่อฟังก์ชันใน OpenGL ขั้นแรก ชื่อของฟังก์ชันทั้งหมดที่ได้รับจาก OpenGL โดยตรงจะขึ้นต้นด้วยคำนำหน้า GL- ประการที่สอง ฟังก์ชันที่ระบุพารามิเตอร์ที่กำหนดโดยชุดตัวเลข (เช่น พิกัดหรือสี) จะมีส่วนต่อท้ายของรูปแบบ [จำนวนพารามิเตอร์ + ประเภทของพารามิเตอร์ + การแสดงพารามิเตอร์]

• จำนวนพารามิเตอร์ - ระบุจำนวนพารามิเตอร์ที่ยอมรับ ยอมรับ ค่าต่อไปนี้: 1 , 2 , 3 , 4
• ประเภทพารามิเตอร์ - ระบุประเภทของพารามิเตอร์ที่ยอมรับ ค่าต่อไปนี้เป็นไปได้: ข, ส, ฉัน, ฉ, ง, ub, เรา, อุ้ย- เหล่านั้น. ไบต์ (อักขระใน C, จำนวนเต็ม 8 บิต), แบบสั้น (จำนวนเต็ม 16 บิต), int (จำนวนเต็ม 32 บิต), float (หมายเลขจุดลอยตัว), สองเท่า (หมายเลขจุดลอยตัวที่มีความแม่นยำสองเท่า), ไบต์ที่ไม่ได้ลงนาม, แบบสั้นที่ไม่ได้ลงนาม int ที่ไม่ได้ลงนาม (สามอันสุดท้ายเป็นจำนวนเต็มที่ไม่ได้ลงนาม)
• การแสดงพารามิเตอร์ - ระบุว่าพารามิเตอร์ถูกส่งในรูปแบบใด หากแต่ละตัวเลขเป็นรายบุคคล จะไม่มีการเขียนใดๆ หากพารามิเตอร์ถูกส่งผ่านเป็นอาร์เรย์ ตัวอักษรจะถูกผนวกเข้ากับชื่อฟังก์ชัน โวลต์

ตัวอย่าง: glVertex3ivระบุพิกัดจุดยอด ซึ่งประกอบด้วยจำนวนเต็มสามตัวที่ส่งผ่านเป็นตัวชี้ไปยังอาร์เรย์

กราฟิก

ทั้งหมด วัตถุกราฟิกใน OpenGL เป็นกลุ่มของจุด เส้น และรูปหลายเหลี่ยม มีวัตถุดั้งเดิมที่แตกต่างกัน 10 ชนิดที่ใช้สร้างวัตถุทั้งหมด ทั้งแบบสองมิติและสามมิติ ในทางกลับกัน ดั้งเดิมทั้งหมดจะถูกระบุด้วยจุด - จุดยอด

• GL_POINTS- แต่ละจุดยอดจะกำหนดจุด
• GL_LINES- จุดยอดแต่ละคู่จะกำหนดเส้น
• GL_LINE_STRIP- จุดยอดแต่ละคู่กำหนดเส้น (เช่น จุดสิ้นสุดของบรรทัดก่อนหน้าคือจุดเริ่มต้นของบรรทัดถัดไป)
• GL_LINE_LOOP- คล้ายกับจุดก่อนหน้า ยกเว้นว่าจุดยอดสุดท้ายเชื่อมต่อกับจุดแรกและได้รับรูปปิด
• GL_สามเหลี่ยม- จุดยอดสามจุดแต่ละจุดจะกำหนดรูปสามเหลี่ยม
• 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. glBegin (GL_QUADS) ;
2. glVertex2i(250 , 450 ) ;
3. glVertex2i(250, 150);
4. glVertex2i(550 , 150 ) ;
5. glVertex2i(550 , 450 ) ;
6. glEnd() ;

พื้นฐานของโปรแกรม OpenGL

สำหรับงานที่ไม่ขึ้นอยู่กับแพลตฟอร์มกับ windows คุณสามารถใช้ส่วนขยาย . GLUT ทำให้การทำงานกับ OpenGL ง่ายขึ้น
ในการเริ่มต้น GLUT เมื่อเริ่มต้นโปรแกรมคุณต้องโทร glutInit(&argc, argv)- หากต้องการตั้งค่าโหมดการแสดงผล ให้โทร glutInitDisplayMode (โหมด)โดยที่โหมดสามารถรับค่าต่อไปนี้:

• GLUT_RGBA- รวมสีสี่องค์ประกอบ (ค่าเริ่มต้น)
• GLUT_RGB- เช่นเดียวกับ GLUT_RGBA
• GLUT_INDEX- รวมถึงสีที่จัดทำดัชนีไว้
• GLUT_สองเท่า- เปิดใช้งานบัฟเฟอร์หน้าจอคู่
• GLUT_SINGLE- เปิดใช้งานบัฟเฟอร์หน้าจอเดียว (ค่าเริ่มต้น)
• GLUT_DEPTH- เปิดใช้งาน Z-buffer (บัฟเฟอร์เชิงลึก)
• 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 ใช้กลไกที่ขับเคลื่อนด้วยเหตุการณ์ เหล่านั้น. มีการวนซ้ำหลักที่เริ่มต้นหลังจากการเริ่มต้น และเหตุการณ์ที่ประกาศทั้งหมดได้รับการประมวลผลแล้ว เช่น การกดปุ่มบนแป้นพิมพ์หรือการเลื่อนเคอร์เซอร์ของเมาส์ เป็นต้น คุณสามารถลงทะเบียนฟังก์ชันตัวจัดการเหตุการณ์ได้โดยใช้คำสั่งต่อไปนี้:

• เป็นโมฆะ glutDisplayFunc (เป็นโมฆะ (* func) (เป็นโมฆะ))- ตั้งค่าฟังก์ชั่นการวาดภาพ
• เป็นโมฆะ glutReshapeFunc (เป็นโมฆะ (* func) (ความกว้าง int, ความสูง int))- ตั้งค่าฟังก์ชั่นสำหรับการประมวลผลการปรับขนาดหน้าต่าง
• เป็นโมฆะ glutVisibilityFunc (เป็นโมฆะ (* func) (สถานะ int))- ตั้งค่าฟังก์ชั่นสำหรับการประมวลผลการเปลี่ยนแปลงในสถานะการมองเห็นหน้าต่าง
• เป็นโมฆะ glutKeyboardFunc (เป็นโมฆะ (* func) (คีย์ถ่านที่ไม่ได้ลงนาม, int x, int y))- ตั้งค่าฟังก์ชั่นสำหรับการประมวลผลการกดแป้นพิมพ์ (เฉพาะที่สร้างอักขระ ASCII)
• เป็นโมฆะ glutSpecialFunc (เป็นโมฆะ (* func) (คีย์ int, int x, int y))- ตั้งค่าฟังก์ชั่นสำหรับการประมวลผลการกดปุ่มแป้นพิมพ์ (ที่ไม่สร้างอักขระ ASCII)
• เป็นโมฆะ glutIdleFunc (เป็นโมฆะ (* func) (เป็นโมฆะ))- ระบุฟังก์ชันที่ถูกเรียกเมื่อไม่มีเหตุการณ์อื่น
• เป็นโมฆะ glutMouseFunc (เป็นโมฆะ (* func) (ปุ่ม int, สถานะ int, int x, int y))- กำหนดฟังก์ชันที่ประมวลผลคำสั่งเมาส์
• เป็นโมฆะ glutMotionFunc (เป็นโมฆะ (* func) (int x, int y))- กำหนดฟังก์ชันที่ประมวลผลการเคลื่อนไหวของเคอร์เซอร์ของเมาส์เมื่อกดปุ่มเมาส์ค้างไว้
• เป็นโมฆะ glutPassiveMotionFunc (เป็นโมฆะ (* func) (int x, int y))- กำหนดฟังก์ชันที่ประมวลผลการเคลื่อนไหวของเคอร์เซอร์ของเมาส์เมื่อไม่มีการกดปุ่มเมาส์
• เป็นโมฆะ glutEntryFunc (เป็นโมฆะ (* func) (สถานะ int))- กำหนดฟังก์ชันที่จัดการการเลื่อนเคอร์เซอร์ไปนอกหน้าต่างและการส่งคืนเคอร์เซอร์
• เป็นโมฆะ glutTimerFunc (int msecs ที่ไม่ได้ลงนาม, เป็นโมฆะ (* func) (ค่า int), ค่า)- ระบุฟังก์ชันที่ถูกเรียกใช้บนตัวจับเวลา

จากนั้นคุณสามารถเริ่มวงหลักได้ glutMainLoop().

โปรแกรมแรก

ตอนนี้เรารู้พื้นฐานของการทำงานกับ OpenGL แล้ว คุณสามารถเขียนได้ โปรแกรมง่ายๆเพื่อรวบรวมความรู้
เริ่มต้นด้วยการรวมไฟล์ส่วนหัว GLUT:

ตอนนี้เรารู้แล้วว่าจะต้องเขียนอะไรเป็นหลัก มาลงทะเบียนตัวจัดการสองตัวกัน: สำหรับการวาดเนื้อหาของหน้าต่างและสำหรับการประมวลผลการปรับขนาด ตัวจัดการสองตัวนี้ใช้ในโปรแกรมใด ๆ ที่ใช้ OpenGL และ GLUT เป็นหลัก

1. int หลัก (int argc, ถ่าน * argv)
2. glutInit(& argc, argv);
3. glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*เปิดใช้งานการบัฟเฟอร์คู่และสีสี่องค์ประกอบ*/
4. glutInitWindowSize(800, 600) ;
5. glutCreateWindow("OpenGL บทเรียนที่ 1" ) ;
6. glutReshapeFunc (สร้างใหม่);
7. glutDisplayFunc (จอแสดงผล);
8. glutMainLoop() ;
9. กลับ 0 ;

ตอนนี้เราจำเป็นต้องเขียนฟังก์ชันตัวจัดการสำหรับการปรับขนาดหน้าต่าง มาตั้งค่าพื้นที่ส่งออกรูปภาพให้เป็นขนาดของหน้าต่างทั้งหมดโดยใช้คำสั่ง glViewport(x, y, ความกว้าง, ความสูง)- จากนั้นโหลดเมทริกซ์การฉายภาพ glMatrixMode (GL_PROJECTION)ให้แทนที่ด้วยยูนิต glLoadIdentity ()และตั้งค่าการฉายภาพมุมฉาก และสุดท้าย โหลดเมทริกซ์มุมมองโมเดล glMatrixMode (GL_MODELVIEW)และแทนที่ด้วยยูนิตหนึ่ง
เป็นผลให้เราได้รับ:

1. การปรับรูปร่างเป็นโมฆะ (int w, int h)
2. glViewport(0 , 0 , กว้าง, ชั่วโมง) ;
3. glMatrixMode(GL_โครงการ) ;
4. glLoadIdentity() ;
5. gluOrtho2D(0 , ส, 0 , ชม.) ;
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 ในเนมสเปซ เต๋า.OpenGL(ค#) ใน Object Pascal ฟังก์ชันและขั้นตอนไลบรารี GLUT ทั้งหมดจะมีคำนำหน้าด้วย "glu" เพื่อแยกความแตกต่างจากขั้นตอนและฟังก์ชันของ OpenGL

หากต้องการสร้างเมทริกซ์การฉายภาพตามส่วนที่เลือกของการฉายภาพฉาก คุณสามารถใช้คำสั่ง PickMatrix ของไลบรารี GLUT:

C #: เป็นโมฆะ gluPickMatrix (สองเท่า x, สองเท่า y, ความกว้างสองเท่า, ความสูงสองเท่า, int viewport); วัตถุ Pascal: ขั้นตอน gluPickMatrix (x, y, ความกว้าง, ความสูง: GLdouble; วิวพอร์ต: PGLint);

คำสั่ง PickMatrix ของไลบรารี GLUT จะปรับเปลี่ยนเมทริกซ์ปัจจุบันเพื่อให้ขนาดของขอบเขตฉากตรงกับขอบเขตการเลือกที่กำหนดไว้ในพิกัดการฉายภาพของฉากนั้น คำสั่งมีพารามิเตอร์ดังต่อไปนี้:

• x, y – พิกัดแนวนอนและแนวตั้งของพื้นที่การเลือกในพิกัดของหน้าต่างที่แสดงการฉายภาพฉาก 3 มิติ
• ความกว้าง ความสูง – ความกว้างและความสูงของพื้นที่ฉายภาพสี่เหลี่ยมที่เลือกของฉาก 3 มิติในพิกัดหน้าต่าง
• วิวพอร์ตเป็นอาร์เรย์ขององค์ประกอบจำนวนเต็มสี่องค์ประกอบ ใน C# อาร์เรย์จะถูกส่งผ่านเป็นพารามิเตอร์โดยตรง ใน Object Pascal ตัวชี้ไปยังอาร์เรย์จะถูกส่งผ่านเป็นพารามิเตอร์ อาร์เรย์จะกำหนดพื้นที่เอาต์พุตของการฉายภาพฉาก 3 มิติ ค่าอาร์เรย์จะต้องสอดคล้องกับพิกัดพื้นที่เอาต์พุตที่กำหนดโดยใช้คำสั่ง ViewPort องค์ประกอบของอาร์เรย์นี้จะต้องมีค่าดังต่อไปนี้: องค์ประกอบที่ 1 และ 2 คือพิกัด x และ y ทางด้านซ้าย มุมบนพื้นที่ที่เลือกในพิกัดหน้าจอ 3 และ 4 องค์ประกอบ – ความกว้างและความสูงของพื้นที่นี้

จะต้องดำเนินการคำสั่งก่อนดำเนินการคำสั่ง Ortho หรือ Frushtum ซึ่งสร้างเมทริกซ์การฉายภาพ

การทำให้ไลบรารี OpenGL เข้าสู่โหมดการเลือก

หากต้องการทำให้ไลบรารีเข้าสู่โหมดการเลือก ให้ใช้คำสั่ง RenderMode:

C #: int RenderMode (โหมด RenderingMode); วัตถุ Pascal: ฟังก์ชั่น glRenderMode (โหมด: GLenum): GLint;

พารามิเตอร์โหมดจะกำหนดโหมดการทำงานของไลบรารี OpenGL และสามารถรับค่าใดค่าหนึ่งจากสามค่าได้:

ตารางที่ 10.1.

ค่าที่เป็นไปได้สำหรับพารามิเตอร์โหมดของคำสั่ง RenderMode	คำอธิบาย
	ความหมาย	ไลบรารี OpenTK, C#
วัตถุปาสคาล โหมดการเลือกใช้เพื่อนำไลบรารี่เข้าสู่โหมดการเลือก	RenderingMode เลือก	GL_SELECT
โหมดการถ่ายภาพฉาก โหมดนี้จะใช้ตามค่าเริ่มต้นหลังจากเตรียมใช้งานไลบรารี OpenGL แล้ว ในโหมดนี้รูปภาพจะถูกสร้างขึ้นโดยไลบรารี OpenGL	RenderingMode.Render	GL_RENDER
โหมดคำติชม	RenderingMode.ข้อเสนอแนะ	GL_ข้อเสนอแนะ

หลังจากสลับไปที่โหมดการเลือก OpenGL จะไม่เรนเดอร์รูปภาพจนกว่าโหมดจะเปลี่ยนเป็นโหมดเรนเดอร์ฉากโดยใช้คำสั่ง RenderMode พร้อมค่า RenderingMode.Render ใน C# และ GL_RENDER ใน Object Pascal

การตั้งชื่อและการสร้างวัตถุฉาก

ตามที่กล่าวไว้ข้างต้น ไม่มีการสร้างภาพในโหมดการเลือก คำสั่งเกี่ยวกับภาพในโหมดนี้ใช้เพื่อกำหนดวัตถุที่อยู่ภายในพื้นที่การเลือก

เนื่องจากอ็อบเจ็กต์ที่ผู้ใช้ทำงานด้วยมักจะถูกสร้างขึ้นจากพื้นฐานที่แตกต่างกันจำนวนมาก จึงมีการใช้ชื่อสแต็กเพื่อกำหนดอ็อบเจ็กต์ที่เลือก ชื่อเป็นค่าจำนวนเต็ม ก่อนที่เอาต์พุตของอ็อบเจ็กต์ถัดไปจะเริ่มต้น ชื่อ (หมายเลข) ของอ็อบเจ็กต์นี้จะถูกวางไว้บนสแต็กชื่อ เมื่อสร้างวัตถุ ไลบรารีตรวจพบว่าวัตถุดั้งเดิมของวัตถุนี้ตกอยู่ในพื้นที่การเลือก เนื้อหาของสแต็กชื่อจะถูกคัดลอกไปยังบัฟเฟอร์การเลือก (พร้อมกับบางส่วน ข้อมูลเพิ่มเติม) เริ่มต้นด้วยคำสั่ง SelectBuffer เมื่อวัตถุดั้งเดิมของวัตถุที่มีชื่ออื่นเข้ามาในพื้นที่ฉาก เนื้อหาของสแต็กชื่อจะถูกคัดลอกไปยังบัฟเฟอร์การเลือกด้วย ดังนั้นจึงสามารถรับชื่อ (ตัวเลข) ของวัตถุที่อยู่ทั้งหมดหรือบางส่วนภายในพื้นที่การเลือกได้ จะต้องคำนึงว่าเพื่อที่จะกำหนดวัตถุที่เลือกได้อย่างถูกต้อง จำเป็นต้องแปลงพิกัดของวัตถุให้ตรงกับที่ดำเนินการเมื่อสร้างภาพฉาก

มีการใช้คำสั่งหลายคำสั่งเพื่อทำงานกับเนมสแต็ก การล้างสแต็กชื่อทำได้โดยใช้คำสั่ง InitNames:

C#: โมฆะ InitNames(); วัตถุ Pascal: ขั้นตอน glInitNames;

การใส่ชื่อลงบนสแต็กทำได้โดยใช้คำสั่ง PushName:

C #: โมฆะ PushName (ชื่อ uint); วัตถุ Pascal: ขั้นตอน glPushName (ชื่อ: GLuint);

ชื่อถูกส่งผ่านเป็นพารามิเตอร์คำสั่ง

ก่อนที่จะใช้สแต็กชื่อได้ จะต้องเริ่มต้นโดยใช้คำสั่ง InitNames จากนั้นคุณจะต้องพุชองค์ประกอบหนึ่งลงบนสแต็กโดยใช้คำสั่ง PushName ก่อนที่แต่ละออบเจ็กต์จะถูกสร้างขึ้น องค์ประกอบเดียวของสแต็กชื่อจะถูกแทนที่ด้วยชื่อของออบเจ็กต์ที่กำลังถูกสร้างขึ้นโดยใช้คำสั่ง LoadName ขั้นตอนจะแทนที่องค์ประกอบสุดท้ายในสแต็กชื่อด้วยองค์ประกอบที่กำหนดเป็นพารามิเตอร์ ดังนั้นการเริ่มต้นและการใช้ name stack จึงสามารถแสดงแผนผังได้ดังนี้:

ชื่อเริ่มต้น; พุชชื่อ(0); ...ชื่อโหลด(1); //การก่อตัวของวัตถุหมายเลข 1 LoadName(2); //การก่อตัวของวัตถุหมายเลข 2 LoadName(3); //การก่อตัวของวัตถุหมายเลข 3 //ฯลฯ รายการ 10.7.

แผนภาพสำหรับการใช้เนมสแต็กเพื่อเลือกออบเจ็กต์

ตัดสินใจเรียนรู้ OpenGL แต่รู้ว่าจะเริ่มต้นอย่างไร เราได้ทำการคัดสรรวัสดุ

OpenGL คืออะไร OpenGL (เปิดไลบรารีกราฟิก ) เป็นหนึ่งในมาตรฐานกราฟิกยอดนิยมสำหรับการทำงานกับกราฟิก โปรแกรมที่เขียนด้วยความช่วยเหลือสามารถถ่ายโอนไปยังเกือบทุกแพลตฟอร์มโดยได้รับผลลัพธ์เดียวกัน OpenGL ช่วยให้คุณไม่ต้องเขียนโปรแกรมสำหรับฮาร์ดแวร์ แต่ใช้งานได้การพัฒนาที่มีอยู่

- OpenGL ได้รับการพัฒนาโดย Silicon Graphics โดยร่วมมือกับยักษ์ใหญ่ด้านเทคโนโลยีอื่นๆ จากมุมมองของการเขียนโปรแกรม OpenGL คืออินเทอร์เฟซซอฟต์แวร์ สำหรับกราฟิกแรสเตอร์

เช่น ตัวเร่งกราฟิก ประกอบด้วยคำสั่งที่แตกต่างกันประมาณ 150 คำสั่งซึ่งโปรแกรมเมอร์สามารถกำหนดวัตถุต่างๆ และเรนเดอร์ได้

วัสดุการศึกษา

บทช่วยสอน

• หลักสูตรออนไลน์
• ลินดา - "หลักสูตร OpenGL";
• มหาวิทยาลัยโตเกียว - “คอมพิวเตอร์กราฟิกเชิงโต้ตอบ”;

มหาวิทยาลัยซานดิเอโก - "พื้นฐานของคอมพิวเตอร์กราฟิก"

หนังสือ

ในภาษารัสเซีย

1. D. Shreiner - OpenGL Redbook - ดาวน์โหลด;

หนังสือเล่มนี้เป็นคู่มืออย่างเป็นทางการสำหรับการเรียนรู้ OpenGL ฉบับล่าสุดแตกต่างจากฉบับดั้งเดิมเกือบทั้งหมดผู้เขียนอัปเดตตามการเปลี่ยนแปลงในเวอร์ชัน ตามที่ผู้เชี่ยวชาญหลายร้อยคนที่ทำงานร่วมกับ Open GL หนังสือเล่มนี้คือสิ่งแรกที่ใครก็ตามที่ต้องการเรียนรู้เทคโนโลยีควรหยิบยกขึ้นมา

2. D. Wolf - Open GL 4. ภาษา Shader หนังสือสูตรอาหาร (2558) - ดาวน์โหลด; หนังสือเล่มนี้ครอบคลุมเทคนิคการเขียนโปรแกรม GLSL อย่างเต็มรูปแบบโดยเริ่มจากประเภทพื้นฐาน

3. ดี. กินส์เบิร์ก - OpenGL ES 3.0 คู่มือนักพัฒนา (2014) - ซื้อ;

ในหนังสือเล่มนี้ ผู้เขียนจะตรวจสอบ API และภาษาทั้งหมดสำหรับการเขียนเชเดอร์ นอกจากนี้คุณยังจะพบเคล็ดลับในการเพิ่มประสิทธิภาพและเพิ่มประสิทธิภาพสูงสุด งานเอพีไอและ GPU และ ใช้งานได้เต็มที่ OpenGL ES ในแอพพลิเคชั่นที่หลากหลาย

4. V. Porev - คอมพิวเตอร์กราฟิก (2545) - ดาวน์โหลด;

หนังสือกล่าวถึงวิธีการทำงานด้วย คอมพิวเตอร์กราฟิก, ปัญหาทั่วไปมีการแสดงตัวอย่างโปรแกรมในภาษา C++

ในภาษาอังกฤษ

1. P. Shirley - พื้นฐานของคอมพิวเตอร์กราฟิก (2009) - ;

หนังสือเล่มนี้มีวัตถุประสงค์เพื่อเป็นการแนะนำคอมพิวเตอร์กราฟิกส์ ระดับพื้นฐาน- ผู้เขียนครอบคลุมพื้นฐานทางคณิตศาสตร์ของคอมพิวเตอร์กราฟิกส์ โดยเน้นไปที่การนำพื้นฐานเหล่านี้ไปใช้ในการพัฒนาโค้ดที่มีประสิทธิภาพ

2. E. Angel - คอมพิวเตอร์กราฟิกเชิงโต้ตอบ - ซื้อ;

หนังสือเล่มนี้มีไว้สำหรับนักเรียนทุกคนที่เรียนวิทยาการคอมพิวเตอร์และการเขียนโปรแกรมเชิงลึก แอนิเมชั่นคอมพิวเตอร์และกราฟิกไม่ซับซ้อนเหมือนเมื่อก่อน ตามคำกล่าวของเขา ผู้เขียนได้เขียนหนังสือเล่มนี้ด้วยภาษาที่เข้าใจได้มากที่สุด

ในส่วนนี้ เราจะได้เรียนรู้วิธีสร้างภาพ 3 มิติโดยใช้ฟังก์ชันไลบรารี OpenGL เพื่อที่ว่าในบทถัดไป เราจะสามารถพัฒนาแอปพลิเคชัน Windows ที่ถือได้ว่าเป็นเครื่องมือในการดูผลลัพธ์ของการคำนวณทางวิทยาศาสตร์ เนื้อหาในส่วนนี้จะช่วยให้คุณค่อยๆ เร่งความเร็วและเชี่ยวชาญเทคโนโลยีที่น่าสนใจในการสร้างและจัดการภาพสามมิติ ก่อนอื่นเราจะดูที่ความสามารถพื้นฐานของไลบรารี OpenGL จากนั้นเราจะเรียนรู้วิธีการควบคุม ฟังก์ชัน OpenGLตามตัวอย่าง แอปพลิเคชั่นที่เรียบง่ายประเภทคอนโซลและหลังจากนั้นเราจะเริ่มพัฒนาแอปพลิเคชัน Windows

ผู้อ่านคงรู้ว่า OpenGL เป็นไลบรารีกราฟิกที่ได้รับการปรับปรุงและมีประสิทธิภาพสูงสำหรับฟังก์ชั่นและประเภทข้อมูลสำหรับการแสดงสองและ กราฟิก 3 มิติ- มาตรฐาน OpenGL ได้รับการอนุมัติในปี 1992 โดยอิงจากไลบรารี IRIS GL ที่พัฒนาโดย Silicon Graphics (www.sgi.com) OpenGL รองรับทุกแพลตฟอร์ม นอกจากนี้ OpenGL ยังรองรับฮาร์ดแวร์อีกด้วย มีการ์ดแสดงผลที่มีตัวเร่งความเร็วและการ์ด SD เฉพาะที่ใช้ OpenGL ดั้งเดิมในฮาร์ดแวร์

เนื้อหาในส่วนแรกของบทเรียนนี้ได้รับแรงบันดาลใจจากหนังสือดีๆ (หาออนไลน์ได้) จาก Addison-Wesley "คู่มือการเขียนโปรแกรม OpenGL คู่มืออย่างเป็นทางการสำหรับการเรียนรู้ OpenGL" หากผู้อ่านเป็นเจ้าของ ภาษาอังกฤษแล้วเราแนะนำให้อ่านครับ

ไลบรารีที่เชื่อมโยง

การใช้งาน OpenGL ของ Microsoft รวมถึง ชุดสมบูรณ์คำสั่ง OpenGL นั่นคือ ฟังก์ชั่นระดับโลกรวมอยู่ในแกนหลักของไลบรารี OPENGL32.LIB และมีคำนำหน้า GL(เช่น glLineWidth) โปรดทราบว่าฟังก์ชันไลบรารีหลักมีหลายเวอร์ชัน ซึ่งช่วยให้คุณสามารถระบุพารามิเตอร์หรือการตั้งค่าที่ต้องการได้ตามที่คุณต้องการ ดูความช่วยเหลือสำหรับฟังก์ชันต่างๆ ในตระกูล glColor* ปรากฎว่าคุณสามารถตั้งค่าสีปัจจุบันได้ 32 วิธี ตัวอย่างเช่น ฟังก์ชัน:

โมฆะ glColorSb (GLbyte สีแดง, GLbyte สีเขียว, GLbyte สีน้ำเงิน);

กำหนดสีโดยใช้องค์ประกอบ 3 ประเภทประเภท GLbyte และฟังก์ชัน:

โมฆะ glColor4dv (const GLdouble *v);

ระบุโดยใช้ที่อยู่ของอาร์เรย์สี่องค์ประกอบ

เมื่อพิจารณาตัวเลือกเหล่านี้แล้ว ไลบรารีหลักจะมีคำสั่งมากกว่า 300 คำสั่ง นอกจากนี้ คุณยังสามารถเชื่อมต่อไลบรารียูทิลิตี้ GLU32.LIB ที่ช่วยเสริมเคอร์เนลหลักได้ มีฟังก์ชันสำหรับควบคุมพื้นผิว การแปลงพิกัด การสร้างทรงกลม ทรงกระบอก และดิสก์ การประมาณเส้นโค้งและพื้นผิว ( พยาบาล - เส้นโค้ง B-Spline ที่ไม่สม่ำเสมอ) ตลอดจนการจัดการข้อผิดพลาด เพิ่มเติมอีกประการหนึ่ง ( เสริม) ไลบรารี GLAUX.LIB อนุญาต ด้วยวิธีง่ายๆสร้างหน้าต่าง Windows แสดงวัตถุ SD จัดการเหตุการณ์อินพุตและจัดการ กระบวนการเบื้องหลัง- ขออภัย ห้องสมุดนี้ไม่มีเอกสารประกอบ บริษัทไมโครซอฟต์เราไม่แนะนำให้ใช้เพื่อพัฒนาโครงการเชิงพาณิชย์ เนื่องจากมีโค้ดลูปการประมวลผลข้อความซึ่งไม่สามารถแทรกการประมวลผลข้อความที่กำหนดเองอื่น ๆ ได้

บันทึก
ประเภท GLbyte เทียบเท่ากับประเภทถ่านที่มีลายเซ็น และ GLdouble เทียบเท่ากับประเภท double ประเภทของตัวเองใช้เพื่อทำให้การพกพาไปยังแพลตฟอร์มอื่นง่ายขึ้น เรามีรายการประเภท OpenGL ด้านล่าง องค์ประกอบสีที่สี่จะกำหนดความโปร่งใสของสี ซึ่งเป็นวิธีที่สีพื้นหลังผสมผสานกับสีของรูปภาพ คำสั่ง OpenGL บางคำสั่งจะมี v ต่อท้าย ซึ่งระบุว่าอาร์กิวเมนต์ควรเป็นที่อยู่ของอาร์เรย์ (เวกเตอร์) เวกเตอร์ในคณิตศาสตร์คือลำดับของตัวเลข (พิกัด) ที่กำหนดองค์ประกอบของปริภูมิเวกเตอร์โดยไม่ซ้ำกัน คำสั่งจำนวนมากมีหลายเวอร์ชัน ซึ่งท้ายที่สุดแล้วทำให้คุณสามารถระบุเวกเตอร์ได้หลายวิธี.

ฟังก์ชัน Windows GDI ประมาณยี่สิบฟังก์ชันถูกสร้างขึ้นเพื่อทำงานกับ OpenGL โดยเฉพาะ ส่วนใหญ่จะมีคำนำหน้า ตกลง(ตัวย่อสำหรับ Windows GL) ฟังก์ชันเหล่านี้เป็นฟังก์ชันที่คล้ายคลึงกันของฟังก์ชันที่นำหน้าด้วย glx ที่เชื่อมต่อ OpenGL กับแพลตฟอร์มระบบ X window ในที่สุดก็มีฟังก์ชัน Win32 หลายอย่างสำหรับควบคุมรูปแบบพิกเซลและ บัฟเฟอร์สองเท่า- ใช้ได้กับหน้าต่าง OpenGL เฉพาะทางเท่านั้น

คุณกำลังอ่านบทช่วยสอน OpenGL ครั้งแรกของฉัน!

ก่อนที่คุณจะเริ่มเรียนรู้ OpenGL สำหรับฉัน ดูเหมือนว่าเป็นการดีกว่าที่จะบอกวิธีคอมไพล์โค้ด รัน และที่สำคัญที่สุดคือ วิธีทดลองใช้ซอร์สโค้ดที่ให้ไว้ในบทเรียนเหล่านี้

สิ่งที่คุณต้องรู้

บทเรียนเหล่านี้มุ่งเป้าไปที่ผู้อ่านที่ไม่มีความรู้พิเศษด้านการเขียนโปรแกรม แน่นอนว่าความรู้เกี่ยวกับภาษาการเขียนโปรแกรมใด ๆ (C, Java, Lisp, JavaSript) จะเป็นประโยชน์อย่างมาก แต่ไม่จำเป็นคุณเพียงแค่ต้องเรียนสองวิชาในเวลาเดียวกัน - กราฟิก 3 มิติและการเขียนโปรแกรม

โค้ดทั้งหมดในบทเรียนเหล่านี้เขียนด้วยภาษา C++ ในรูปแบบที่เรียบง่ายที่สุด ไม่มีเทมเพลต คลาส หรือเลขคณิตของพอยน์เตอร์ ดังนั้น เมื่อดูโค้ดแล้ว คุณจะเข้าใจได้ว่ามันทำอะไร แม้ว่าคุณจะคุ้นเคยกับ JavaSript เท่านั้นก็ตาม

ลืมทุกสิ่งที่คุณรู้เกี่ยวกับ OpenGL 1/2

บทเรียนเหล่านี้ถือว่าคุณไม่รู้อะไรเลยเกี่ยวกับกราฟิก 3 มิติ แต่ถ้าคุณได้อ่านบทช่วยสอน OpenGL แล้วเจอบางอย่างเช่น glBegin() ก็ลืมมันไปได้เลย ที่นี่เราจะศึกษา OpenGL 3 และ 4 และสิ่งที่คุณอ่านใช้ได้กับ OpenGL 1 หรือ 2 ดังนั้น ฉันขอแนะนำให้คุณลืมทุกสิ่งที่คุณรู้มาก่อน ไม่เช่นนั้นสมองของคุณจะเริ่มละลายจากความไม่สอดคล้องกัน

กำลังสร้างโครงการ

โค้ดจากบทเรียนเหล่านี้สามารถคอมไพล์ได้สำหรับ Windows และ Linux หากต้องการเริ่มคอมไพล์โค้ดสำหรับแพลตฟอร์มใดๆ คุณต้องดำเนินการดังต่อไปนี้:

1. อัพเดตไดรเวอร์การ์ดจอของคุณ!! ฉันเตือนคุณแล้ว :)
2. ดาวน์โหลดคอมไพเลอร์หากคุณยังไม่มี
3. ติดตั้ง CMake
4. ดาวน์โหลดแหล่งบทเรียนสำเร็จรูป
5. สร้างโครงการโดยใช้ CMake
6. ประกอบโครงการ
7. ทดลองใช้โค้ดเพื่อทำความเข้าใจว่าเกิดอะไรขึ้นที่นั่น

ด้านล่างนี้ฉันได้ให้คำอธิบายโดยละเอียดเพิ่มเติมเกี่ยวกับการประกอบโปรเจ็กต์สำหรับแต่ละแพลตฟอร์ม แต่ขึ้นอยู่กับเวอร์ชันของระบบปฏิบัติการ ภาพหน้าจออาจแตกต่างกันเล็กน้อยจากสิ่งที่จะปรากฏบนหน้าจอของคุณ แต่โดยทั่วไปแล้ว ทุกอย่างควรจะใกล้เคียงกัน

สร้างสำหรับ Windows

สร้างสำหรับลินุกซ์

ในโลกนี้มี Linux หลากหลายรูปแบบอยู่มากมาย ดังนั้นฉันจึงไม่อยากจะยกตัวอย่างการประกอบโปรเจ็กต์สำหรับแต่ละรูปแบบ หากมีบางอย่างไม่เป็นไปตามที่อธิบายไว้ด้านล่าง โปรดอ่านเอกสารหรือค้นหาในอินเทอร์เน็ต

1. ติดตั้ง ไดรเวอร์ล่าสุดไปยังการ์ดวิดีโอของคุณ ฉันขอแนะนำไดรเวอร์ที่ไม่ใช่โอเพ่นซอร์สเป็นอย่างยิ่ง สิ่งเหล่านี้ไม่ได้รวมอยู่ใน GNU แต่มักจะทำงานได้ดีกว่ามาก หาก Linux build ของคุณไม่มีให้โปรแกรมติดตั้งอัตโนมัติ
2. ลองอ่านคู่มือของ Ubuntu ติดตั้งคอมไพเลอร์ด้วยทั้งหมดห้องสมุดที่จำเป็น
3. และเครื่องมือ นี่คือรายการสิ่งที่คุณต้องการ: cmake make g++ libx11-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev ใช้ sudo apt-get install ***** หรือ su /yum install ******
4. ดาวน์โหลดซอร์สตัวอย่างและแตกไฟล์ลงในโฟลเดอร์ เช่น ~/Projects/OpenGLTutorials/

• ไปที่ ~/Projects/OpenGLTutorials/ และป้อนคำสั่งต่อไปนี้:

• สร้าง mkdir

• สร้างซีดี

1. มะ..
2. หากดำเนินการคำสั่งก่อนหน้านี้สำเร็จ makefile จะถูกสร้างขึ้นในโฟลเดอร์ build/ ป้อน "make all" และหลังจากนั้นตัวอย่างทั้งหมดและการขึ้นต่อกันจะถูกรวบรวม หากไม่มีข้อผิดพลาดก็พร้อมไฟล์ปฏิบัติการ

จะถูกวางไว้ใน ~/Projects/OpenGLTutorials/ โฟลเดอร์

ฉันชอบใช้ QtCreator IDE มาก IDE นี้สามารถทำงานร่วมกับ CMake ได้ทันทีและมอบคุณสมบัติอื่นๆ มากมาย เช่น การดีบัก การเติมข้อความอัตโนมัติ ฯลฯ

1. คำแนะนำสำหรับการสร้างโปรเจ็กต์ใน QtCreator: ใน QtCreator คลิก

2. ไฟล์ -> เครื่องมือ -> ตัวเลือก -> คอมไพล์และดำเนินการ -> CMake

3. ระบุเส้นทางไปยัง CMake ส่วนใหญ่จะเป็น /usr/bin/cmake

4. ไฟล์ -> เปิดโปรเจ็กต์แล้วเลือกบทช่วยสอน/CMakeLists.txt

5. ระบุโฟลเดอร์บิลด์ โดยโฟลเดอร์ควรอยู่นอกโฟลเดอร์บทช่วยสอน

6. ตั้งค่าทางเลือก –DCMAKE_BUILD_TYPE=ดีบักในฟิลด์ตัวเลือก คลิกบนค้อนด้านล่าง

7. หลังจากนี้ ตัวอย่างสามารถเรียกใช้ได้จากโฟลเดอร์บทช่วยสอน/

หากต้องการรันตัวอย่างจาก QtCreator ให้เลือก Projects ->Execution parameter ->Working Directory และเลือกไดเร็กทอรีที่มีพื้นผิวและโมเดลเชเดอร์อยู่ สำหรับบทช่วยสอนที่ 2 จะเป็น ~/opengl -tutorial /tutorial02_red_triangle/

ตัวอย่างการรัน
เมื่อคอมไพล์โปรเจ็กต์แล้ว แอปพลิเคชันสามารถเปิดได้โดยตรงจากไดเร็กทอรี

หากคุณต้องการเรียกใช้ตัวอย่างโดยตรงจาก IDE ให้ใช้คำแนะนำด้านบนเพื่อตั้งค่าไดเร็กทอรีการทำงานอย่างถูกต้อง

วิธีเรียนบทเรียนเหล่านี้ แต่ละบทเรียนมาพร้อมกับซอร์สโค้ด

และข้อมูล ไฟล์ทั้งหมดเหล่านี้สามารถพบได้ในไดเร็กทอรี TutorialXX/ ที่เกี่ยวข้อง

เมื่อคุณอ่านบทช่วยสอนเหล่านี้ คุณจะเห็นโค้ดเล็กๆ น้อยๆ ทุกที่ คุณสามารถคัดลอกลงใน Playground.cpp เพื่อดูการใช้งานจริงได้ การทดลองย่อมดีเสมอ ฉันจะพูดอีกครั้งอย่าเพิ่งอ่าน รหัสพร้อมและลองเปิดใช้งาน คุณจะไม่ได้เรียนรู้อะไรมากมายเพียงแค่อ่านซอร์สโค้ด แม้จะคัดลอกและวางแบบง่ายๆ คุณก็จะได้รับปัญหามากมาย ซึ่งการแก้ปัญหานี้คุณจะได้รับประสบการณ์ที่จำเป็น

การเปิดหน้าต่าง

ในที่สุด! โอเพ่นจีแอล!

แม้ว่าคุณจะต้องรออีกสักหน่อย ในบทเรียนทั้งหมด การดำเนินการ 3 มิติจะดำเนินการในระดับที่ต่ำมาก ดังนั้นจึงไม่มีเวทย์มนตร์สำหรับคุณ อย่างไรก็ตาม การทำงานกับหน้าต่างระบบและข้อความนั้นไม่น่าสนใจและน่าเบื่อ ดังนั้นเราจะปล่อยให้ไลบรารี่ GLFW ทำงานสกปรกแทนเรา หากคุณต้องการจริงๆ คุณสามารถใช้ Win32 Api สำหรับ Windows หรือ X11 API สำหรับ Linux หรือใช้อย่างอื่นเช่น SFML, FreeGLUT, SDL, ... อ่านหน้าลิงก์

เอาล่ะ มาเริ่มกันเลย เริ่มจากข้อเท็จจริงที่ว่าเราจำเป็นต้องเชื่อมต่อการพึ่งพา เนื่องจากเราต้องการส่งข้อความไปยังคอนโซล เราจะเขียนดังต่อไปนี้:

// การเชื่อมต่อส่วนหัวมาตรฐาน

#รวม

#รวม

จากนั้นเราเชื่อมต่อ GLEW

// เราต้องไม่ลืมสิ่งนั้น เกลว จะต้องเชื่อมต่อก่อน GL . ชม. หรือ glfw . ชม.

#รวม

จากนั้นเราเชื่อมต่อ GLFW ไลบรารีนี้จะทำการจัดการหน้าต่างทั้งหมด

#รวม

บน ในขั้นตอนนี้เราไม่ต้องการห้องสมุดนี้ แต่มีฟังก์ชันทางคณิตศาสตร์อยู่ และเราจะต้องการมันเร็วๆ นี้ ไม่มีเวทย์มนตร์ใน GLM และหากคุณต้องการจริงๆ คุณสามารถใช้ไลบรารีอื่นเพื่อทำงานกับเมทริกซ์และเวกเตอร์ได้ เรารวม "การใช้เนมสเปซ" เพื่อเขียน "vec3" ไม่ใช่ "glm::vec3"

#รวม

ใช้เนมสเปซ glm;

หากคุณคัดลอกโค้ดเหล่านี้ลงใน Playground.cpp คอมไพลเลอร์จะเริ่มบ่นว่าไม่มีฟังก์ชัน main() ลองเพิ่ม:

int หลัก())(

จะดีกว่าถ้าเริ่มต้น GLFW ก่อน:

//เริ่มต้น GLFW

ถ้า(!glfwInit())

{

fprintf(stderr, "ไม่สามารถเริ่มต้น GLFW\n");

กลับ -1;

}

ตอนนี้เรามาสร้างหน้าต่าง OpenGL ของเรากันดีกว่า:

glfwOpenWindowHint( GLFW_ สฟส_ ตัวอย่าง, 4); // 4 xเรียบ

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); -เรา จำเป็น โอเพ่นจีแอล 3.3

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);

glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // เรา ไม่ จำเป็น เก่า OpenGL

// มาเปิดหน้าต่างและสร้างบริบทกัน

ถ้า(!glfwOpenWindow(1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW))

{

fprintf(stderr, "ไม่สามารถเปิดหน้าต่าง GLFW\n");