Hình 19 – Kết quả phép biến đổi

Xây dựng ứng dụng 3D với Android

75

______________________________________________________________________



Giá trị cờ mặc định là GL_LESS, khi thử đi qua khi các giá trị bằng nhau thì sẽ

xảy ra các đối tượng có cùng các giá trị z, màn hình sẽ hiển thị tùy thuộc vào thứ tự mà

đối tượng đó được in ra.

gl.glDepthFunc(GL10.GL_LEQUAL);

gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);



Khi thử chiều sâu để so sánh các giá trị, phải khởi tạo tất cả các giá trị trong bộ

đệm. Điều này có thể đạt được bằng cách sử dụng hàm glClearDepthf, hàm này sẽ đưa

ra một trong những tham số chỉ ra giá trị về chiều sâu trong bộ đệm dùng để khởi tạo

cùng.

gl.glClearDepthf(1.0f);



Ví dụ: hiển thị một số hình tam giác trên màn hình làm việc với depth buffer

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, triangle);

gl.glColorPointer(4, GL10.GL_FLOAT, 0, colors);

gl.glEnableClientState (GL10.GL_VERTEX_ARRAY);

gl.glEnableClientState (GL10.GL_COLOR_ARRAY);

public void display(GL10 gl)

{

gl.glClear(GL10.GL_COLOR_BUFFER_BIT |

GL10.GL_DEPTH_BUFFER_BIT);

gl.glLoadIdentity ();

gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);



Vẽ tam giác thứ 2 hơi ở trên tam giác đầu tiên



Xây dựng ứng dụng 3D với Android

76

______________________________________________________________________

gl.glPushMatrix();

gl.glTranslatef(-0.2f, 0.0f, -1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLES, 0,3);



Tam giác thứ 3 quay 45 độ theo trục z của tam giác thứ 2

gl.glRotatef(45.0f, 0.0f, 0.0f, 1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLES, 0,3);

gl.glPopMatrix();



Cuối cùng là tam giác đặt cùng với trục z với tam giác đầu tiên, đây là hình tam

giác nhỏ nằm ở phía bên phải.

gl.glPushMatrix();

gl.glTranslatef(0.5f, 0.0f, 0.0f);

gl.glScalef(0.5f, 0.5f, 0.5f);

gl.glDrawArrays(GL10.GL_TRIANGLES, 0,3);

gl.glPopMatrix();

gl.glFlush ();

gl.glFinish ();

}



Kết quả:



Xây dựng ứng dụng 3D với Android

77

______________________________________________________________________

Hình 20 – Kết quả chiều sâu



5.7 Màu sắc và tô bóng (Color and Shading):

Tất cả màu sắc trong OpenGL được đại diện bởi 4 giá trị, 3 giá trị màu đỏ, xanh

lá cây và xanh lam, cuối cùng là giá tri alpha, điều này chỉ thể hiện rõ ràng 1 màu. Để

hiển thị nhiều màu pha trộng nhau, ta sẽ sử dụng một mảng màu.

Ví dụ:

Khởi tạo một mảng tam giác:

float[] triangle = {

0.25f, 0.25f, 0.0f,

0.75f, 0.25f, 0.0f,

0.25f, 0.75f, 0.0f,

};



Tiếp theo, tạo ra một mảng màu, mỗi đỉnh là một màu sắc khác nhau, màu đỏ,

xanh lá cây và xanh lam:

float[] colors = {

1.0f, 0.0f, 0.0f, 1.0f, // point 0 red

0.0f, 1.0f, 0.0f, 1.0f, // point 1 green

0.0f, 0.0f, 1.0f, 1.0f, // point 2 blue

};



Một biến boolean shaded được tạo để theo dõi xem có được đánh bóng hay

không:

boolean shaded = false;



Thiết lập phép chiếu trực giao:



Xây dựng ứng dụng 3D với Android

78

______________________________________________________________________

private void init(GL10 gl) {

gl.glClearColor(0.0f, 0.0f, 0.0f,0.0f);

gl.glMatrixMode (GL10.GL_PROJECTION);

gl.glLoadIdentity ();

gl.glOrthof(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, triangle);



Sử dụng hàm glColorPointer để thiết lập cho mảng màu, hàm này làm việc

giống như hàm glVertexPointer, chúng có 4 tham số và tham số đầu tiên để xác định có

4 float (một giá trị màu) cho mỗi đỉnh:

gl.glColorPointer(4, GL10.GL_FLOAT, 0, colors);



Kích hoạt các đỉnh và mảng màu:

gl.glEnableClientState (GL10.GL_VERTEX_ARRAY);

gl.glEnableClientState (GL10.GL_COLOR_ARRAY);



Bây giờ ta thêm màu và shading (tô bóng) vào hình. Có 2 loại tô bóng, được xác

định bằng cách sử dụng hàm glShadeModel, hàm này sẽ đưa ra một trong hai tham số

GL_FLAT và GL_SMOOTH để xác định loại tô bóng và GL_SMOOTH được thiết lập

theo mặc định.

gl.glShadeModel(GL10.GL_FLAT);

}



