G IỚI THIỆU
OpenGL là một thư viện đồ họa cấp thấp, cung cấp cho lập trình viên một tập hợp các hình học cơ bản như điểm, đường, đa giác, hình ảnh và ảnh bitmap Thư viện này cho phép xác định các đặc điểm của các đối tượng hình học trong không gian hai hoặc ba chiều thông qua một bộ lệnh mạnh mẽ Ngoài ra, OpenGL còn hỗ trợ các lệnh điều khiển việc kết xuất các đối tượng này thông qua GLUT.
OpenGL cho phép người dùng tạo ra các hình học đơn giản như điểm, đường và đa giác, nhưng để phát triển các đối tượng ba chiều phức tạp hơn như quả cầu, xuyến hay ấm trà, OpenGL Utility Toolkit đã được phát triển Mặc dù GLUT có thể không đáp ứng đầy đủ các tính năng của ứng dụng OpenGL, nó vẫn là một khởi đầu hữu ích cho những ai muốn tìm hiểu về OpenGL.
GLUT được phát triển nhằm cung cấp một hệ thống độc lập cho việc lập trình giao diện cửa sổ cho các ứng dụng OpenGL Giao diện của GLUT được thiết kế đơn giản nhưng vẫn đáp ứng đầy đủ nhu cầu của các chương trình hữu ích.
Việc loại bỏ các hoạt động hệ thống cửa sổ khỏi OpenGL là một quyết định hợp lý, giúp hệ thống đồ họa này có khả năng tái định hướng cho nhiều nền tảng khác nhau Điều này bao gồm cả các máy trạm đồ họa mạnh mẽ, hệ thống đồ họa sản xuất hàng loạt như trò chơi video, hộp set-top cho truyền hình tương tác và máy tính cá nhân.
GLUT giúp đơn giản hóa quá trình thực hiện các chương trình sử dụng OpenGL để kết xuất đồ họa Việc áp dụng giao diện lập trình ứng dụng (API) này yêu cầu một số thói quen nhất định để hiển thị cảnh kết xuất một cách hiệu quả.
OpenGL.Việc dư thừa thói quen cũng có thông số tương đối ít
C ÁCH CÀI ĐẶT
Môi trường cài đặt
Quá trình nghiên cứu và phát triển chương trình diễn ra trên hệ điều hành Linux, cụ thể là Ubuntu 10.10 OpenGL là bộ thư viện mã nguồn mở, có thể sử dụng trên cả Windows và Ubuntu Tuy nhiên, Ubuntu, với tính chất mở và kho tài liệu phong phú, cung cấp một cộng đồng hỗ trợ nhiệt tình cho người dùng khi gặp khó khăn.
Các gói thƣ viện của openGL : GLUT,AUX, XLIB…
Cài đặt
Cài đặt trình biên dịch C/C++ GNU: tại terminal gõ Sudo apt-get install gcc
Sau khi cài đặt kiểm tra lại thử đã có hay chƣa
Cài đặt bộ thƣ viện Opengl
Administrator->synaptic->search với từ khóa opengl: Lựa chọn và make các file cần thiết và apply
Sử dụng thƣ viện openGL
Cách biên dịch 1 bài C đơn giản
CƠ BẢN VỀ OPENGL
C ẤU TRÚC CHƯƠNG TRÌNH OPEN GL ĐƠN GIẢN
Để bắt đầu với GLUT, điều quan trọng là gọi hàm glutInit() để khởi tạo thư viện GLUT trước khi tạo bất kỳ đối tượng nào Các tham số cần thiết cho glutInit() được truyền từ hàm main(), bao gồm int argc và char **argv Sau khi gọi hàm này, giá trị của argc sẽ được cập nhật, trong khi argv sẽ giữ nguyên giá trị ban đầu Tiếp theo, chúng ta cần sử dụng hàm glutInitDisplayMode() để xác định chế độ hiển thị cho cửa sổ, nơi bạn cần quyết định giữa mô hình màu RGBA (GLUT_RGBA) hoặc màu chỉ số (GLUT_INDEX) Mô hình RGBA lưu trữ các thành phần màu sắc gồm đỏ, xanh lá cây, xanh dương và alpha.
Giá trị alpha trong thiết kế đồ họa phản ánh độ trong suốt, với alpha là 1.0 biểu thị độ mờ hoàn toàn và 0.0 thể hiện độ trong suốt tối đa Ngoài ra, chế độ chỉ số màu sắc, tương phản và màu sắc bộ đệm cũng đóng vai trò quan trọng trong việc quản lý và hiển thị các chỉ số màu trong các cửa hàng.
Quyết định về chế độ màu cần dựa trên phần cứng và yêu cầu ứng dụng; chế độ RGBA thường phù hợp hơn cho màu sắc đặc biệt so với chế độ chỉ số màu Đối với các hiệu ứng như bóng, ánh sáng và sương mù, chế độ RGBA mang lại tính linh hoạt cao hơn Vì vậy, nên sử dụng chế độ RGBA bất cứ khi nào có thể, vì đây là chế độ mặc định.
Khi thiết lập chế độ hiển thị, bạn cần quyết định giữa việc sử dụng đệm đơn (GLUT_SINGLE) hoặc đệm đôi (GLUT_DOUBLE) Các ứng dụng sử dụng cả bộ đệm màu sắc phía trước và phía sau thường sử dụng đệm đôi Để tạo hiệu ứng mượt mà cho hoạt hình, bạn sẽ vẽ vào bộ đệm phía sau (không hiển thị) trước, sau đó hoán đổi mặt trước và mặt sau của bộ đệm Nếu không cần sử dụng hoạt hình, bạn nên chọn đệm đơn, vì đây là tùy chọn mặc định.
Khi quyết định sử dụng các bộ đệm trong lập trình đồ họa, bạn cần xem xét bộ đệm chiều sâu (GLUT_DEPTH), bộ đệm stencil (GLUT_STENCIL) và bộ đệm tích lũy (GLUT_ACCUM) Bộ đệm chiều sâu lưu trữ giá trị độ sâu cho mỗi điểm ảnh, cho phép hiển thị các đối tượng có giá trị độ sâu nhỏ hơn ở phía trước Bộ đệm stencil giúp hạn chế việc vẽ vào một phần cụ thể của màn hình, tương tự như cách sử dụng stencil trong nghệ thuật Cuối cùng, bộ đệm tích lũy cho phép tích lũy nhiều hình ảnh để tạo ra một hình ảnh cuối cùng Tuy nhiên, các bộ đệm này không phải là mặc định trong hệ thống.
Để tạo ra các đặc tính của cửa sổ trong lập trình, bạn cần sử dụng hàm glutInitWindowSize() để xác định kích thước cửa sổ ban đầu bằng chiều cao và chiều rộng (tính bằng pixel) Bên cạnh đó, hàm glutInitWindowPosition() sẽ giúp xác định vị trí hiển thị cho góc trên bên trái của cửa sổ Các giá trị x và y sẽ chỉ ra vị trí của cửa sổ so với toàn bộ màn hình hiển thị.
2.1.2 Tạo của sổ Để thực sự tạo ra một cửa sổ, với các thiết lập đặc điểm trước đó (hiển thị chế độ, kích thước, vị trí, vv), sử dụng glutCreateWindow () để khởi tạo
Lệnh này chứa một chuỗi tham số có thể hiển thị trong thanh tiêu đề nếu hệ điều hành hỗ trợ Tuy nhiên, cửa sổ sẽ không hiển thị cho đến khi glutMainLoop() được gọi.
Hàm glutDisplayFunc() là một sự kiện quan trọng trong việc gọi lại và hiển thị nội dung Đây là nơi mà các hàm đã được định nghĩa tương ứng với các sự kiện cụ thể Cụ thể, đối số của glutDisplayFunc() chỉ định hàm mà GLUT sẽ gọi để cập nhật nội dung hiển thị trong cửa sổ Do đó, bạn nên đặt tất cả các hàm cần thiết để hiển thị cảnh vào trong hàm gọi lại này.
2.1.4 Chức năng định lại hình
Hàm glutReshapeFunc() là một hàm gọi lại, được sử dụng để xác định hành động cần thực hiện khi cửa sổ được thu nhỏ hoặc di chuyển.
Các chức năng này thường được gọi khi cần thay đổi hình dáng hiển thị của cửa sổ với kích thước mới và định nghĩa lại các đặc tính xem theo mong muốn Nếu glutReshapeFunc() không được gọi, một số tính năng có thể không hoạt động đúng cách.
Chức năng thay đổi hình dáng, được gọi là bộ giao diện, giúp giảm thiểu sự biến dạng và nâng cao chất lượng hiển thị trên các màn hình.
Cuối cùng, hàm glutMainLoop() được gọi để hiển thị tất cả các cửa sổ đã tạo và xử lý hiệu quả các sự kiện như click chuột và thay đổi kích thước cửa sổ Khi vòng lặp này được bắt đầu, chương trình sẽ không bao giờ thoát và các cuộc gọi lại hiển thị từ glutDisplayFunc() sẽ được kích hoạt Cần lưu ý rằng các lệnh OpenGL không được thực hiện ngay lập tức; do đó, việc gọi glFlush() là cần thiết để đảm bảo tất cả các lệnh đã phát hành được thực thi Thông thường, glFlush() được gọi ở cuối chuỗi các lệnh vẽ để đảm bảo tất cả các đối tượng trong cảnh được vẽ trước khi chấp nhận đầu vào từ người dùng.
2.1.6 Mã nguồn 1 chương trình đơn giản
Cấu trúc một chương trình
#include void handleKeypress(unsigned char key, int x, int y) {
} void initRendering() { glEnable(GL_DEPTH_TEST);
} void handleResize(int w, int h) { glViewport(0, 0, w, h);
} int main(int argc, char** argv) { //Khoi tao GLUT glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB
// Tao cua so glutCreateWindow("Demo"); initRendering(); //Khoi tao cac thuoc tinh lien qua
// cac ham ve, lay ban phim va resize glutDisplayFunc(drawScene); glutKeyboardFunc(handleKeypress); glutReshapeFunc(handleResize); glutMainLoop(); //vong lap chinh de duy tri su ve return 0;
Ví dụ chương trình đơn giản “Hello.c”
#include void display(void)
{ glClear (GL_COLOR_BUFFER_BIT); glColor3f (1.0, 1.0, 1.0); glBegin(GL_POLYGON); glVertex3f (0.25, 0.25, 0.0); glVertex3f (0.75, 0.2 5, 0.0); glVertex3f (0.75, 0.75, 0.0); glVertex3f (0.25, 0.75, 0.0); glEnd(); glFlush ();
13 glClearColor (0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
} int main(int argc, char** argv)
{ glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (250, 250); glutInitWindowPosition (100, 100); glutCreateWindow ("hello"); init (); glutDisplayFunc(display); glutMainLoop(); return 0;
D Ữ LIỆU VÀ THUỘC TÍNH
OpenGL sử dụng tiền tố "gl" cho các lệnh, ví dụ như glClearColor(), và xác định các hằng số bắt đầu bằng "GL_" với tất cả chữ in hoa, phân tách các từ bằng gạch dưới, như trong trường hợp của GL_COLOR_BUFFER_BIT.
Trong lập trình đồ họa, bạn có thể nhận thấy một số lệnh có hậu tố không liên quan, chẳng hạn như "3f" trong "glColor3f()" Hậu tố này giúp xác định rằng lệnh thuộc về bộ màu sắc hiện hành Mặc dù nhiều lệnh khác nhau đã được định nghĩa để cho phép sử dụng các loại đối số khác nhau, nhưng phần "3" trong hậu tố chỉ ra rằng ba đối số được cung cấp là phiên bản của lệnh màu có bốn tham số Hậu tố "f" cho biết rằng các đối số là số điểm float.
OpenGL chấp nhận có đến tám loại dữ liệu khác nhau cho các đối số của họ
Các ký tự được sử dụng như hậu tố để xác định kiểu dữ liệu trong ANSI C cho việc triển khai OpenGL được trình bày trong Bảng 1-1, kèm theo các định nghĩa loại tương ứng của OpenGL Tuy nhiên, việc thực hiện cụ thể của OpenGL mà bạn đang sử dụng có thể không hoàn toàn tuân theo sơ đồ này; ví dụ, một triển khai trong C++ hoặc Ada có thể không cần phải tuân theo.
Hai lệnh glVertex2i(1, 3) và glVertex2f(1.0, 3.0) đều có chức năng tương đương trong OpenGL Tuy nhiên, lệnh đầu tiên sử dụng tọa độ đỉnh dưới dạng số nguyên 32-bit, trong khi lệnh thứ hai sử dụng tọa độ với độ chính xác của số thực.
OpenGL hoạt động như một máy trạng thái, cho phép bạn chuyển đổi giữa các trạng thái khác nhau, và các chế độ này sẽ vẫn giữ hiệu lực cho đến khi chúng được thay đổi Một ví dụ điển hình là màu sắc, hiện tại được coi là một biến trạng thái, có thể được thiết lập thành các giá trị như trắng hoặc đỏ.
Màu sắc hiện tại trong OpenGL là một trong nhiều biến trạng thái mà hệ thống lưu trữ, cho phép bạn vẽ các đối tượng với màu sắc đã thiết lập Các biến trạng thái này kiểm soát nhiều yếu tố như cách nhìn, biến đổi chiếu, đường và mẫu cho các đối tượng đa giác, cũng như chế độ vẽ và các thuộc tính pixel Việc kích hoạt hoặc vô hiệu hóa các chế độ này được thực hiện thông qua các lệnh glEnable() và glDisable().
Mỗi biến trạng thái đều có giá trị mặc định và bạn có thể truy vấn giá trị hiện tại của từng biến tại bất kỳ thời điểm nào Để thực hiện việc này, bạn thường sử dụng một trong bốn lệnh: glGetBooleanv(), glGetDoublev(), glGetFloatv(), hoặc glGetIntegerv(), tùy thuộc vào kiểu dữ liệu bạn cần Ngoài ra, một số biến trạng thái có các lệnh truy vấn cụ thể hơn như glGetLight*() hoặc glGetError().
Bạn có thể sử dụng các lệnh glGetPolygonStipple() để lưu và khôi phục các giá trị của biến trạng thái thông qua glPushAttrib() và glPopAttrib() Việc sử dụng các lệnh này thay vì các lệnh truy vấn khác sẽ mang lại hiệu quả cao hơn.
Danh sách toàn bộ các biến trạng thái có thể truy vấn được có trong Phụ lục B Phụ lục này cũng cung cấp thông tin về các hàm *glGet tương ứng với từng biến.
() lệnh trả về giá trị của biến, lớp thuộc tính mà nó thuộc về, và giá trị mặc định của biến.
C ÁC THƢ VIỆN LIÊN QUAN
OpenGL là một thư viện mạnh mẽ cung cấp nhiều lệnh vẽ và hỗ trợ cho lập trình viên Việc phát triển một thư viện riêng dựa trên OpenGL có thể giúp đơn giản hóa quy trình lập trình Bên cạnh đó, việc tạo ra các thủ tục chương trình OpenGL cũng có thể làm cho công việc trở nên dễ dàng hơn.
Hệ thống cửa sổ của bạn có thể được cải thiện đáng kể bằng cách áp dụng các thói quen và thư viện đã được chứng minh Những yếu tố này cung cấp các tính năng chuyên ngành, giúp tối ưu hóa hiệu suất và tính năng của hệ thống.
Thư viện OpenGL Utility Library (GLU) cung cấp các thủ tục sử dụng lệnh OpenGL cấp thấp để thiết lập ma trận cho các định hướng xem cụ thể và thực hiện các tác vụ như lo t đa giác và vẽ bề mặt GLU là một phần không thể thiếu của triển khai OpenGL và được mô tả chi tiết trong Phụ lục C cùng với Tài liệu Tham khảo OpenGL Tất cả các hàm trong GLU đều bắt đầu bằng tiền tố "glu".
The OpenGL Extension to the X Window System (GLX) offers a method for creating an OpenGL context and linking it to a drawable window on a machine that utilizes the X Window System.
System GLX đƣợc cung cấp nhƣ là một hỗ trợ cho OpenGL Đó là mô tả chi tiết hơn trong cả hai D Phụ lục và OpenGL Reference
Manual Một trong những sử dụng GLX (cho framebuffer trao đổi) đƣợc mô tả trong "hoạt hình” GLX sử dụng tiền tố glx
The OpenGL Programming Guide Auxiliary Library ( AUX ),
Thư viện được thiết kế đặc biệt cho cuốn sách này nhằm minh họa các ví dụ lập trình đơn giản và chưa hoàn chỉnh Chủ đề này sẽ được khai thác chi tiết trong Phụ lục E, nơi sử dụng tiền tố aux Phần "Làm thế nào để Lấy mẫu mã" sẽ hướng dẫn cách thu thập mã nguồn cho các thư viện phụ trợ.
Open Inventor là một bộ công cụ định hướng đối tượng dựa trên
OpenGL là một công cụ mạnh mẽ cho việc phát triển ứng dụng đồ họa 3D tương tác Được phát triển bởi Silicon Graphics và lập trình bằng C++, Open Inventor cung cấp các đối tượng và phương pháp tích hợp sẵn, giúp xây dựng mô hình một cách hiệu quả cho người dùng.
17 ứng dụng cao cấp cho việc tạo và chỉnh sửa cảnh 3D, bao gồm khả năng in ấn các đối tượng và trao đổi dữ liệu trong nhiều định dạng đồ họa khác nhau.
H OẠT CẢNH (A NIMATION )
Hoạt hình là một yếu tố quan trọng trong đồ họa máy tính, cho phép người dùng tạo ra hình ảnh chuyển động mượt mà, từ việc thiết kế cơ khí cho đến mô phỏng bay hoặc trò chơi điện tử Để tạo ra chuyển động, kỹ sư thường thay đổi các frame, nhưng việc vẽ xóa liên tục có thể làm giảm hiệu suất hệ thống và khiến hình ảnh không mượt mà OpenGL cung cấp các thư viện và phương pháp hiệu quả để đưa các frame vào bộ đệm, giúp cải thiện chất lượng hình ảnh và trải nghiệm người dùng.
Ví dụ minh họa việc sử dụng các glXSwapBuffers () trong một ví dụ đó rút ra một hình vuông mà quay liên tục, nhƣ trong hình.
CÁC KỸ THUẬT OPENGL CƠ BẢN
C ÁC ĐỐI TƢỢNG HÌNH HỌC ( G EOMETRIC O BJECTS )
Tất cả các hình khối trong OpenGL được vẽ giữa hai dòng lệnh glBegin() và glEnd(), tương tự như trong Pascal Có thể sử dụng nhiều cặp dòng lệnh này để viết các hàm vẽ khác nhau Tham số của glBegin() là GL_LINE_LOOP, cho phép vẽ một đường khép kín với điểm đầu trùng với điểm cuối.
Dưới đây là một số hằng số cơ bản:
GL_LINE Vẽ đường thẳng nối hai điểm
GL_LINE_STRIP Tập hợp của những đoạn đựơc nối với nhau
GL_LINE_LOOP Đường gấp khúc khép kín
GL_TRIANGLES Vẽ hình tam giác
GL_QUADS Vẽ tứ giác
GL_TRIANGLES_STRIP Vẽ một tập hợp các tam giác liền nhau, chung một cạnh
GL_QUAD_STRIP Vẽ một tập hợp các tứ giác liền nhau, chung một cạnh
GL_TRIANGLE_FAN Vẽ hình quạt Dưới đây là bức tranh toàn cảnh về các thông số này
Mỗi đối tượng hình học được mô tả thông qua một tập hợp các đỉnh và các loại nguyên thủy Đỉnh A không chỉ là một điểm xác định trong không gian ba chiều, mà còn phụ thuộc vào cách các đỉnh được kết nối qua các loại nguyên thủy Mỗi đối tượng hình học cuối cùng được mô tả bằng cách thiết lập các đỉnh, và lệnh *glVertex() được sử dụng để xác định một đỉnh Dấu '*' chỉ ra rằng có những khác biệt trong các lệnh cơ bản của glVertex().
Một số tên lệnh OpenGL có các ký tự ở cuối để chỉ định số lượng và loại tham số Ký tự đầu tiên thể hiện số lượng giá trị cần thiết cho lệnh, trong khi ký tự thứ hai xác định loại hình cụ thể của các đối số Nếu có ký tự 'v' ở cuối, điều này cho biết lệnh sử dụng một con trỏ tới một mảng (vector) giá trị thay vì một chuỗi các đối số riêng lẻ.
Trong lệnh glVertex3fv(), chữ '3' chỉ ra ba đối số, 'f' biểu thị các đối số là điểm trôi, và 'v' cho biết các đối số ở định dạng vector Điểm A được xác định bởi một đỉnh duy nhất, với đỉnh này được quy định bởi người sử dụng dưới dạng hai chiều (chỉ có tọa độ x và y) Để điều chỉnh kích thước của điểm kết xuất, bạn có thể sử dụng hàm glPointSize() và cung cấp kích thước mong muốn.
Mặc định, mỗi điểm ảnh tương ứng với một pixel Khi chiều rộng được thiết lập là 2.0, mỗi điểm sẽ trở thành một hình vuông có kích thước 2x2 pixel Hàm glVertex*() được sử dụng để mô tả một điểm, nhưng chỉ có hiệu lực khi nằm giữa cặp hàm glBegin() và glEnd() Các tham số truyền cho glBegin() sẽ xác định loại hình học nguyên thủy được tạo ra từ các đỉnh.
Ví dụ : glBegin (GL_POINTS) ; glVertex2f(0.0, 0.0) ; glVertex2f(0.0, 3.0) ; glVertex2f(4.0, 3.0) ; glVertex2f(6.0, 1.5) ; glVertex2f(4.0, 0.0) ; glEnd() ;
Trong OpenGL, một dòng được định nghĩa là một đoạn đường với điểm đầu và điểm cuối, không phải là một phiên bản toán học kéo dài vô hạn Cách đơn giản nhất để xác định một đường là thông qua hai điểm này.
21 trên, tham số truyền cho glBegin () bắt đầu thực hiện vẽ Các tùy chọn cho các dòng bao gồm:
GL_LINES: Vẽ một loạt các đoạn đường chưa được nối rút ra giữa mỗi thiết lập các đỉnh Một đỉnh không liên quan đƣợc bỏ qua
GL_LINE_STRIP: Vẽ một đoạn thẳng từ đỉnh đầu đến cuối Đường có thể cắt nhau tùy tiện
GL_LINE_LOOP: Tương tự như GL_STRIP, ngoại trừ một đoạn đường cuối cùng được rút ra từ các đỉnh cuối cùng trở về đầu tiên
Trong OpenGL, mô tả hình dạng của một đối tượng được rút ra là độc lập với màu sắc của nó Khi một đối tượng hình học được rút ra, màu sắc được quy định thông qua các chương trình Quá trình lập trình OpenGL thường bắt đầu bằng việc thiết lập màu sắc bằng hàm *glColor() trước khi rút ra các đối tượng Tất cả các đối tượng sẽ được rút ra với màu sắc đã thiết lập cho đến khi có sự thay đổi về màu sắc.
Đa giác là các khu vực được bao bọc bởi một vòng khép kín của các phân đoạn đường, với các đoạn đường được quy định bởi các đỉnh tại điểm cuối Ví dụ trong mã OpenGL cho thấy cách sử dụng hàm glBegin và glEnd để vẽ đa giác, nơi màu sắc được xác định bằng glColor3f và các đỉnh được chỉ định bằng glVertex2f Đa giác có thể được vẽ với các điểm ảnh để điền màu hoặc chỉ đơn giản là phác thảo.
Trong OpenGL, có một số hạn chế đối với hình dạng của đa giác nguyên thủy, bao gồm việc các cạnh không được cắt nhau và phải lồi Để tạo ra các đa giác cụ thể, có các lệnh như glBegin (GL_TRIANGLES) cho tam giác và glBegin (GL_QUADS) cho tứ giác Đối với trường hợp tổng quát của đa giác, người dùng có thể sử dụng lệnh glBegin (GL_POLYGON) để định nghĩa.
Ví dụ : glBegin(GL_POLYGON); glColor3f(1.0, 1.0, 0.0); // yellow glVertex2f(0.0, 0.0) glVertex2f(0.0, 3.0) glVertex2f(4.0, 3.0) glVertex2f(6.0, 1.5) glVertex2f(4.0, 0.0) glEnd();
3.1.2 Vẽ các đối tƣợng không gian ( Drawing 3-D Objects )
GLUT cung cấp nhiều bản vẽ tiêu chuẩn để tạo ra mô hình ba chiều, giúp tiết kiệm thời gian khi không cần định nghĩa lại mã vẽ cho từng chương trình Điều này cho phép tất cả các đồ họa được hiển thị ngay lập tức Mỗi đối tượng đồ họa có thể được hiển thị dưới dạng wireframe hoặc solid và đều được cung cấp sẵn.
3.1.3 Các phép biến đổi ( Transformations )
Việc chuyển đổi mô hình được sử dụng để định vị và định hướng mô hình
Bạn có thể thực hiện các hoạt động như xoay, dịch thuật hoặc thay đổi kích thước các mô hình, hoặc kết hợp các hoạt động này Để tạo cảm giác rằng một đối tượng đang di chuyển ra xa khỏi người xem, có hai tùy chọn: người xem có thể tiến lại gần đối tượng hoặc đối tượng có thể được di chuyển ra xa khỏi người xem.
Chúng ta sẽ thảo luận về việc chuyển người xem sau khi xem xét các phép biến đổi Hiện tại, chúng tôi sẽ giữ vị trí mặc định của "máy ảnh" tại gốc tọa độ, hướng về phía trục z tiêu cực, thẳng đứng với mặt phẳng xem.
Khi thực hiện chuyển đổi, một chuỗi phép nhân ma trận được áp dụng để điều chỉnh vị trí, định hướng và nhân rộng các mô hình.
Các phép nhân ma trận thực hiện theo thứ tự ngược lại với cách chúng xuất hiện trong các mã, vì vậy trình tự chuyển đổi rất quan trọng Nếu bạn thực hiện chuyển đổi A trước và sau đó là B, bạn sẽ thường nhận được kết quả khác so với khi thực hiện theo thứ tự ngược lại.
Scaling: lệnh glScale () nhân ma trận hiện tại của một ma trận trải dài, co lại, hoặc phản ánh một đối tƣợng dọc theo các trục
Mỗi phối hợp x, y và z của tất cả các điểm trong đối tượng được nhân với tham số tương ứng Hàm *glScale()* là một phần của chuyển đổi mô hình ba chiều, cho phép thay đổi kích thước rõ ràng của một đối tượng: nhân với giá trị lớn hơn 1,0 sẽ làm đối tượng được kéo dài, trong khi giá trị nhỏ hơn 1,0 sẽ làm co lại Việc sử dụng giá trị -1,0 trong phép scaling sẽ phản ánh đối tượng trên một trục.
Translation :lệnh dịch glTranslate () nhân ma trận hiện tại của một ma trận chuyển động (dịch) một đối tƣợng do cho x-, y, và z-giá trị
K HUNG HIỂN THỊ ( V IEWING )
Vẽ trên màn hình máy tính khác với việc vẽ trên giấy, bởi vì giấy bắt đầu với màu trắng và bạn chỉ cần tạo ra các bức tranh Trong khi đó, trên máy tính, bộ nhớ thường chứa hình ảnh cuối cùng bạn đã vẽ, vì vậy bạn cần xóa chúng bằng cách thay đổi màu nền trước khi bắt đầu vẽ cảnh mới Để thực hiện điều này, bạn sử dụng hàm glClearColor() để chỉ định màu sắc cho nền, với màu mặc định là đen (0,0,0,0) Sau đó, gọi hàm glClear() để xóa các vùng đệm đã được chỉ định để hiển thị.
Để thiết lập màu sắc trong OpenGL, bạn sử dụng lệnh glColor3f() với ba tham số kiểu thực trong khoảng từ 0.0 đến 1.0, đại diện cho các thành phần màu đỏ, xanh lá cây và xanh dương Các tham số này cho phép bạn tạo ra một "hỗn hợp" màu sắc, trong đó 0.0 có nghĩa là không sử dụng thành phần màu nào và 1.0 có nghĩa là sử dụng toàn bộ thành phần đó Ví dụ, lệnh glColor3f(1.0, 0.0, 0.0) sẽ tạo ra màu đỏ sáng nhất mà hệ thống có thể hiển thị, không có thành phần màu xanh lá cây hoặc xanh dương.
Tất cả số không tạo ra màu đen, biểu thị sự thiếu ánh sáng màu, trong khi số trắng biểu thị sự có mặt của tất cả các ánh sáng màu Có tám màu cơ bản và các quy tắc liên quan đến chúng.
Cho đến nay, chúng tôi chỉ sử dụng một màu duy nhất cho mỗi đa giác, nhưng có thể chỉ định một màu khác nhau cho mỗi đỉnh OpenGL sẽ nội suy màu sắc giữa các đỉnh, quá trình này được gọi là Gouraud Shading (hay còn gọi là trơn bóng).
OpenGL thực hiện việc nội suy tuyến tính các giá trị RGB cho các điểm ảnh dọc theo các cạnh giữa các đỉnh, tạo ra sự chuyển đổi màu sắc mượt mà và dần dần.
In this OpenGL example, we utilize the `glBegin(GL_QUADS)` function to draw two shaded polygons The first polygon is colored using `glColor3f` with values for red, green, and cyan, while specifying the vertices with `glVertex2f` coordinates The second polygon employs different color interpolations with shades of gray and white Each vertex is defined with precise coordinates to create a visually appealing representation of the polygons The drawing process concludes with `glEnd()`, encapsulating the entire rendering of the shapes.
3.2.3 Khung hình biến đổi ( Viewing Transformation )
Để thay đổi góc nhìn của người xem, chúng ta sẽ thực hiện các biến đổi tương tự như khi điều chỉnh một đối tượng Bắt đầu, chúng ta khởi tạo ma trận xem bằng cách sử dụng lệnh glLoadIdentity() để thiết lập bản sắc ma trận, sau đó kết hợp nó với các biến đổi mới nhằm định vị "máy ảnh" ở vị trí mong muốn.
Các gluLookAt lệnh được sử dụng để chỉ ra nơi người xem được đặt, mà nó là nhằm mục đích, và có cách là lên
Ví dụ, gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0,0) ; nơi máy ảnh (hoặc mắt vị trí) tại điểm (0,0,5), nhằm mục đích để hướng đến nguồn gốc (0 , 0,0) và xác định véc tơ-up là (0,1,0)
Hiện nay, chúng ta cần xem xét khái niệm về việc loại bỏ mặt ẩn, một quá trình giúp "ẩn" các đối tượng đứng phía sau Điều quan trọng là chúng ta có một bộ đệm chiều sâu, cho phép theo dõi độ sâu của từng điểm ảnh trong cảnh.
Một giá trị sâu các đối tƣợng là sự khác biệt giữa các quan điểm và đối tƣợng
Để sử dụng bộ đệm chiều sâu, bạn cần kích hoạt nó bằng cách sử dụng GL_DEPTH_TEST trong hàm glEnable() Đừng quên xoá bộ đệm độ sâu trước khi vẽ lại khung hình bằng glClearDepth() Khi bộ đệm được kích hoạt, các điểm ảnh hiển thị sẽ có màu sắc của đối tượng với giá trị z nhỏ nhất, giúp đối tượng đó xuất hiện gần hơn so với các đối tượng khác.
Việc chuyển đổi chiếu tương tự như việc chọn ống kính cho máy ảnh, vì nó liên quan đến việc xác định các lĩnh vực cần chú ý.
OpenGL cung cấp hai loại cơ bản để hiển thị đối tượng: chữ viết và phối cảnh Điều này ảnh hưởng đến cách mà người xem tiếp cận và đánh giá các đối tượng bên trong không gian 3D.
Chữ viết (Orthographic) là phương pháp chiếu trực giao, cho phép hiển thị các đối tượng trên màn hình mà không làm thay đổi kích thước tương đối của chúng Phương pháp này thường được áp dụng trong thiết kế kiến trúc và các phần mềm hỗ trợ máy tính, nơi mà các phép đo thực tế của đối tượng quan trọng hơn so với hình dáng bên ngoài của chúng Để thiết lập chuyển đổi chiếu, lệnh glFrustum() được sử dụng, kết hợp với lệnh glMatrixMode() để điều chỉnh chế độ ma trận.
Đối số GL_PROJECTION được sử dụng để thiết lập các ma trận cho sự chuyển đổi chiếu và biến đổi Chúng tôi khởi tạo ma trận chiếu hiện tại bằng lệnh glLoadIdentity() để áp dụng các chuyển đổi dự định Cuối cùng, lệnh glOrtho() được gọi để tạo ra một khối lượng song song cho việc xem chữ viết, với khối lượng này được xác định bởi các cạnh trái, phải, trên, gần và xa thông qua lệnh glOrtho().
Đến lúc thực hiện các phép biến đổi trên mô hình đã tạo ra, chúng tôi sử dụng lệnh glMatrixMode() với đối số GL_MODELVIEW Điều này cho thấy rằng các phép biến đổi hiện tại ảnh hưởng đến ma trận modelview thay vì ma trận chiếu.
Chúng tôi sẽ áp dụng chiếu quan điểm để tạo ra một thực tế phong phú hơn với nhiều đối tượng Mỗi đối tượng sẽ có những đặc trưng riêng biệt, giúp phân biệt rõ ràng giữa chúng Thêm vào đó, một đối tượng nhỏ hơn sẽ được ghi nhận từ máy chụp, tạo ra sự đa dạng trong bức tranh tổng thể.
CHƯƠNG TRÌNH DEMO
C ÁC KỸ THUẬT SỬ DỤNG CHO CHƯƠNG TRÌNH
Chương trình Demo sử dụng các kỹ thuật vẽ cơ bản :
Các phép dịch chuyển và quay
Kỹ thuật tạo hình ảnh bề mặt (texture) cho đối tượng vẽ giúp thay thế màu sắc đơn giản bằng những hình ảnh sinh động hơn Kỹ thuật này sẽ được áp dụng để phủ lên bề mặt của các khối hình học mà chúng ta cần thể hiện.
Để sử dụng texture, bạn cần một bức ảnh nguồn ở bất kỳ định dạng nào, nhưng định dạng BMP (bitmap) sẽ thuận tiện hơn Sử dụng các hàm cần thiết để chuyển đổi bức ảnh thành một mảng với các giá trị màu sắc theo thứ tự (R1, G1, B1, R2, G2, B2…), trong đó R, G, B tương ứng là giá trị màu đỏ, xanh lá cây và xanh dương của mỗi pixel.
Chúng tôi thực hiện quy trình đơn giản bằng cách tải lên các hình ảnh, sau đó sử dụng các texture của OpenGL và cuối cùng xóa các đối tượng hình ảnh khi không còn cần thiết.
Bắt đầu sử dụng, bằng cách gọi glEnable (GL_TEXTURE_2D) để cho phép áp dụng kết cấu và glBindTexture (GL_TEXTURE_2D,
_textureId) để nói với OpenGL mà chúng tôi muốn sử dụng kết cấu với id _textureId
Chương trình khởi tạo OpenGL thông qua thư viện GLUT, tạo cửa sổ và thiết lập các chế độ cần thiết như vẽ 3D, texture, chế độ màu và các bộ đệm.
Đầu tiên, tải file ảnh định dạng *.bmp và chuyển đổi nó thành một mảng kiểu int để lưu trữ giá trị màu của các pixel Sau đó, tiếp tục chuyển mảng giá trị này thành texture trong OpenGL.
Hàm vẽ sẽ gọi hàm glBindTexture (GL_TEXTURE_2D,
Để sử dụng texture trong OpenGL, chúng ta cần sử dụng GL_TEXTURE dạng 2D cùng với _textureId, là ID của texture mà chúng ta vừa tạo Texture này sẽ được hiển thị lên bề mặt của các đối tượng mà OpenGL vẽ ra.
M Ã NGUỒN
#define ESCAPE 27 // ma ascii cua phim escape int window; // so cua so GLUT float xrot, yrot, zrot; // gia tri goc quay cua cac truc X,Y,Z int texture[1]; // mang chua texture
/* Kieu du lieu Image - chieu rong, cao, du lieu */ struct Image { unsigned long sizeX; unsigned long sizeY; char *data;
The function `ImageLoad` is designed to load an image from a specified filename into an `Image` structure It begins by declaring necessary variables, including a file pointer, size of the image in bytes, a counter, and parameters for the number of planes and bits per pixel, which are required to be 1 and 24 respectively Additionally, a temporary variable is utilized for converting color formats from BGR to RGB.
// mo file if ((file = fopen(filename, "rb"))==NULL) { printf("File Not Found : %s\n",filename); return 0;
} // seek through the bmp header, up to the width/height: fseek(file, 18, SEEK_CUR);
// doc chieu rong if ((i = fread(&image->sizeX, 4, 1, file)) != 1)
{ printf("Error reading width from %s.\n", filename); return 0;
} printf("Width of %s: %lu\n", filename, image-
// doc chieu cao if ((i = fread(&image->sizeY, 4, 1, file)) != 1)
36 printf("Error reading height from %s.\n", filename); return 0;
} printf("Height of %s: %lu\n", filename, image-
// calculate the size (assuming 24 bits or 3 bytes per pixel) size = image->sizeX * image->sizeY * 3;
// read the planes if ((fread(&planes, 2, 1, file)) != 1) { printf("Error reading planes from %s.\n", filename); return 0;
} if (planes != 1) { printf("Planes from %s is not 1: %u\n", filename, planes); return 0;
// read the bpp if ((i = fread(&bpp, 2, 1, file)) != 1) { printf("Error reading bpp from %s.\n", filename); return 0;
} if (bpp != 24) { printf("Bpp from %s is not 24: %u\n", filename, bpp); return 0;
} // seek past the rest of the bitmap header fseek(file, 24, SEEK_CUR);
// read the data image->data = (char *) malloc(size); if (image->data == NULL) { printf("Error allocating memory for color- corrected image data"); return 0;
37 if ((i = fread(image->data, size, 1, file)) !=
1) { printf("Error reading image data from
} for (i=0;i rgb) temp = image->data[i]; image->data[i] = image->data[i+2]; image->data[i+2] = temp;
// Load Bitmaps And Convert To Textures void LoadGLTextures() {
// allocate space for texture image1 = (Image *) malloc(sizeof(Image)); if (image1 == NULL) { printf("Error allocating space for image"); exit(0);
} if (!ImageLoad("Data/ITF.bmp", image1)) { exit(1);
// tao Texture glGenTextures(1, &texture[0]); glBindTexture(GL_TEXTURE_2D, texture[0]);// 2d texture (x and y size) glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); // tuyen tinh neu kich co lon hon texture
38 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); // tuyen tinh neu kich co nho hon texture
// 2d texture, level of detail 0 (normal), 3 components (red, green, blue), x size from image, y size from image,
// border 0 (normal), rgb color data, unsigned byte data, and finally the data itself glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1-
/* Khoi tao OpenGL */ void InitGL(int Width, int Height) // goi sau khi khoi tao cua so
To set up texture mapping in OpenGL, first load the textures with `LoadGLTextures()` and enable 2D texturing using `glEnable(GL_TEXTURE_2D)` Clear the background to black with `glClearColor(0.0f, 0.0f, 0.0f, 0.0f)` and initialize the depth buffer with `glClearDepth(1.0)` Configure the depth test to use `glDepthFunc(GL_LESS)` and enable depth testing with `glEnable(GL_DEPTH_TEST)` For smooth color shading, use `glShadeModel(GL_SMOOTH)` Set the projection matrix with `glMatrixMode(GL_PROJECTION)` and reset it using `glLoadIdentity()`, followed by defining the perspective with `gluPerspective(45.0f, (GLfloat)Width/(GLfloat)Height, 0.1f, 100.0f)` Finally, switch to the model view matrix with `glMatrixMode(GL_MODELVIEW)`.
/* Ham tu dong tuy chinh khi cua so bi thay doi kich co */ void ReSizeGLScene(int Width, int Height)
{ if (Height==0) // Neu cua so qua nho
Height=1; glViewport(0, 0, Width, Height);// dai lai Viewport And Perspective Transformation glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0f,(GLfloat)Width/(GLfloat)Height, 0.1f,100.0f); glMatrixMode(GL_MODELVIEW);
{ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // lam sach mang anh va bo dem chieu sau glLoadIdentity(); // dat lai khung nhin glTranslatef(0.0f,0.0f,-5.0f); // di chuyen
Sử dụng hàm glRotatef(xrot, 1.0f, 0.0f, 0.0f) để quay đối tượng quanh trục X, glRotatef(yrot, 0.0f, 1.0f, 0.0f) để quay quanh trục Y và glRotatef(zrot, 0.0f, 0.0f, 1.0f) để quay quanh trục Z Tiếp theo, sử dụng glBindTexture(GL_TEXTURE_2D, texture[0]) để chọn texture cần sử dụng Cuối cùng, bắt đầu vẽ lập phương bằng cách gọi glBegin(GL_QUADS).
To define the vertices of a textured quad in OpenGL, the following coordinates are used: for the bottom left corner, glTexCoord2f(0.0f, 0.0f) and glVertex3f(-1.0f, -1.0f, 1.0f); for the bottom right corner, glTexCoord2f(1.0f, 0.0f) and glVertex3f(1.0f, -1.0f, 1.0f); for the top right corner, glTexCoord2f(1.0f, 1.0f) and glVertex3f(1.0f, 1.0f, 1.0f); and for the top left corner, glTexCoord2f(0.0f, 1.0f) and glVertex3f(-1.0f, 1.0f, 1.0f).
In OpenGL, texture mapping is achieved by defining texture coordinates for each vertex of a quad The process begins with `glTexCoord2f(1.0f, 0.0f)` and `glVertex3f(-1.0f, -1.0f, -1.0f)` to specify the bottom right corner of the texture and quad Next, `glTexCoord2f(1.0f, 1.0f)` and `glVertex3f(-1.0f, 1.0f, -1.0f)` are used for the top right corner For the top left corner, `glTexCoord2f(0.0f, 1.0f)` and `glVertex3f(1.0f, 1.0f, -1.0f)` are defined, followed by `glTexCoord2f(0.0f, 0.0f)` and `glVertex3f(1.0f, -1.0f, -1.0f)` for the bottom left corner This sequence ensures proper texture mapping across the quad's surface.
In OpenGL, the rendering process involves specifying texture coordinates and vertex positions to create a textured quad The top left corner of the texture is defined with `glTexCoord2f(0.0f, 1.0f)` and the corresponding vertex at `glVertex3f(-1.0f, 1.0f, -1.0f)` The bottom left corner is set with `glTexCoord2f(0.0f, 0.0f)` and its vertex at `glVertex3f(-1.0f, 1.0f, 1.0f)` For the bottom right corner, `glTexCoord2f(1.0f, 0.0f)` is used with the vertex `glVertex3f(1.0f, 1.0f, 1.0f)`, while the top right corner is defined by `glTexCoord2f(1.0f, 1.0f)` and the vertex `glVertex3f(1.0f, 1.0f, -1.0f)` This sequence effectively maps the texture onto the quad's surface.
// mat day glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Top Right Of The Texture and Quad glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f); // Top Left Of The Texture and Quad glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
41 glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, - 1.0f, 1.0f); // Bottom Right Of The Texture and Quad
In OpenGL, texture mapping involves specifying texture coordinates and vertex positions for a quad The process begins with glTexCoord2f(1.0f, 0.0f) and glVertex3f(1.0f, -1.0f, -1.0f) to define the bottom right corner of the texture and quad Next, glTexCoord2f(1.0f, 1.0f) and glVertex3f(1.0f, 1.0f, -1.0f) set the top right corner, followed by glTexCoord2f(0.0f, 1.0f) and glVertex3f(1.0f, 1.0f, 1.0f) for the top left corner Finally, glTexCoord2f(0.0f, 0.0f) and glVertex3f(1.0f, -1.0f, 1.0f) establish the bottom left corner, completing the quad's definition.
In this OpenGL code snippet, texture coordinates and vertex positions are defined to create a textured quad The bottom left vertex is set at (-1.0f, -1.0f, -1.0f), followed by the bottom right at (-1.0f, -1.0f, 1.0f), the top right at (-1.0f, 1.0f, 1.0f), and finally the top left at (-1.0f, 1.0f, -1.0f) After defining the quad's vertices, the drawing process concludes with `glEnd()` The rotation angles for the X, Y, and Z axes are incremented by 1.0f each frame, allowing for dynamic rotation Finally, `glutSwapBuffers()` is called to update the display with the rendered frame.
/* ham su kien nhan phim */ void keyPressed(unsigned char key, int x, int y)
/* thoat chuong trinh neu nhan phim ESCAPE */ if (key == ESCAPE) {
/* tat cua so GLUT */ glutDestroyWindow(window);
} int main(int argc, char **argv)
{ glutInit(&argc, argv); // khoi tao OpenGL voi thu vien GLUT
/* chon kieu mang hinh voi: bo dem doi RGBA color ho tro anh sang bo dem chieu xau */ glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);
/* khoi tao cua so voi kich thuoc truyen vao*/ glutInitWindowSize(640, 480);
/* set diem treo cua cua so */ glutInitWindowPosition(0, 0);
/*�� cua so */ window = glutCreateWindow("ITF - cube ");
/* thuc hien ve */ glutDisplayFunc(&DrawGLScene);
/* tuy chon full man hinh */
/* tu dong tuy chinh neu thay doi kich co cua so
/* Su kien nhan phim */ glutKeyboardFunc(&keyPressed);
/* khoi tao cac gia tri cho cua so */
/* vong lap chinh */ glutMainLoop(); return 1;
ITF: gcc -o ITF ITF.c -lglut -lGLU -lGL clean: rm -f ITF.o
Hình ảnh đƣợc dùng : file ITF.bmp
Kết quả chạy trên ubuntu 10.10
KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN
1 Những kết quả đạt đƣợc
OpenGl là thƣ viện mở, luôn đƣợc cộng động theo dõi, phát triển và cập nhật ngay khi có những cái mới hoặc những vấn đề nảy sinh
Nắm vững kỹ thuật đồ họa cơ bản trong đồ họa máy tính giúp bạn phát triển các ứng dụng yêu cầu giao diện và đồ họa cao cấp.
2 Những vấn đề tồn tại
Chƣa làm đƣợc các đồ họa hoạt hình và đồ họa 3D cấp cao, nhƣ :
Tốc độ và hiển thị
Kết hợp nhiều thƣ viện khác của openGL
Lập trình trên các ngôn ngữ khác nhau: VB.VC++,C,java…
