Tải bản đầy đủ
3 Thư viện đồ họa OpenGL

3 Thư viện đồ họa OpenGL

Tải bản đầy đủ

1.3.1 Cơ chế hoạt động của OpenGL

Hình 1.4: Cơ chế hoạt động của OpenGL
OpenGL có cơ chế hoạt động theo kiểu ống dẫn, tức là đầu ra của giai
đoạn trước là đầu vào của giai đoạn sau. Từ sơ đồ thì các thành phần của cơ chế
được giải thích như sau:


Display List: Là nơi lưu lại một số lệnh để xử lý sau.


Evaluator (bộ ước lượng): Xấp xỉ các đường cong và mặt phẳng hình học
bằng cách đánh giá các đa thức của dữ liệu đưa vào.



Per- vertex Operations and Primitive assembly: Xử lý các primitive hình học
(điểm, đoạn thẳng, đa giác) được biểu diễn bởi các vertex. Các vertex sẽ được xử
lý và các primitive được cắt xén vào viewport để chuẩn bị cho khâu kế tiếp.



Rasterization: Tạo ra một chuỗi các địa chỉ bộ đệm khung và các giá trị liên
quan bằng cách sử dụng mô tả 2 chiều của điểm, đoạn thẳng hay đa giác. Mỗi
phần tử (fragment) được sinh ra sẽ đưa vào giai đoạn kế tiếp.



Per- fragment operations: Là các thao tác cuối cùng trên dữ liệu, trước khi lưu
trữ dữ liệu dưới dạng các pixel trong bộ đệm khung. Các thao tác này bao
gồm việc cập nhật (có điều kiện) cho bộ đệm khung dựa vào dữ liệu vào và dữ
liệu được lưu trữ trước đó, thực hiện trộn màu cho các pixel và làm một số
thao tác khác.
Trong trường hợp dữ liệu vào ở dạng pixel không phải vertex, nó sẽ đưa

thẳng vào giai đoạn xử lý pixel. Sau giai đoạn này, dữ liệu ở dạng pixel sẽ được
lưu trữ như là bộ nhớ texture để đưa vào giai đoạn Per-fragment operation hoặc
đưa vào Rasterization như dữ liệu dạng Vertex.
12

1.3.2 Đặc điểm của OpenGL
OpenGL là một thư viện đồ họa rất lớn gồm khoảng 150 hàm hỗ trợ một
số tính năng cơ bản sau:
1.3.2.1 Thể hiện các đối tượng đồ họa cơ bản
OpenGL không có sẵn các hàm để xây dựng các đối tượng hình học phức
tạp, người dùng phải tự xây dựng chúng từ các đối tượng hình học cơ bản mà
OpenGL hỗ trợ: điểm, đoạn thẳng, đa giác.
Mọi đối tượng hình học đều được mô tả cơ bản từ các vertex. Vertex cũng
có thể hiểu là một điểm. Khai báo một điểm, dùng hàm:
glVertex{234}{sifd}[v] (Tọa độ điểm);
Trong đó:
{234} – Chỉ định số chiều của không gian.
{sifd} – Chỉ định kiểu dữ liệu của tọa độ, ý nghĩa được chỉ định trong bảng
1.1 như sau:
Bảng 1.1: Một số kiểu dữ liệu của OpenGL
Kí hiệu
s
i
f
d

Kiểu dữ liệu
16 – bit integer
32 – bit integer
32 – bit floating – point
64 – bit floating – point

Tên kiểu của OpenGL
GLshort
GLint, GLsizei
GLfloat, GLclampf
GLdouble, GLclampd

[v] – Nếu tọa độ điểm được truyền từ 1 mảng cho trước.
Việc xây dựng các đối tượng hình học khác đều có thể được thực hiện như sau:
glBegin(mode);
/* xác định tọa độ và màu sắc các điểm của hình */
glEnd();

13

Danh sách các mode (tham số) có thể là một trong những giá trị sau:
Bảng 1.2: Các tham số của glBegin()
Giá trị
GL_POINTS
GL_LINE
GL_POLYGON
GL_TRIANGLES
GL_QUADS
GL_LINE_STRIP
GL_LINE_LOOP
GL_TRIANGLE_STRIP
GL_TRIANGLE_FAN
GL_QUAD_STRIP

Ý nghĩa.
Các điểm.
Đoạn thẳng.
Đa giác lồi.
Tam giác.
Tứ giác.
Đường gấp khúc không khép kín.
Đường gấp khúc khép kín.
Một dải tam giác liên kết với nhau.
Các tam giác liên kết theo hình quạt.
Một dải các tứ giác liên kết với nhau.

Dưới đây là hình minh họa cho các loại mode:

Hình 1.5: Các đối tượng đồ họa cơ bản
Ngoài ra còn có một số đối tượng ba chiều cơ bản như: Hình cầu, hình trụ,
hình hộp ... từ đó ta xây dựng được các đối tượng ba chiều phức tạp hơn, thậm chí
có thể tự định nghĩa hay thiết kế các phần mềm hỗ trợ thiết kế ba chiều như
AutoCAD, SolidWorks, 3D Max.
Ví dụ: Các lệnh để thực hiện quá trình vẽ các điểm trong môi trường 2D
của OpenGL như sau:

14

glBegin(GL_POINTS);
glVertex2f(0.0f,0.0f);
glVertex2f(1.0f,0.0f);
glVertex2f(0.0f,1.0f);
glEnd();
Các lệnh để vẽ các điểm tạo thành hình ngũ giác trong môi trường 2D:
glBegin(GL_POLYGON);
glVertex2f(0.0f,0.0f);
glVertex2f(3.0f,0.0f);
glVertex2f(4.0f,3.0f);
glVertex2f(1.5f,6.0f);
glVertex2f(-1.0f,3.0f);
glEnd();

Hình 1.6: Quá trình vẽ các Vertex 2D t

1.3.2.2 Quan sát đối tượng
Các đối tượng có thể quan sát từ nhiều góc độ khác nhau thông qua các
phép biến đổi vị trí mắt nhìn hay phép biến đổi vị trí vật cũng như các phép chiếu...
1.3.2.3 Định màu sắc, vật liệu đối tượng

15

OpenGL có thể thể hiện màu sắc đối tượng một cách đa dạng và đặc biệt là
khả năng thể hiện thuộc tính vật liệu.
Để thiết lập màu sắc cho đối tượng, ta dùng hàm : glColor3f() ;
Ví dụ :
glColor3f(0.0, 0.0, 0.0); // black
glColor3f(1.0, 0.0, 0.0); // red
glColor3f(0.0, 1.0, 0.0); // green
glColor3f(1.0, 1.0, 0.0); // yellow
glColor3f(0.0, 0.0, 1.0); // blue
glColor3f(1.0, 0.0, 1.0); // magenta
glColor3f(0.0, 1.0, 1.0); // cyan
glColor3f(1.0, 1.0, 1.0); // white
Ví dụ: quá trình Render màu sắc của đối tượng:

Hình 1.7: Quá trình Render màu sắc của vật liệu

1.3.2.4 Tạo hiệu ứng ánh sáng OpenGL trong chương trình mô phỏng
Cho phép tạo ra hiệu ứng ánh sáng như trong thực tế tạo nên cảm giác thật
cho các mô hình và khung cảnh ba chiều.

16

void COpenGLView::SetupLighting ()
{
//Material Properties
GLfloat matSpecular[] = { 1.0f, 0.0f, 0.0f, 1.0f};
GLfloat matShininess[] = { 50.0f};
GLfloat matAmbient[] = { 0.25f, 0.25f, 0.25f, 1.0f};
GLfloat matDiffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f};
glMaterialfv(GL_FRONT, GL_SPECULAR, matSpecular);
glMaterialfv(GL_FRONT, GL_SHININESS, matShininess);
glMaterialfv(GL_FRONT, GL_DIFFUSE, matDiffuse);
glMaterialfv(GL_FRONT, GL_AMBIENT, matAmbient);
//Lighting Parameters
//Enable Lighting
glEnable(GL_LIGHTING);
//Specify a single directional light
GLfloat ambient1[] = { 0.5f,0.5f,0.5f};
GLfloat diffuse1[] = { 0.5f,0.5f,0.5f};
GLfloat specular1[] = { 1.0f,0.0f,0.0f};
GLfloat position1[] = { 0.0f,0.0f,5.0f,0.0};
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient1);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse1);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular1);
glLightfv(GL_LIGHT0, GL_POSITION, position1);
glEnable(GL_LIGHT0);
GLfloat ambient2[] = { 1.0f,1.0f,0.0f};
GLfloat diffuse2[] = { 1.0f,0.0f,0.0f};
GLfloat position2[] = { 1.0f,0.0f,5.0f,1.0};
GLfloat direction2[] = {0.0f,0.0f,-5.0f};
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient2);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse2);
glLightfv(GL_LIGHT1, GL_POSITION, position2);
glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, direction2);
glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 15.0f);
glEnable(GL_LIGHT1);
}

17

Hình 1.8: Quá trình tạo hiệu ứng ánh sánh cho đối tượng
1.3.2.5 Tạo khung cảnh mô phỏng thực tế OpenGL
Hỗ trợ các kỹ thuật tạo các khung cảnh giống với thực tế như: Kỹ thuật
dán ảnh, kỹ thuật sương mù, kỹ thuật pha trộn, kỹ thuật giảm hiệu ứng răng cưa.


Kỹ thuật dán ảnh (Texture Mapping)
Đôi khi chúng ta cần thể hiện một đối tượng phức hợp, một trong những

cách để làm được điều này là thêm chất liệu (dán ảnh) vào đối tượng và nó được
gọi là Texture Mapping.
Ví dụ, để tạo thành các Texture Mapping thì các lệnh như sau sẽ thực thi
trong OpenGL:
void COpenGLView::LoadTexture (CString fileName, int texName)
//Load Texture
AUX_RGBImageRec* m_texture;
m_texture = auxDIBImageLoad((const char*)fileName);
if(!m_texture)
{
MessageBox("Picture could not be loaded");
exit(1);
}
glBindTexture(GL_TEXTURE_2D, m_Texture[texName]);

