TRƯỜNG ĐẠI HỌC BÁCH KHOA
KHOA CÔNG NGHỆ THÔNG TIN
BỘ MÔN MẠNG VÀ TRUYỀN THÔNG
BÀI TẬP LỚN CHUYÊN ĐỀ II
ĐỀ TÀI:
LẬP TRÌNH ĐỒ HỌA
ỨNG DỤNG THƯ VIỆN OPENGL TRÊN LINUX
Sinh viên
: Lê Phương Tiến
Hà Phước Việt
Cán bộ hướng dẫn : Nguyễn Tấn Khôi
Đà Nẵng 2010
07T2
07T1
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
2
MỤC LỤC
TỔNG QUAN VỀ ĐỀ TÀI
CHƯƠNG 1. GIỚI THIỆU THƯ VIỆN OPENGL VÀ CÁCH CÀI ĐẶT5
1.1. GIỚI THIỆU.................................................................................5
1.2. CÁCH CÀI ĐẶT...........................................................................6
1.2.1. Môi trường cài đặt................................................................6
1.2.2. Cài đặt..................................................................................6
1.2.3. Sử dụng thư viện openGL....................................................7
CHƯƠNG 2. CƠ BẢN VỀ OPENGL.......................................................8
2.1. CẤU TRÚC CHƯƠNG TRÌNH OPENGL ĐƠN GIẢN........................8
2.1.1. Khởi tạo................................................................................8
2.1.2. Tạo của sổ............................................................................9
2.1.3. Chức năng hiển thị...............................................................9
2.1.4. Chức năng định lại hình.....................................................10
2.1.5. Vòng lặp chính...................................................................10
2.1.6. Mã nguồn 1 chương trình đơn giản...................................10
2.2. DỮ LIỆU VÀ THUỘC TÍNH.........................................................12
2.2.1. Cú pháp lệnh của OpenGL.................................................12
2.2.2. Máy trạng thái....................................................................13
2.3. CÁC THƯ VIỆN LIÊN QUAN.......................................................14
2.4. HOẠT CẢNH (ANIMATION )......................................................15
CHƯƠNG 3. CÁC KỸ THUẬT OPENGL CƠ BẢN.............................16
3.1. CÁC ĐỐI TƯỢNG HÌNH HỌC ( GEOMETRIC OBJECTS )..............16
3.1.1. Points, Lines and Polygons................................................17
3.1.2. Vẽ các đối tượng không gian ( Drawing 3-D Objects ).....19
3.1.3. Các phép biến đổi ( Transformations )...............................20
3.1.4. Danh sách hiển thị ( Display Lists )...................................21
3.2. KHUNG HIỂN THỊ ( VIEWING )....................................................23
3.2.1. Màu sắc ( Color )................................................................23
3.2.2. Độ bóng ( Shading )...........................................................24
3.2.3. Khung hình biến đổi ( Viewing Transformation ).............24
3.2.4. Phép chiếu ( Projection )....................................................25
3.2.5. Thao tác ngăn xếp ma trận ( Manipulating the Matrix
Stacks )
26
3.2.6. Ánh sáng ( Light )..............................................................27
3.2.7. Khung quan sát biến đổi ( Viewport Transformation )......28
CHƯƠNG 4. CHƯƠNG TRÌNH DEMO................................................29
4.1. CÁC KỸ THUẬT SỬ DỤNG CHO CHƯƠNG TRÌNH.......................29
4.2. MÃ NGUỒN..............................................................................30
4.3. Kết quả chạy............................................................................36
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
3
TỔNG QUAN VỀ ĐỀ TÀI
1. Bối cảnh và lý do thực hiện đề tài
Ngày nay đồ họa máy tính đóng một vai trò quan trong, quyết định
không nhỏ đến sự thành công hay thất bại của một sản phẩm phần mềm. Sản
phẩm làm ra ngoài tính năng đáp ứng được nhu cầu sử dụng thì mẫu giao
diện đồ họa phải bắt mắt, than thiện với người sử dụng, có như thế thì sản
phẩm mới có thể thành công. Ngoài các sản phẩm phần mềm thì một xu
hướng mới nữa đó là các bộ phim hoạt hình 3D cũng đang rất được quan tâm.
Nhận thấy tìm năng vả khả năng phát khiển mạnh của công nghiệp đồ
họa, chúng em lựa chọn đề tài: Lập trình đồ họa ứng dụng thư viện
OpenGL trên Linux. Đây là một thư viên hỗ trợ các công cụ mạnh mẽ để vẽ
và xử lý các đối tượng đồ họa.
2. Mục tiêu đề tài
Tìm hiểu lý thuyết thư viện OpenGL
Xây dựng chương trình đồ họa demo với OpenGL
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
Chương 1.
1.1.
4
GIỚI THIỆU THƯ VIỆN OPENGL VÀ CÁCH CÀI
ĐẶT
Giới thiệu
OpenGL là một cấp thấp thư viện đồ họa đặc điểm kỹ thuật. Nó làm cho
có sẵn cho các lập trình một nhóm nhỏ các hình học cơ bản - điểm, đường, đa
giác, hình ảnh, và ảnh bitmap. OpenGL cung cấp một bộ các lệnh cho phép
các đặc điểm kỹ thuật của các đối tượng hình học trong hai hoặc ba chiều, sử
dụng cơ bản cung cấp, cùng với các lệnh để điều khiển các đối tượng này là
kết xuất (GLUT).
Từ bản vẽ lệnh OpenGL được giới hạn bởi các hình học đơn giản (điểm,
đường, và đa giác), các OpenGL Utility Toolkit đã được tạo ra để trợ giúp
trong việc phát triển phức tạp hơn các đối tượng ba chiều như một quả cầu,
một xuyến, và thậm chí một ấm trà. GLUT có thể không được thỏa đáng cho
đầy đủ tính năng ứng dụng OpenGL, nhưng nó là một điểm khởi đầu hữu ích
cho việc học OpenGL.
GLUT được thiết kế để lấp đầy sự cần thiết cho một hệ thống độc lập lập
trình giao diện cửa sổ cho các chương trình OpenGL. Giao diện được thiết kế
đơn giản nhưng vẫn đáp ứng các nhu cầu của các chương trình hữu ích
OpenGL. Loại bỏ các hoạt động hệ thống cửa sổ từ OpenGL là một quyết
định âm thanh bởi vì nó cho phép hệ thống đồ họa OpenGL được retargeted
cho các hệ thống khác nhau bao gồm nhưng đắt tiền máy trạm đồ họa mạnh
mẽ cũng như sản xuất hàng loạt hệ thống đồ họa như trò chơi video, hộp settop cho truyền hình tương tác, và máy tính cá nhân.
GLUT đơn giản hóa việc thực hiện các chương trình sử dụng OpenGL
rendering. Việc áp dụng dư thừa giao diện lập trình (API) đòi hỏi vài thói
quen rất để hiển thị một cảnh kết xuất bằng cách sử dụng đồ họa
OpenGL.Việc dư thừa thói quen cũng có thông số tương đối ít.
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
1.2.
Cách cài đặt
1.2.1.
Môi trường cài đặt
5
Quá trình tìm hiểu và viết chương trình được thực hiện trên môi trường
Linux phiên bản Ubuntu 10.10. OpenGL là một bộ thư viện mở có thể sử
dụng ở môi cả môi trường Windows nhưng Ubuntu là một hệ điều hành mở,
kho tài liệu phong phú, luôn có một cộng động sẵn sang giúp đỡ khi có vẫn
đề khó khăn.
Các gói thư viện của openGL : GLUT,AUX, XLIB…..
1.2.2.
Cài đặt
Cài đặt trình biên dịch C/C++ GNU: tại terminal gõ
Sudo apt-get install gcc
Sudo apt-get install g++
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
6
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
1.2.3.
Sử dụng thư viện openGL
Cách biên dịch 1 bài C đơn giản
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
7
Cách biên dịch C có sử dụng thư viện OpenGL
Tại terminal gõ: gcc [filenam].c –o [filenam] –lglut –lGLU –lGL
Dùng makefile : vào terminal đưa về thư mục chứa code và
makefile gõ make là xong
Chương 2.
CƠ BẢN VỀ OPENGL
2.1.
Cấu trúc chương trình openGL đơn giản
2.1.1.
Khởi tạo
Điều đầu tiên chúng ta cần làm là gọi glutInit () làm thủ tục khởi tạo. Nó
phải được gọi trước khi bất kỳ đối tượng GLUT nào bởi vì nó khởi tạo thư
viện GLUT . Các tham số để glutInit () được truyền từ main (), cụ thể (int
argv mà, char ** argv) và glutInit & argv mà, (argv) , nơi argcp là một con
trỏ đến chương trình của cố định biến argv mà từ chính. Khi trả về, giá trị
được trỏ đến bởi argcp sẽ được cập nhật, và argv là argv biến của chương
trình chưa sửa đổi từ chính. Giống như argcp, các dữ liệu cho argv sẽ được
cập nhật.
Điều tiếp theo chúng tôi cần làm là gọi glutInitDisplayMode () làm thủ tục
để xác định chế độ hiển thị cho cửa sổ.Bạn phải quyết định xem bạn muốn sử
dụng một RGBA (GLUT_RGBA) hoặc màu chỉ số (GLUT_INDEX) mô hình
màu. Các chế độ RGBA cửa hàng các bộ đệm màu sắc của nó là thành phần
màu đỏ, xanh lá cây, xanh dương, và alpha. Các thành phần ra màu sắc,
alpha, tương ứng với khái niệm mờ(độ sang). Một giá trị alpha là 1.0 có nghĩa
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
8
opacity hoàn tất, và giá trị alpha của một độ trong suốt hoàn toàn 0.0. Chế độ
chỉ số màu sắc, tương phản, màu sắc bộ đệm trong các cửa hàng indicies.
Quyết định của bạn về chế độ màu nên được dựa trên phần cứng sẵn có và
những gì bạn ứng dụng đòi hỏi màu sắc khác thường có thể được đại diện
đồng thời với chế độ RGBA hơn với chế độ chỉ số màu. Và cho các hiệu ứng
đặc biệt, như bóng, ánh sáng, và sương mù, RGBA chế độ cung cấp linh hoạt
hơn. Nhìn chung, sử dụng chế độ RGBA bất cứ khi nào có thể. RGBA chế độ
mặc định.
Khi thiết lập chế độ hiển thị là liệu bạn muốn sử dụng đệm đơn
(GLUT_SINGLE) hoặc đệm đôi (GLUT_DOUBLE. Các ứng dụng sử dụng
cả hai mặt trước và các bộ đệm màu sắc trở lại là đôi đệm.Sự mền mại hoạt
hình được thực hiện bằng cách vẽ vào bộ đệm chỉ trở lại (không hiển thị), sau
đó gây ra mặt trước và sau bộ đệm được đổi chỗ. Nếu bạn không sử dụng
annimation, gắn bó với đệm duy nhất, đó là mặc định.
Cuối cùng, bạn phải quyết định xem bạn muốn sử dụng một bộ đệm chiều
sâu (GLUT_DEPTH), đệm stencil (GLUT_STENCIL) và / hoặc đệm một sự
tích lũy (GLUT_ACCUM). Các đệm cửa hàng chuyên sâu một giá trị chuyên
sâu cho mỗi điểm ảnh. Bằng cách sử dụng một "bài kiểm tra chiều sâu", bộ
đệm độ sâu có thể được sử dụng để hiển thị các đối tượng có giá trị độ sâu
nhỏ hơn ở phía trước của các đối tượng có giá trị độ sâu lớn hơn. Các bộ đệm
thứ hai, bộ đệm stencil được sử dụng để hạn chế vẽ để phần nào đó của màn
hình, chỉ như là một stencil tông có thể được sử dụng với một hộp sơn xịt để
làm cho một hình ảnh in. Cuối cùng, bộ đệm tích lũy được sử dụng để tích
lũy một loạt các hình ảnh vào một hình ảnh sáng tác cuối cùng. Không ai
trong số này là các bộ đệm mặc định.
Cần phải tạo ra các đặc tính của cửa sổ. Một tham số đến
glutInitWindowSize () sẽ được sử dụng để xác định kích thước, trong ảnh,
trong cửa sổ inital của bạn. Chiều cao và chiều rộng (bằng pixel) của cửa sổ
yêu cầu. Tương tự như vậy, glutInitWindowPosition () được sử dụng để xác
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
9
định vị trí màn hình cho góc trên bên trái của cửa sổ ban đầu. Những giá trị,
x và y, cho biết vị trí của các cửa sổ liên quan đến 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 có một chuỗi như một tham số mà có thể xuất hiện trong thanh tiêu
đề nếu hệ thống cửa sổ bạn đang sử dụng hỗ trợ nó cửa sổ là không thực sự
hiển thị cho đến khi glutMainLoop () được nhập vào.
2.1.3.
Chức năng hiển thị
Hàm glutDisplayFunc () làm thủ tục là sự kiện quan trọng đầu tiên của
hầu hết các chức năng gọi lại và hiển thị . Một chức năng gọi lại là một trong
những nơi hàm đã được định nghĩa ,ứng với mỗi hàm sẽ có một sự kiện phù
hợp . Ví dụ, các đối số của glutDisplayFunc () là chức năng được GLUT xác
định rằng nội dung của cửa sổ cần phải được hiển thị lại. Vì vậy, bạn nên đặt
tất cả các hàm mà bạn cần hiển thị ra một cảnh trong chức năng gọi lại hiển
thị.
2.1.4.
Chức năng định lại hình
Hàm glutReshapeFunc () là một chức năng gọi lại rằng quy định cụ thể
chức năng đó được gọi là bất cứ khi nào cửa sổ được thu nhỏ hoặc di chuyển.
Thông thường, các chức năng đó được gọi khi cần thiết cho thay đổi hình
dáng chức năng hiển thị cửa sổ với kích thước mới và định nghĩa lại các đặc
tính xem như mong muốn. Nếu glutReshapeFunc () là không được gọi, một
mặc định chức năng thay đổi hình dáng mà được gọi là bộ giao diện để giảm
thiểu sự biến dạng và đặt ra các màn hình hiển thị lên tầm cao mới và chiều
rộng.
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
2.1.5.
10
Vòng lặp chính
Cuối là gọi glutMainLoop (). Tất cả các cửa sổ đã được tạo ra có thể
được hiển thị, và vẽ những cửa sổ hiện có hiệu quả. Chương trình sẽ có thể
xử lý các sự kiện như chúng xảy ra (click chuột, thay đổi kích thước cửa sổ,
vv.). Ngoài ra, các cuộc gọi lại hiển thị (từ glutDisplayFunc () ) được kích
hoạt. Sau khi vòng lặp này được nhập vào, nó không bao giờ đã thoát!
Điều quan trọng cần lưu ý rằng các lệnh OpenGL không nhất thiết phải
thực hiện ngay khi chúng được phát hành. Nó là cần thiết để gọi lệnh glFlush
() để đảm bảo rằng tất cả các lệnh đã ban hành trước đây được thực hiện.
glFlush () được gọi chung là ở phần cuối của một chuỗi các bản vẽ lệnh để
đảm bảo tất cả các đối tượng trong cảnh được vẽ trước khi bắt đầu chấp nhận
của 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
#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);
}
void drawScene() {
}
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
11
int main(int argc, char** argv) {
//Khoi tao GLUT
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB
| GLUT_DEPTH);
glutInitWindowSize(400, 400); /
// 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 ();
}
void init (void)
{
}
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);
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
12
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;
}
2.2.
Dữ liệu và thuộc tính
2.2.1.
Cú pháp lệnh của OpenGL
Có thể quan sát được từ chương trình đơn giản trong phần trước, lệnh
OpenGL sử dụng các chữ cái và vốn ban đầu gl tiền tố cho mỗi từ tạo thành
tên lệnh (gọi lại glClearColor (). Tương tự như vậy, OpenGL xác định hằng
số bắt đầu bằng GL_, sử dụng tất cả các chữ in hoa, và sử dụng gạch dưới
những từ riêng biệt (như GL_COLOR_BUFFER_BIT).
Bạn cũng có thể đã nhận thấy một số không liên quan thư dường như nối
thêm vào một số tên lệnh (các 3f trong glColor3f ()). Sự thật là phần màu
của tên lệnh là đủ để xác định các lệnh là một trong những bộ màu sắc hiện
hành. Tuy nhiên, nhiều hơn một lệnh như vậy đã được xác định để bạn có thể
sử dụng các loại khác nhau của các đối số;. Trong đó, 3 phần của hậu tố chỉ ra
rằng ba đối số được đưa ra một phiên bản của lệnh màu có bốn tham số của.
F Phần hậu tố cho thấy rằng các đối số là số điểm float. Một số các lệnh
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 chữ được sử dụng như là hậu tố để xác định các kiểu dữ liệu cho ANSI C
triển khai thực hiện của OpenGL được thể hiện trong Bảng 1-1, cùng với các
định nghĩa OpenGL loại tương ứng. Việc thực hiện cụ thể của OpenGL mà
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
13
bạn đang sử dụng có thể không tuân theo sơ đồ chính xác, một thực hiện
trong C + + hay Ada, ví dụ, không cần.
Như vậy, hai lệnh
glVertex2i(1, 3);
glVertex2f(1.0, 3.0);
là tương đương, trừ trường hợp đầu tiên xác định tọa độ của đỉnh là số
nguyên 32-bit và lần thứ hai quy định chúng như là một điểm chính xác con
số thực.
2.2.2.
Máy trạng thái
OpenGL là một máy trạng thái. Bạn đặt nó vào trạng thái khác nhau (hay
chế độ) mà sau đó vẫn có hiệu lực cho đến khi thay đổi chúng. Như đã thấy,
màu sắc hiện nay là một biến trạng thái. Có thể đặt màu hiện tại để trắng, đỏ,
hoặc bất kỳ màu nào khác, và sau đó mỗi đối tượng được vẽ với màu sắc cho
đến khi bạn thiết lập màu hiện tại để cái gì khác. Màu sắc hiện tại chỉ là một
trong nhiều biến trạng thái OpenGL lưu trữ . Những điều khiển kiểm soát
những thứ như xem hiện tại và biến đổi chiếu, đường và các mẫu cách ve
từng đốm đa giác, đa giác chế độ vẽ, pixel-đóng gói các công ước, vị trí và
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
14
đặc điểm sáng,các đối tượng vẽ. Nhiều biến trạng thái tham khảo các chế độ
được kích hoạt hay vô hiệu hóa với lệnh glEnable () hoặc glDisable ().
Mỗi biến trạng thái hoặc có một giá trị mặc định, và tại bất kỳ điểm nào
bạn có thể truy vấn các hệ thống giá trị hiện tại của mỗi biến. Thông thường,
bạn sử dụng một trong bốn lệnh sau đây để làm điều này: glGetBooleanv ()
glGetDoublev, (), glGetFloatv (), hoặc glGetIntegerv (). Những lệnh này
bạn chọn phụ thuộc vào kiểu dữ liệu bạn muốn trả lời được cho in Một số
biến trạng thái có lệnh truy vấn cụ thể hơn (như glGetLight * (), glGetError
(), hoặc glGetPolygonStipple ()). Ngoài ra, bạn có thể lưu và sau đó khôi
phục lại các giá trị của một tập hợp các biến trạng thái trên một thuộc tính
stack với glPushAttrib () và glPopAttrib () lệnh. Bất cứ khi nào có thể, bạn
nên sử dụng các lệnh này hơn là bất kỳ trong những lệnh truy vấn, vì chúng
tôi có thể sẽ hiệu quả hơn.
Danh sách đầy đủ của các biến trạng thái bạn có thể truy vấn được tìm
thấy trong Phụ lục B. Đối với mỗi biến, phụ lục này cũng liệt kê các * glGet
() 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.
2.3.
Các thư viện liên quan
OpenGL cung cấp một bộ thư viện mạnh mẽ của các lệnh vẽ, và các thư
viện hỗ trợ cao hơn cho người lập trình . Do đó, có thể muốn viết thư viện
riêng trên đầu trang của OpenGL để đơn giản hóa công việc lập trình. Ngoài
ra, có thể muốn viết một số một thủ tục chương trình OpenGL để làm việc dễ
dàng với hệ thống cửa sổ của bạn. Trong thực tế, chẳng hạn một số thư viện
và thói quen đã được bằng văn bản để cung cấp các tính năng chuyên ngành.
The OpenGL Utility Library (GLU), có chứa một số thủ tục sử
dụng các lệnh OpenGL cấp thấp hơn để thực hiện các công việc
như thiết lập các ma trận để xem định hướng cụ thể và các dự đoán,
thực hiện sự lót đá đa giác, và các bề mặt vẽ. Thư viện này được
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
15
cung cấp như một phần của OpenGL thực hiện của bạn. Đó là mô tả
chi tiết tại Phụ lục C và trong OpenGL Reference Manual. Glu sử
dụng tiền tố Glu.
The OpenGL Extension to the X Window System (GLX), cung
cấp một phương tiện của việc tạo ra một bối cảnh OpenGL và liên
kết nó với một cửa sổ drawable trên một máy có sử dụng X
Window 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 viết riêng cho cuốn sách này để làm ví dụ lập
trình đơn giản và chưa hoàn chỉnh hơn. Đó là chủ đề của phần tiếp
theo, và đó là mô tả chi tiết tại Phụ lục E, sử dụng thư viện aux tiền
tố. "Làm thế nào để Lấy mẫu mã" mô tả làm thế nào để có được
những 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 cung cấp các đối tượng và phương pháp để tạo chiều
tương tác đồ họa ba ứng dụng. Có sẵn từ Silicon Graphics và viết
bằng C + +, Open Inventor cung cấp xây dựng các đối tượng trước
và tích hợp sẵn trong trường hợp mô hình cho tương tác người
dùng, cao cấp thành phần ứng dụng cho việc tạo và ba chiều cảnh
chỉnh sửa, và khả năng in ấn các đối tượng và trao đổi dữ liệu trong
đồ họa khác định dạng.
2.4.
Hoạt cảnh (Animation )
Một trong những điều thú vị nhất mà bạn có thể làm trên một máy tính đồ
họa được vẽ hình ảnh chuyển động. Cho dù bạn là một kỹ sư đang cố gắng để
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
16
xem tất cả các mặt của một phần cơ khí bạn đang thiết kế, một phi công học
tập để bay một máy bay sử dụng một mô phỏng, hay chỉ đơn thuần là trò chơi
máy tính một người đam mê, thì rõ ràng rằng hoạt hình là một phần quan
trọng trong đồ họa máy tính .
Để tạo ra một sử chuyển động của hình ảnh thì chỉ việc thay đổi các frame
và kỹ thuật này được dùng để làm hoạt hình, các đồ họa khác. Nhưng với sự
vẽ xóa liên tục các frame sẽ làm cho hệ thống không đáp ứng được và hình
ảnh hiển thị không được mượt mà. OpenGL cung cấp bộ thư viện với các
phương thước nhắm đưa các frame vào các bộ đệm và kỹ thuật dùng bộ đệm
làm cho hình ảnh đưa ra được như ý muốn.
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.
Chương 3.
GVHD: Nguyễn Tấn Khôi
CÁC KỸ THUẬT OPENGL CƠ BẢN
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
3.1.
17
Các đối tượng hình học ( Geometric Objects )
Tất cả các hình khối được vẽ trong opengl đều được nằm giữa hai dòng
lệnh glBegin() và glEnd() (Hơi giống với pascal).Có thể có nhiều cặp dòng
lệnh như vậy, tức là có thể viết các hàm vẽ khác nhau và dùng cặp câu lệnh
trên trong các hàm đó.Tham số của glBegin() là GL_LINE_LOOP có nghĩa là
nó bảo window vẽ một đường khép kín điểm đầu trùng với điểm cuối.
Dưới đây là một số hằng số cơ bản:
Hằng số
ý nghĩa
GL_POINT
Vẽ điểm
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.
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
3.1.1.
18
Points, Lines and Polygons
Mỗi đối tượng hình học được mô tả bằng một tập các đỉnh và các loại
nguyên thủy được rút ra. Đỉnh A là không nhiều hơn một điểm được xác định
trong không gian ba chiều. Hay không và làm thế nào các đỉnh được kết nối
được xác định bởi các loại nguyên thủy. Mỗi đối tượng hình học là cuối cùng
được mô tả như là một yêu cầu thiết lập các đỉnh. Sử dụng * glVertex () lệnh
để xác định một đỉnh. . Các '*' được dùng để chỉ ra rằng có những khác biệt
để các lệnh cơ bản glVertex () .
Một số tên lệnh OpenGL có một, hai, hoặc ba chữ cái ở cuối để biểu thị số
lượng và kiểu của các tham số cho lệnh. Các ký tự đầu tiên chỉ số giá trị của
các loại chỉ ra rằng phải được trình bày cho lệnh. Nhân vật thứ hai cho các
loại hình cụ thể của các đối số. Cuối cùng, nếu có, là 'v', cho biết lệnh này có
một con trỏ tới một mảng (vector) của giá trị hơn là một loạt các đối số cá
nhân.
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
19
Ví dụ, trong lệnh glVertex3fv () , '3 'được dùng để chỉ ba đối số,' f 'được
dùng để chỉ các đối số là điểm trôi, và' v 'chỉ ra rằng các đối số là ở định dạng
vector.
Điểm: điểm A là xác định bởi một đỉnh duy nhất. Đỉnh quy định bởi người
sử dụng như là hai chiều (chỉ có x và y-tọa độ). Để điều chỉnh kích thước của
một điểm kết xuất, sử dụng glPointSize () và cung cấp các kích thước mong.
Mặc định là như 1 điểm ảnh theo điểm pixel 1. Nếu chiều rộng quy định là
2,0, điểm sẽ được một hình vuông của 2 bằng 2 điểm ảnh. glVertex * () được
sử dụng để mô tả một điểm, nhưng nó chỉ có hiệu quả giữa một glBegin () và
một glEnd () cặp. Các đối số được truyền cho glBegin () xác định những loại
hình học nguyên thủy được xây dựng 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() ;
Lines: Trong OpenGL, dòng ám chỉ đến một đoạn đường, không phải là
phiên bản của toán học kéo dài đến vô cực ở cả hai hướng. Cách dễ nhất để
xác định một đường là có điểm đầu và điểm cuối. Như với những điểm nêu
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.
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
Lập trình đồ họa ứng dụng thư viện OpenGL trên Linux
20
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.
Với OpenGL, mô tả hình dạng của một đối tượng đang được rút ra là độc
lập với mô tả về màu sắc của nó. Khi một đối tượng paraticular hình học
được rút ra, đó là rút ra bằng cách sử dụng các chương trình hiện quy định
màu. Nói chung, lập trình OpenGL đầu tiên thiết lập màu sắc, bằng cách sử
dụng * glColor () và sau đó rút ra các đối tượng. Cho đến khi màu sắc được
thay đổi, tất cả các đối tượng được rút ra trong màu sắc hoặc sử dụng có màu
sắc.
Ví dụ:
glBegin;
glColor3f(1.0, 1.0, 0.0); // yellow
glVertex2(-1.0, 1,0);
glVertex2f(2.0, 2.0);
glColor3f(1.0, 0.0, 0.0); // red
glVertex2f(0.0, 0.0);
glVertex2f(1.0, -1.0);
glVertex2f(-2.0, -2.0);
glEnd();
Đa giá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, nơi các đoạn đường được quy định bởi các đỉnh tại
điểm cuối của họ. Đa giác thường được vẽ với các điểm ảnh trong điền vào,
nhưng bạn cũng có thể vẽ chúng như là phác thảo hoặc thiết lập một điểm.
Trong OpenGL, có một vài hạn chế về những gì tạo thành một đa giác
nguyên thủy. Ví dụ, các cạnh của một đa giác không thể cắt nhau và chúng
phải được lồi (không có vết lõm). Có các lệnh đặc biệt cho một (tam giác) ba
mặt và bốn mặt (tứ giác) đa giác, glBegin (GL_TRIANGLES) và glBegin
(GL_QUADS) .. Tuy nhiên, trường hợp tổng quát của một đa giác có thể
được định nghĩa bằng cách sử dụng glBegin (GL_POLYGON) .
Ví dụ :
glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 0.0); // yellow
glVertex2f(0.0, 0.0)
GVHD: Nguyễn Tấn Khôi
SVTH: Lê Phương Tiến – Hà Phước Việt
- Xem thêm -