Thiết lập chế độ màn hình hiển thị, trong lời gọi hàm glDrawArrays ta sử dụng

cờ GL_TRIANGLES để vẽ 3 đỉnh của tam giác.

Kết quả:



Xây dựng ứng dụng 3D với Android

79

______________________________________________________________________



Hình 21 – Kết quả màu sắc và tô bóng



5.8 Hình khối (Solid Shapes):

Áp dụng xử lí chiều sâu và phép chiếu phối cảnh để tạo ra một đối tượng hình khối

3D.

Thực hiện: tạo một mảng các đỉnh để tạo ra hình hộp, không tạo ra bằng cách sử

dụng các dãy tam giác liên tục mà tạo ra nó bằng cách tạo ra các bề mặt riêng biệt:

float[] box = {

// front

-0.5f, -0.5f, 0.5f,

0.5f, -0.5f, 0.5f,

-0.5f, 0.5f, 0.5f,

0.5f, 0.5f, 0.5f,

// back

-0.5f, -0.5f, -0.5f,

0.5f, 0.5f, -0.5f,

0.5f, -0.5f, -0.5f,

0.5f, 0.5f, -0.5f,

// left

-0.5f, -0.5f, 0.5f,



Xây dựng ứng dụng 3D với Android

80

______________________________________________________________________

-0.5f, 0.5f, 0.5f,

-0.5f, -0.5f, -0.5f,

-0.5f, 0.5f, -0.5f,

// right

0.5f, -0.5f, -0.5f,

0.5f, 0.5f, -0.5f,

0.5f, -0.5f, 0.5f,

0.5f, 0.5f, 0.5f,

// top

-0.5f, 0.5f, 0.5f,

0.5f, 0.5f, 0.5f,

-0.5f, 0.5f, -0.5f,

0.5f, 0.5f, -0.5f,

// bottom

-0.5f, -0.5f, 0.5f,

-0.5f, -0.5f, -0.5f,

0.5f, -0.5f, 0.5f,

0.5f, -0.5f, -0.5f,

};



Thiết lập màn hình và xoay như bình thường:

public void display(GL10 gl)

{

gl.glClear(GL10.GL_COLOR_BUFFER_BIT |

GL10.GL_DEPTH_BUFFER_BIT);

gl.glLoadIdentity ();

GLU.gluLookAt(gl, 0.0f, 0.0f, 3.0f,

0.0f, 0.0f, 0.0f,

0.0f, 1.0f, 0.0f);



Xây dựng ứng dụng 3D với Android

81

______________________________________________________________________

gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f);

gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);



Vẽ 2 mặt đối diện có màu giống nhau vì vậy nên vẽ 2 mặt cùng một lúc:

gl.glColor4f(1.0f, 0.0f, 0.0f, 1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 4, 4);

gl.glColor4f(0.0f, 1.0f, 0.0f, 1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 8, 4);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 12, 4);

gl.glColor4f(0.0f, 0.0f, 1.0f, 1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 16, 4);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 20, 4);

gl.glFlush ();

gl.glFinish ();

}



Kết quả:



Xây dựng ứng dụng 3D với Android

82

______________________________________________________________________

Hình 22 – Kết quả hình khối



5.9 Bộ lọc mặt sau (Backface Culling):

Khi tạo ra đối tượng 3D như hình hộp trong hướng dẫn trước, chúng ta không

cần mặt sau của các mặt hình hộp được hiển thị. Một kĩ thuật được gọi là Backface

Culling được sử dụng để ngăn chặn các mặt trong của hình được đưa ra. Điều này có

thể tiết kiệm được thời gian để vẽ và bộ nhớ.

Thực hiện: kích hoạt chế độ backface culling bằng cách thêm dòng lệnh

glEnable(GL_CULL_FACE) vào hàm init().



5.10 Ánh sáng (Lighting):

Việc thêm ánh sáng vào cảnh sẽ làm tăng tính chân thực và cách nhìn. Bước đầu

tiên cần thực hiện là kích hoạt backface culling như trong 5.10.

Có một số loại ánh sáng có thể được thêm vào hình:

Ambient Light: ánh sáng bao xung quanh, nó không đến từ bất kì một hướng

nào cụ thể, khi ánh sáng bao xung quanh một bề mặt ánh sáng sẽ được phản xạ theo

nhiều hướng.

Diffuse Light: Ánh sáng khuếch tán, nó đến từ một hướng, ánh sáng khuếch tán

tương tự như ánh sáng bao quanh, nó cũng được phản xạ theo nhiều hướng.

Specular Light: Ánh sáng phản chiếu, cũng giống như ánh sáng khuếch tán

nhưng nó được phản xạ theo một hướng, giống như ánh sáng nổi bật trên bề mặt trước.

Emissive Light: Ánh sáng tỏa, ánh sáng này đến từ một đối tượng cụ thể, các

đối tượng có thể giảm lượng ánh sáng nhưng nó không thể phản chiếu ra bất kì bề mặt

ngoài nào.

Không chỉ có thể chiếu sáng các vật thể mà còn có thể chỉ định các bề mặt phản

ứng như thế nào với ánh sáng bằng cách sử dụng vector pháp tuyến.



