lecture-04.pdf

Transcript

1. ບ ັ ນຍາຍ OpenGL ຄ ັ້ ງທ ີ 5 (ຕ ໍ່ )
2. ການໃຊ ້ OpenGL ແລະ GLUT • ເວລາໃຊ ້ OpenGL ຕ ້ ອງມ ີ ການ include header ຕ ໍ່ ໄປນ ີ ້ – #include <GL/gl.h> – #include <GL/glu.h> • ເວລາໃຊ ້ GLUT ຕ ້ ອງມ ີ ການ include header ຕ ໍ່ ໄປນ ີ ້ – #include “glut.h” • ເນ ື່ ອງຈາກ GLUT ໄດ ້ include gl.h ແລະ glu.h ໃຫ ້ ເຮ ົ າຢ ູ່ ແລ ້ ວສະນ ັ້ ນ Include ແຕ ່ glut.h ກ ໍ ພ ໍ
3. Code ຕ ົ ວຢ ່ າງສະເພາະ GLUT int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA); glutCreateWindow("whitesquare"); glutDisplayFunc(draw); glutMainLoop(); }
4. glutInit • glutInit(int *argc, char **argv) – ເປ ັ ນການຕ ັ້ ງຄ ່ າເລ ີ່ ມຕ ົ້ ນຫ ຼ າຍໆຢ ່ າງຂອງ GLUT – ຕ ້ ອງພ ິ ມ glut ກ ່ ອນພ ີ ມຄ ໍ າສ ັ ງຂອງ GLUT – ປ ົ ກກະຕ ິ ເຮ ົ າຂຽນ int main(int argc, char ** argv) – ພຽງແຕ ່ ໃຫ ້ ເອ ີ ້ ນ glutInit(&argc, argv) ເປ ັ ນຄ ໍ າສ ັ່ ງ ທ ໍ າອ ິ ດໃນ main ກ ໍ ພ ໍ
5. glutInitDisplay • glutInitDisplay(unsigned int mode) – ກ ໍ ານ ົ ດສ ີ pixel ໃນໂປຣແກຣມຂອງເຮ ົ າຈະເປ ັ ນແບບໃດ ໋ • ມ ີ ໃຫ ້ ເລ ື ອກສອງແບບຄ ື RGB ແລະ Indexed Color • ເຮ ົ າຈະບ ໍ່ ໃຊ ້ Indexed Color – ກ ໍ ານ ົ ດວ ່ າຈະໃຊ ້ single buffer ຫ ຼື double buffer • ໃຊ ້ double buffer ຈະເຮ ັ ດໃຫ ້ animation ເບ ິ່ ງແລ ້ ວກ ົ ມກ ຶ ນກ ່ ວາ – ກ ໍ ານ ົ ດວ ່ າຈະໃຫ ້ ມ ີ buffer ອ ື່ ນໆນອກຈາກ buffer ສ ີ ຫຍ ັ ງແດ ່ • ປ ົ ກກະຕ ິ ຈະໃຊ ້ ພຽງ depth buffer ສ ໍ າລ ັ ບເກ ັ ບຄວາມເລ ີ ກຂອງແຕ ່ ລະ ເມ ັ ດ(ຈ ຸ ດ) – ຄ ່ າ mode ເກ ີ ດຈາກການເອ ົ າຄ ່ າຄ ົ ງທ ີ ຂອງຕ ົ ວເລ ື ອກຕ ່ າງໆ ມາ or ກ ັ ນ • ປ ົ ກກະຕ ິ ເຮ ົ າຈະໃຊ ້ GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH • ກ ໍ ລະນ ີ ຂອງ code ຕ ົ ວຢ ່ າງ: GLUT_SINGLE | GLUT_RGBA
6. ຄ ໍ າສ ັ່ ງສ ໍ າລ ັ ບຈ ັ ດການໜ ້ າຕ ່ າງ • glutCreateWindow(char *string) – ສ ້ າງໜ ້ າຕ ່ າງທ ີ່ ມ ີ title ເປ ັ ນ string • glutInitWindowPosition(int x, int y) – ກ ໍ ານ ົ ດຕ ໍ າແໜ ່ ງຂອງໜ ້ າຕ ່ າງເທ ິ ງ Monitor • glutInitWindowSize(int width, int height) – ກ ໍ ານ ົ ດຂະໜາດຂອງໜ ້ າຕ ່ າງ
7. glutDisplayFunc • glutDisplayFunc(void (*func)(void)) – ເປ ັ ນການເອ ີ ້ ນເອ ົ າ Define ຟ ັ ງຊ ັ ນມາແຕ ້ ມເທ ິ ງໜ ້ າ ຕ ່ າງ – ຕ ົ ວຢ ່ າງ: void myDisplay() glutDipsplayFunc(myDisplay);
8. glutMainLoop • glutMainLoop() – ຟ ັ ງຊ ັ ນສ ຸ ດທ ້ າຍທ ີ ເຮ ົ າເອ ີ ້ ນໃຊ ້ – ເປ ັ ນການສ ັ່ ງໃຫ ້ GLUT ໄປເຮດວຽກຂອງມ ັ ນເອງ – ງານຂອງ GLUT • ຮ ັ ບ input ຈາກຜ ູ້ ໃຊ ້ • ເອ ີ ້ ນໃຊ ້ ຟ ັ ງຊ ັ ນ glutDisplayFunc • ເລ ີ່ ມຕ ົ້ ນໃໝ ່ ອ ີ ກຄ ັ້ ງ
9. ເມ ື່ ອຂະຫຍາຍ Windows
10. ສ ິ່ ງທ ີ່ ຕ ້ ອງການ
11. glutReshapeFunc • glutReshapeFunc(void (*func)​(int width, int height)) – ປະກາດ ລວງກ ້ ວາງ ແລະ ລວງສ ູ ງ – ຟ ັ ງຊ ັ ນນ ີ ້ ຈະຖ ື ກເອ ີ ້ ນໃຊ ້ ທ ຸ ກຄ ັ້ ງທ ີ່ ມ ີ ການປ ່ ຽນຂະໜາດໜ ້ າ ຕ ່ າງ – ຟ ັ ງຊ ັ ນ glutReshapeFunc ເປ ັ ນໂຕປ ັ ບອ ັ ດຕາສ ່ ວນ ໃນການສະແດງພາບອອກມາ
12. ຕ ົ ວຢ ່ າງການໃຊ ້ glutReshapeFunc #include "glut.h" void reshape(int w, int h) { ......... } void draw() { ......... } int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB A | GLUT_SINGLE); glutCreateWindow("window"); glutReshapeFunc(reshape); glutDisplayFunc(draw); glutMainLoop(); }
13. Aspect Ratio • ອ ັ ດຕາສ ່ ວນລະຫວ ່ າງຄວາມກ ້ ວາງຂອງຮ ູ ບຕ ໍ່ ຄວາມສ ູ ງຂອງຮ ູ ບ • Aspect ratio ຂອງຮ ູ ບສ ີ່ ລ ່ ຽມສ ີ ຂາວ = 1 • ເວລາຫຍ ໍ້ /ຂະຫຍາຍໜ ້ າຈ ໍ aspect ratio ເຖ ິ ງວ ່ າ ເຮ ົ າຈະແຕ ້ ມຮ ູ ບຢ ູ່ ຈ ຸ ດໃດ ໋ ກ ໍ ຕາມ • ທ ັ ງໝ ົ ດນ ີ ້ ເປ ັ ນຍ ້ ອນຈ ຸ ດຕ ່ າງໆມ ີ ການຍ ້ າຍຕ ໍ າແ ໜ ່ ງ height width ratio aspect =
14. Aspect Ratio (ຕ ໍ່ ) (1,1) (1,-1) (-1,-1) (-1,1)
15. Aspect Ratio (ຕ ໍ່ ) (1,1) (-1,1) (-1,-1) (1,-1)
16. Aspect Ratio (ຕ ໍ່ ) (1,1) (-1,1) (1,-1) (-1,-1)
17. ສ ິ່ ງທ ີ່ ເຮ ົ າຕ ້ ອງການ • ເວລາຫຍ ໍ້ /ຂະຫຍາຍ ໜ ້ າຕ ່ າງ aspect ratio ຂອງຮ ູ ບຄວນຈະມ ີ ຄ ່ າຄ ົ ງທ ີ່ ເຖ ິ ງແມ ່ ນວ ່ າ aspect ratio ຂອງໜ ້ າຕ ່ າງຈະປ ່ ຽນກ ໍ່ ຕາມ • ເຮ ົ າຈະປ ່ ຽນ coordinate system ຂອງເນ ື ້ ອທ ີ່ ທ ີ່ ເຮ ົ າຈະແຕ ້ ມຮ ູ ບ
18. ກ ໍ ລະນ ີ ຄວາມກ ້ ວາງຫ ຼ າຍກວ ່ າ ຄວາມສ ູ ງ (1,1) (1,-1) (-1,1) (-1,-1)
19. ກ ໍ ລະນ ີ ຄວາມສ ູ ງຫ ຼ າຍກວ ່ າຄວາມກ ້ ວາງ (1,1) (1,-1) (-1,1) (-1,-1)
20. gluOrtho2D • gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top) – ໃຊ ້ ປ ່ ຽນ projection matrix ໃຫ ້ ເປ ັ ນການສາຍຮ ູ ບ ແບບ orthogonal projection • (ອ ີ ກສອງອາທ ິ ດຈ ຶ່ ງລ ົ ງເລ ິ ກ) – ການກວດສອບພ ິ ກ ັ ດຂອງຈ ຸ ດມ ຸ ມຂອງບ ໍ ລ ິ ເວນທ ີ່ ເຮ ົ າຈະແຕ ້ ມຮ ູ ບ • ແຈລ ຸ ມຊ ້ າຍເປ ັ ນ (left, bottom) • ແຈລ ຸ ມຂວາເປ ັ ນ (right, bottom) • ແຈເທ ິ ງຊ ້ າຍເປ ັ ນ (left, top) • ແຈເທ ິ ງຂວາເປ ັ ນ (right, top)
21. gluOrtho2D (ຕ ໍ່ ) gluOrtho2D(-1,1,-1,1) gluOrtho2D(-2,2,-2,2) gluOrtho2D(-1,1,-2,2) gluOrtho2D(-2,2,-1,1)
22. ກ ໍ ລະນ ີ ຄວາກ ້ ວາງຫ ຼ າຍກວ ່ າຄວາມສ ູ ງ (ຕ ໍ່ ) (1,1) (1,-1) (-1,1) (-1,-1) (right,top) (right,bottom) (left,top) (left,bottom)
23. ກ ໍ ລະນ ີ ຄວາມກ ້ ວາງຫ ຼ າຍກວ ່ າຄວາມສ ູ ງ (ຕ ໍ່ ) • bottom = -1 • top = 1 • left = ???, right = ??? • ແຕ ່ ເຮ ົ າຮ ູ້ ວ ່ າ left = -right • ສ ັ ງເກດວ ່ າ ເມ ື່ ອ w ແລະ h ແມ ່ ນຄວາມກ ້ ວາງ ແລະ ຄວາມ ສ ູ ງຂອງໜ ້ າຕ ່ າງ bottom top left right h w − − =
24. ກ ໍ ລະນ ີ ລວງກ ້ ວາງຫ ຼ າຍກວ ່ າລວງສ ູ ງ (ຕ ໍ່ ) • ຈະໄດ ້ • ດ ັ່ ງນ ັ້ ນ – left = w/h – right = -w/h left left left left h w = = − − − + = 2 2 ) 1 ( 1 ) (
25. ກ ໍ ລະນ ີ ລວງສ ູ ງຫ ຼ າຍກວ ່ າລວງກ ້ ວາງ (ຕ ໍ່ ) (1,1) (1,-1) (-1,1) (-1,-1) (right,top) (right,bottom) (left,top) (left,bottom)
26. ກ ໍ ລະນ ີ ລວງສ ູ ງຫ ຼ າຍກວ ່ າລວງກ ້ ວາງ (ຕ ໍ່ ) • left = -1 • right = 1 • top = ???, bottom = ??? • ເຮ ົ າຮ ູ້ ວ ່ າ bottom = -top • ດ ັ່ ງນ ັ້ ນ top = h/w ແລະ bottom = -h/w top top top top bottom top left right h w 1 2 2 ) ( ) 1 ( 1 = = − − − − = − − =
27. Callback ສ ໍ າລ ັ ບເວລາໜ ້ າຕ ່ າງປ ່ ຽນຂະໜ າດ void reshape(int w, int h) { glViewport(0,0,w,h); if (w == 0) w = 1; if (h == 0) h = 1; double aspect = w * 1.0 / h; glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w > h) gluOrtho2D(-aspect, aspect, -1, 1); else gluOrtho2D(-1, 1, -1/aspect, 1/aspect); }
28. Callback ສ ໍ າລ ັ ບເວລາໜ ້ າຕ ່ າງປ ່ ຽນຂະໜ າດ void reshape(int w, int h) { glViewport(0,0,w,h); if (w == 0) w = 1; if (h == 0) h = 1; double aspect = w * 1.0 / h; glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w > h) gluOrtho2D(-aspect, aspect, -1, 1); else gluOrtho2D(-1, 1, -1/aspect, 1/aspect); } ກ ັ ນ division by zero
29. Callback ສ ໍ າລ ັ ບເວລາໜ ້ າຕ ່ າງປ ່ ຽນຂະໜ າດ void reshape(int w, int h) { glViewport(0,0,w,h); if (w == 0) w = 1; if (h == 0) h = 1; double aspect = w * 1.0 / h; glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w > h) gluOrtho2D(-aspect, aspect, -1, 1); else gluOrtho2D(-1, 1, -1/aspect, 1/aspect); } ຄ ໍ ານວນ aspect ratio ຂອງໜ ້ າຕ ່ າງ
30. Callback ສ ໍ າລ ັ ບເວລາໜ ້ າຕ ່ າງປ ່ ຽນຂະໜ າດ void reshape(int w, int h) { glViewport(0,0,w,h); if (w == 0) w = 1; if (h == 0) h = 1; double aspect = w * 1.0 / h; glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w > h) gluOrtho2D(-aspect, aspect, -1, 1); else gluOrtho2D(-1, 1, -1/aspect, 1/aspect); } ກ ້ ວາງ > ສ ູ ງ
31. Callback ສ ໍ າລ ັ ບເວລາໜ ້ າຕ ່ າງປ ່ ຽນຂະໜ າດ void reshape(int w, int h) { glViewport(0,0,w,h); if (w == 0) w = 1; if (h == 0) h = 1; double aspect = w * 1.0 / h; glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (w > h) gluOrtho2D(-aspect, aspect, -1, 1); else gluOrtho2D(-1, 1, -1/aspect, 1/aspect); } ສ ູ ງ > ກ ້ ວາງ
32. glViewport • void glViewport(GLint x, GLint y, GLsizei width, GLsizei height ) – ກ ໍ ານ ົ ດເນ ື ້ ອທ ີ່ ໃນໜ ້ າຕ ່ າງທ ີ່ ຈະໃຊ ້ ສະແດງຜ ົ ນ ພາບ ທ ີ່ OpenGL ສ ້ າງ – x, y, width, height ມ ີ ຫ ົ ວໜ ່ ວຍເປ ັ ນ Pixel – ຕ ໍ າແໜ ່ ງ (x,y) ກ ໍ ານ ົ ດຕ ໍ າແໜ ່ ງແຈເທ ິ ງຊ ້ າຍຂອງເນ ື ້ ອທ ີ່ – width ກ ໍ ານ ົ ດລວງກ ້ ວາງຂອງເນ ື ້ ອທ ີ່ – height ກ ໍ ານ ົ ດລວງສ ູ ງຂອງເນ ື ້ ອທ ີ່ • ໃນຕ ົ ວຢ ່ າງເຮ ົ າໃຊ ້ glViewport(0,0,w,h) ໝາຍຄວາມວ ່ າເຮ ົ າໃຊ ້ ເນ ື ້ ອທ ີ່ ທ ັ ງ ໝ ົ ດຂອງໜ ້ າຕ ່ າງ
33. Callback ສ ໍ າລ ັ ບເວລາໜ ້ າຕ ່ າງປ ່ ຽນຂະໜ າດ (ຕ ໍ່ ) • ເຮ ົ າເອ ີ ້ ນໃຊ ້ glMatrixMode(GL_PROJECTION); glLoadIdentity(); ກ ່ ອນຈະເອ ີ ້ ນ glOrtho2D(…); ເພ ື່ ອກ ໍ ານ ົ ດລະບ ົ ບບອກຕ ໍ າແໜ ່ ງ • ທ ັ ງສອງຟ ັ ງຊ ັ ງນ ີ ້ ກ ່ ຽວຂ ້ ອງກ ັ ບການກ ໍ ານ ົ ດ viewing transform ເຊ ິ ງເຮ ົ າຈະລ ົ ງເລ ີ ກໃນອ ີ ກສອງອາທ ິ ດ • ຕອນນ ີ ້ ໃຫ ້ ຈ ື່ ໄປກ ່ ອນວ ່ າຕ ້ ອງເອ ີ ້ ນໃຊ ້ ສອງຟ ັ ງຊ ັ ນນ ີ ້ ກ ່ ອນໃຊ ້ glOrtho2D
34. ວ ັ ດຖ ຸ ເລຂາຄະນ ິ ດໃນ OpenGL • OpenGL ສາມາດແຕ ້ ມວ ັ ດຖ ຸ ເລຂາຄະນ ິ ດແບບງ ່ າຍໄດ ້ 3 ຢ ່ າງ – ຈ ຸ ດ – ສ ່ ວນຂອງເສ ັ້ ນຊ ື່ – ຮ ູ ບຫ ຼ າຍລ ່ ຽມ • ບ ໍ່ ສາມາດແຕ ້ ມເສ ັ້ ນໂຄ ້ ງ ຫ ຼື ຜ ິ ວໂຄ ້ ງໄດ ້ • ແຕ ່ ເຮ ົ າສາມາດແຕ ້ ມເສ ັ້ ນໂຄ ້ ງໄດ ້ ໂດຍແຕ ້ ມ ຈ ຸ ດ ຕ ິ ດໆກ ັ ນ
35. Vertex • ການກ ໍ ານ ົ ດວ ັ ດຖ ຸ ເລຂາຄະນ ິ ດໃນ OpenGL ແມ ່ ນໃຫ ້ ກ ໍ ານ ົ ດ vertex ຫ ຼື ເອ ີ ້ ນວ ່ າ “ເມ ັ ດ” ຂອງ ວ ັ ດຖ ຸ – ເມ ັ ດໃນ OpenGL ມ ີ 1 vertex – ເສ ັ້ ນຊ ື່ ໃນ OpenGL ມ ີ 2 vertex (ຍ ້ ອນເສ ັ້ ນຊ ື່ ເກ ີ ດ ຈາກການລາກເສ ັ້ ນຈາກເມ ັ ດທ ີ່ ໜ ຶ່ ງໄປຫາເມ ັ ດທ ີ ສອງ) – ຮ ູ ບຫ ຼ າຍຫ ຼ ່ ຽມມ ີ ຈ ໍ ານວນ vertex ເທ ົ່ າກ ັ ບຈ ໍ ານວນ ລ ່ ຽມ • ສາມລ ່ ຽມ ມ ີ 3 vertex • ສ ີ່ ລ ່ ຽມມ ີ 4 vertex
36. glVertex • glVertex[234][sifd][v](TYPE coords) – ໃຊ ້ ກ ໍ ານ ົ ດຕ ໍ າແໜ ່ ງ vertex – ສາມາດມ ີ argument 2, 3, ຫ ຼື 4 ກ ໍ ໄດ ້ • ເຊ ັ່ ນ: x, y, z, w – W ຈະອະທ ິ ບາຍພາຍຫ ຼັ ງຈາກຮຽນເລ ື່ ອງ homogeneous coordinate • ຖ ້ າມ ີ 3 ໂຕ ຈະເຂ ົ້ າໃຈວ ່ າ w = 1 • ຖ ້ າມ ີ 2 ໂຕ ຈະເຂ ົ້ າໃຈວ ່ າ z = 0 ແລະ w = 1 • ປ ົ ກກະຕ ິ ຈະໃຊ ້ argument ພຽງ 3 ໂຕ – ຕ ົ ວຢ ່ າງ: • glVertex2i(10, 5) • glVertex3d(8, 7, 3.14153265)
37. glVertex (ຕ ໍ່ ) – ເພ ີ່ ມ v ເຂ ົ້ າໄປຖ ້ າຕ ້ ອງການ argument ເປ ັ ນ pointer ໄປຫາ array ຂອງຕ ໍ າແໜ ່ ງ • GLint p0[] = {1,2,3}; glVertex3iv(p0); • GLfloat *p1 = {2.0f, 3.0f, 4.0f, 5.0f}; glVertex4fv(p1)
38. ການກ ໍ ານ ົ ດວ ັ ດຖ ຸ ເລຂາຄະນ ິ ດ • ເລ ີ່ ມຕ ົ້ ນໂດຍ glBegin(ຊະນ ິ ດວ ັ ດຖ ຸ ) • ຫ ຼັ ງຈາກນ ັ້ ນໃຊ ້ glVertex ກ ໍ ານ ົ ດ vertex ຂອງວ ັ ດຖ ຸ ນ ັ້ ນ • ແລ ້ ວຈ ົ ບໂດຍໃຊ ້ glEnd() • ຕ ົ ວຢ ່ າງ: glBegin(GL_POLYGON); glVertex3f(-0.5f, -0.5f, 0.0f); glVertex3f(0.5f, -0.5f, 0.0f); glVertex3f(0.5f, 0.5f, 0.0f); glVertex3f(-0.5f, 0.5f, 0.0f); glEnd();
39. ຊະນ ິ ດຂອງວ ັ ດຖ ຸ ຄ ່ າທ ີ່ ເອ ົ າໄປໃສ ່ ໃນ glBegin(…) ຊະນ ິ ດຂອງວ ັ ດຖ ຸ 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 ຮ ູ ບຫ ຼ າຍລ ່ ຽມ
40. ຊະນ ິ ດຂອງວ ັ ດຖ ຸ (ຕ ໍ່ )
41. glColor • glColor[34][fd][v](TYPE colors) – ໃຊ ້ ກ ໍ ານ ົ ດສ ີ ໃຫ ້ ກ ັ ບ vertex – ກ ໍ ານ ົ ດແລ ້ ວ vertex ຈະມ ີ ສ ີ ນ ັ້ ນໄປຕະຫ ຼ ອດຈ ົ ນກວ ່ າຈະ ເອ ີ ້ ນ glColor ໃໝ ່ ເພ ື່ ອປ ່ ຽນມ ັ ນ – ສາມາດມ ີ argument 3, ຫ ຼື 4 ໂຕກ ໍ ໄດ ້ • Argument ຄ ື r (ສ ີ ແດງ, g (ສ ີ ຂຽວ), b (ສ ີ ນ ໍ້ າເງ ິ ນ), a (ຄວາມໃສ) • ແຕ ່ ລະໂຕມ ີ ຄ ່ າຕ ັ້ ງແຕ ່ 0.0 (ບ ໍ່ ມ ີ ຄວາມເຂ ັ້ ມ) ເຖ ິ ງ 1.0 (ຄວາມ ເຂ ັ້ ມສ ຸ ດ) • ຖ ້ າມ ີ argument ສາມໂຕ a ຈະມ ີ ຄ ່ າເທ ົ່ າກ ັ ບ 1.0 (ທ ຶ ບແສງ) – ຕ ົ ວຢ ່ າງ • glColor3f(1.0f, 1.0f, 0.0f) = ສ ີ ເຫ ຼື ອງ • glColor4d(0.5f, 0.5f, 0.5f, 0.5f) = ສ ີ ເທ ົ າ ຄວາມໃສ 50%
42. glColor (ຕ ໍ່ ) – ເພ ີ່ ມ v ຖ ້ າຕ ້ ອງການໃຫ ້ argument ເປ ັ ນ pointer ໄປ ຫາ array ຂອງສ ີ • GLdouble color0[] = {0,1,1}; gColor3dv(p0); • GLfloat *color1 = {0.1f, 0.9f, 0.5f, 0.75f}; glVert4fv(p1) – ຄວາມໃສ ຈະບ ໍ່ ມ ີ ຜ ົ ນຈ ົ ນກວ ່ າຈະບອກ OpenGL ໃຫ ້ ຈ ັ ດການກ ັ ບຄວາມໃສ (ຈະຍ ັ ງບ ໍ່ ອະທ ິ ບາຍໃນຕອນ ນ ີ ້ )
43. ຕ ົ ວຢ ່ າງ glBegin(GL_TRIANGLES); // Red glColor3f(1.0f, 0.5f, 0.5f); glVertex3f( 0.0f, 0.5f, 0.0f); glVertex3f(-0.25f, 0.0f, 0.0f); glVertex3f( 0.25f, 0.0f, 0.0f); // Green glColor3f(0.5f, 1.0f, 0.5f); glVertex3f( -0.25f, 0.0f, 0.0f); glVertex3f( -0.5f, -0.5f, 0.0f); glVertex3f( 0.0f, -0.5f, 0.0f); // Blue glColor3f(0.5f, 0.5f, 1.0f); glVertex3f( 0.25f, 0.0f, 0.0f); glVertex3f( 0.0f, -0.5f, 0.0f); glVertex3f( 0.5f, -0.5f, 0.0f); glEnd();
44. ຕ ົ ວຢ ່ າງ glBegin(GL_QUADS); glColor3f( 1.0f, 1.0f, 0.0f); glVertex3f(-0.5f, -0.5f, 0.0f); glColor3f( 1.0f, 0.0f, 1.0f); glVertex3f( 0.5f, -0.5f, 0.0f); glColor3f( 1.0f, 1.0f, 1.0f); glVertex3f( 0.5f, 0.5f, 0.0f); glColor3f( 0.0f, 1.0f, 1.0f); glVertex3f(-0.5f, 0.5f, 0.0f); glEnd();
45. ຕ ົ ວຢ ່ າງ glBegin(GL_LINE_LOOP); for(int i=0;i<256;i++) { double theta = 2*i*M_PI/256; double y = 0.75*sin(theta); double x = 0.75*cos(theta); glVertex2d(x,y); } glEnd();
46. ຮ ູ ບຫ ຼ າຍລ ່ ຽມ • ຮ ູ ບຫ ຼ າຍລ ່ ຽມທ ີ່ ແຕ ້ ມໂດຍ glBegin(GL_POLYGON) ຈະມ ີ ຄ ຸ ນສ ົ ມບ ັ ດດ ັ່ ງນ ີ ້ – ເສ ັ້ ນຂອບຈະຕ ້ ອງບ ໍ່ ຕ ິ ດກ ັ ນ – ຮ ູ ບຫ ຼ າຍລ ່ ຽມນ ັ້ ນຈະຕ ້ ອງເປ ັ ນຮ ູ ບນ ູ ນ – ຮ ູ ບຫ ຼ າຍລ ່ ຽມນ ັ້ ນຈະຕ ້ ອງບ ໍ່ ມ ີ “ຮ ູ ”
47. ຖ ້ າບ ໍ່ ມ ີ ຄ ໍ າຖາມ ສະແດງວ ່ າ ເຂ ົ້ າໃຈດ ີ