18

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,
m_texWrap);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,
m_texWrap);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,
m_texFilter);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
m_texFilter);
glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,
m_texMode);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, m_texture->sizeX,m_texture
->sizeY, GL_RGB, GL_UNSIGNED_BYTE, m_texture->data);
}
void COpenGLView::RenderScene ()
{
glTranslatef(0.0f,0.0f,-5.0f);
glRotatef(m_xRot,1.0f,0.0f,0.0f);
glRotatef(m_yRot,0.0f,1.0f,0.0f);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,m_Texture[0]);
//Front Face
glBegin(GL_POLYGON);
glTexCoord2f(0,0);
glVertex3f(-1.0f,-1.0f,0.0f);
glTexCoord2f(1,0);
glVertex3f( 1.0f,-1.0f,0.0f);
glTexCoord2f(1,1);
glVertex3f( 1.0f, 1.0f,0.0f);
glTexCoord2f(0,1);
glVertex3f(-1.0f, 1.0f,0.0f);

19

glEnd();
// Back face
glBindTexture(GL_TEXTURE_2D,m_Texture[1]);
// Left and Right Faces
glBindTexture(GL_TEXTURE_2D,m_Texture[2]);
// Top and Bottom faces
glDisable(GL_TEXTURE_2D);
}

Hình1.9: Quá trình Texture Mapping trên OpenGL



Kỹ thuật pha trộn (Blending)
Là kỹ thuật kết hợp màu của các pixel nguồn và đích theo các cách khác

nhau để tạo thành những hiệu quả đặc biệt. Pha trộn thường được sử dụng để tạo
các đối tượng trong mờ. Khi một đối tượng được pha trộn chồng lên đối tượng
khác thì có thể nhìn xuyên qua đối tượng được bao phủ do màu của đối tượng
nguồn kết hợp với màu của pixel được bao phủ tạo ra màu mới.
Với ví dụ trên, ta có quá trình Blending:

20

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GLfloat matSpecular[] = { 1.0f, 0.0f, 0.0f, 0.5f};
GLfloat matAmbient[] = { 0.25f, 0.25f, 0.25f, 0.5f};
GLfloat matDiffuse[] = { 0.5f, 0.5f, 0.5f, 0.5f};

Hình 1.10: Quá trình Blending màu sắc của vật liệu trên OpenGL
• Hiệu ứng sương mù (Fog)
Cho phép tạo hiệu ứng hình ảnh mờ dần khi đối tượng chuyển động xa
khỏi mắt nhìn.
Và với ví dụ trên, ta có quá trình tạo hiệu ứng sương mù:
glFogi(GL_FOG_MODE, GL_EXP);
GLfloat fog_color[4] = {0.2f,0.2f,0.2f,0.0f};
glFogfv(GL_FOG_COLOR, fog_color);
glFogf(GL_FOG_DENSITY, 0.25);

21

Hình 1.11: Quá trình tạo hiệu ứng sương mù trên OpenGL
• Kỹ thuật giảm hiệu ứng răng cưa (Antialiasing)
Sử dụng các sắc thái màu khác nhau để che dấu cạnh răng cưa của
đường thẳng trên màn hình. Thực tế Antialiasing chỉ là một kiểu hiệu quả pha
trộn OpenGL.
1.3.2.6 Cải thiện tốc độ OpenGL
Khi ta có ý định vẽ lại hoặc thay đổi trạng thái nhiều lần một đối tượng, sử
dụng Display list để làm tăng khả năng thực thi chương trình. Trong OpenGL,
dislay list sẽ làm giảm sự hao phí thời gian truyền dữ liệu. Ví dụ: muốn vẽ một
cái ôtô có bốn bánh, thay vì việc phải viết đoạn mã vẽ bánh ôtô bốn lần ta sẽ tạo
một danh sách hiển thị làm nhiệm vụ vẽ bánh ôtô và gọi nó bốn lần.
1.3.2.7 Chọn các đối tượng đồ họa
Việc cho phép người dùng chọn đối tượng đồ hoạ bằng cách click chuột
trên cửa sổ là một yêu cầu thiết yếu đối với các ứng dụng tương tác. Để thực hiện
được những chức năng như vậy, trong OpenGL có sẵn một chế độ là Selection.
Và chế độ này được ứng dụng trong kỹ thuật mô phỏng va chạm của các vật thể.
1.3.3 Thư viện hỗ trợ lập trình OpenGL
Ngoài các thư viện chuẩn OpenGL như: GLU32.lib, OpenGL.lib, còn một
số thư viện hỗ trợ lập trình OpenGL. Như đã đề cập ở trên OpenGL là một thư
viện đồ hoạ đã được chuẩn hoá. Vì vậy các chương trình sử dụng các hàm
OpenGL cơ bản có khả năng tương thích với các chương trình biên dịch trên các
22