Xây dựng ứng dụng 3D với Android

83

______________________________________________________________________

Pháp tuyến là một vector vuông góc với một bề mặt, nó được sử dụng trong việc

tính toán ánh sáng, cần phải xác định một pháp tuyến cho mọi đa giác được vẽ bị ảnh

hưởng bởi nguồn sáng.

Ví dụ: tạo ra 2 mảng màu cho ánh sáng bao quanh và ánh sáng khuếch tán. Đây

sẽ là màu sắc của ánh sáng nguồn:

float[] lightAmbient = {0.2f, 0.3f, 0.6f, 1.0f};

float[] lightDiffuse = {0.2f, 0.3f, 0.6f, 1.0f};



Tiếp theo sẽ tạo ra 1 mảng chất liệu, một ánh sáng bao quanh và một ánh sáng

khuếch tán cho nguồn. Về bản chất điều này làm tăng giá trị của ánh sáng bởi các giá

trị của chất liệu nó làm cho màu sắc phản chiếu lên các bề mặt bị mất. Các mảng ở bề

mặt dưới mất đến 40% ánh sáng , mỗi giá trị tượng trưng cho màu mà nó phản xa.

float[] matAmbient = {0.6f, 0.6f, 0.6f, 1.0f};

float[] matDiffuse = {0.6f, 0.6f, 0.6f, 1.0f};

private void init(GL10 gl) {



Bật cờ GL_LIGHTING trong hàm glEnable, điều này cho phép sử dụng ánh

sáng trong OpenGL:

gl.glEnable (GL10.GL_LIGHTING);



OpenGL ES cho phép có tối đa 8 nguồn sáng từ bất kì điểm nào, để kích hoạt

được các nguồn sáng này phải bật cờ GL_LIGHTX trong hàm glEnable, X là giá trị từ

0 đến 7.

gl.glEnable (GL10.GL_LIGHT0);



Xác định các thông số chất liệu cho các mô hình chiếu sáng, thông qua các hàm

glMaterialfv và glMaterialf cùng với 3 tham số.

+ Tham số thứ nhất là cờ GL_FRONT_AND_BACK.



Xây dựng ứng dụng 3D với Android

84

______________________________________________________________________

+ Tham số thứ hai dùng để xác định loại nguồn sáng muốn sử dụng như



GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION và

GL_AMBIENT_AND_DIFFUSE.

+ Tham số cuối cùng là một mảng hoặc một giá trị.

gl.glMaterialf(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT,

matAmbient);

gl.glMaterialf(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE,

matDiffuse);



Giống như việc thiết lập chất liệu, ánh sáng cũng được thiết lập như vậy, điều

này được thực hiện bằng cách sử dụng hàm glLightfv và glLightf :

gl.glLightv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient);

gl.glLightv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightDiffuse);



Phần còn lại của hàm Init vẫn được giữ nguyên

gl.glEnable (GL10.GL_DEPTH_TEST);

gl.glDepthFunc(GL10.GL_LEQUAL);

gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

gl.glClearDepthf(1.0f);

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, box);

gl.glEnableClientState (GL10.GL_VERTEX_ARRAY);

gl.glEnable (GL10.GL_CULL_FACE);

gl.glShadeModel(GL10.GL_SMOOTH);

}



Xây dựng ứng dụng 3D với Android

85

______________________________________________________________________

Phần đầu của hàm display vẫn được giữ nguyên

public void display(GL10 gl)

{

gl.glClear(GL10.GL_COLOR_BUFFER_BIT |

GL10.GL_DEPTH_BUFFER_BIT);

gl.glLoadIdentity ();

GLU.gluLookAt(gl, 0.0f, 0.0f, 3.0f,

0.0f, 0.0f, 0.0f,

0.0f, 1.0f, 0.0f);

gl.glRotatef(xrot, 1.0f, 0.0f, 0.0f);

gl.glRotatef(yrot, 0.0f, 1.0f, 0.0f);



Ở phần trên chúng ta đã nói về pháp tuyến, các pháp tuyến này cần vuông góc

với bề mặt, bởi vậy bề mặt phía trước có một vector pháp tuyến (0,0,1), phía sau là

(0,0,-1). Độ dài 2 vector này là 1. Các pháp tuyến được xác định bằng hàm glNormal3f

và nó được gọi trước khi vẽ hình, hàm này có 3 tham số float.

// front and back

gl.glColor4f(1.0f, 0.0f, 0.0f, 1.0f);

gl.glNormal3f(0.0f, 0.0f, 1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLES_STRIP, 0, 4);

gl.glNormal3f(0.0f, 0.0f, -1.0f);

gl.glDrawArrays(GL10.GL_TRIANGLES_STRIP, 4, 4);



Điều này cũng được thực hiện cho phía trên, phía dưới và các mặt:

// left and right

gl.glColor4f(0.0f, 1.0f, 0.0f, 1.0f);

gl.glNormal3f(-1.0f, 0.0f, 0.0f);

gl.glDrawArrays(GL10.GL_TRIANGLES_STRIP, 8, 4);

gl.glNormal3f(1.0f, 0.0f, 0.0f);