WebGL 3D trực giao
Bài đăng này là phần tiếp theo của loạt bài đăng về WebGL. Video đầu tiên bắt đầu với các kiến thức cơ bản và video trước đó là về ma trận 2D. Nếu bạn chưa đọc những bài viết đó, vui lòng xem trước. Trong bài đăng trước, chúng ta đã tìm hiểu cách hoạt động của ma trận 2D. Chúng ta đã nói về việc tịnh tiến, xoay, điều chỉnh tỷ lệ và thậm chí là chiếu từ pixel vào không gian cắt đều có thể được thực hiện bằng một ma trận và một số phép toán ma trận kỳ diệu. Để tạo 3D, bạn chỉ cần thực hiện thêm một bước nhỏ nữa. Trong các ví dụ 2D trước, chúng ta có các điểm 2D (x, y) mà chúng ta nhân với ma trận 3x3. Để tạo 3D, chúng ta cần các điểm 3D (x, y, z) và ma trận 4x4. Hãy lấy ví dụ cuối cùng và thay đổi thành 3D. Chúng ta sẽ sử dụng lại chữ F nhưng lần này là chữ "F" 3D. Việc đầu tiên chúng ta cần làm là thay đổi chương trình đổ bóng đỉnh để xử lý 3D. Đây là chương trình đổ bóng cũ.
<script id="2d-vertex-shader" type="x-shader/x-vertex">
attribute vec2 a_position;
uniform mat3 u_matrix;
void main() {
// Multiply the position by the matrix.
gl_Position = vec4((u_matrix * vec3(a_position, 1)).xy, 0, 1);
}
</script>
Và đây là phiên bản mới
<script id="3d-vertex-shader" type="x-shader/x-vertex">
attribute vec4 a_position;
uniform mat4 u_matrix;
void main() {
// Multiply the position by the matrix.
gl_Position = u_matrix * a_position;
}
</script>
Giờ đây, việc này còn đơn giản hơn nữa! Sau đó, chúng ta cần cung cấp dữ liệu 3D.
...
gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
...
// Fill the buffer with the values that define a letter 'F'.
function setGeometry(gl) {
gl.bufferData(
gl.ARRAY_BUFFER,
new Float32Array([
// left column
0, 0, 0,
30, 0, 0,
0, 150, 0,
0, 150, 0,
30, 0, 0,
30, 150, 0,
// top rung
30, 0, 0,
100, 0, 0,
30, 30, 0,
30, 30, 0,
100, 0, 0,
100, 30, 0,
// middle rung
30, 60, 0,
67, 60, 0,
30, 90, 0,
30, 90, 0,
67, 60, 0,
67, 90, 0]),
gl.STATIC_DRAW);
}
Tiếp theo, chúng ta cần thay đổi tất cả các hàm ma trận từ 2D sang 3D Dưới đây là các phiên bản 2D (trước đây) của makeTranslation, makeRotation và makeScale
function makeTranslation(tx, ty) {
return [
1, 0, 0,
0, 1, 0,
tx, ty, 1
];
}
function makeRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
c,-s, 0,
s, c, 0,
0, 0, 1
];
}
function makeScale(sx, sy) {
return [
sx, 0, 0,
0, sy, 0,
0, 0, 1
];
}
Và đây là các phiên bản 3D mới.
function makeTranslation(tx, ty, tz) {
return [
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
tx, ty, tz, 1
];
}
function makeXRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
1, 0, 0, 0,
0, c, s, 0,
0, -s, c, 0,
0, 0, 0, 1
];
};
function makeYRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
c, 0, -s, 0,
0, 1, 0, 0,
s, 0, c, 0,
0, 0, 0, 1
];
};
function makeZRotation(angleInRadians) {
var c = Math.cos(angleInRadians);
var s = Math.sin(angleInRadians);
return [
c, s, 0, 0,
-s, c, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
];
}
function makeScale(sx, sy, sz) {
return [
sx, 0, 0, 0,
0, sy, 0, 0,
0, 0, sz, 0,
0, 0, 0, 1,
];
}
Lưu ý rằng hiện tại chúng ta có 3 hàm xoay. Chúng ta chỉ cần một góc trong 2D vì chúng ta chỉ xoay quanh trục Z. Bây giờ, để tạo 3D, chúng ta cũng muốn có thể xoay quanh trục x và trục y. Bạn có thể thấy khi nhìn vào chúng, tất cả đều rất giống nhau. Nếu chúng ta giải chúng, bạn sẽ thấy chúng được đơn giản hoá như trước
Xoay theo trục Z
newX = x * c + y * s;
newY = x * -s + y * c;
Xoay theo trục Y
newX = x * c + z * s;
newZ = x * -s + z * c;
Xoay theo trục X
newY = y * c + z * s;
newZ = y * -s + z * c;
Chúng ta cũng cần cập nhật hàm chiếu. Đây là phiên bản cũ
function make2DProjection(width, height) {
// Note: This matrix flips the Y axis so 0 is at the top.
return [
2 / width, 0, 0,
0, -2 / height, 0,
-1, 1, 1
];
}
chuyển đổi từ pixel sang không gian cắt. Trong lần đầu tiên mở rộng sang 3D, hãy thử
function make2DProjection(width, height, depth) {
// Note: This matrix flips the Y axis so 0 is at the top.
return [
2 / width, 0, 0, 0,
0, -2 / height, 0, 0,
0, 0, 2 / depth, 0,
-1, 1, 0, 1,
];
}
Cũng giống như việc chúng ta cần chuyển đổi từ pixel sang không gian cắt cho x và y, đối với z, chúng ta cũng cần làm điều tương tự. Trong trường hợp này, tôi cũng đặt đơn vị không gian Z là pixel. Tôi sẽ truyền một số giá trị tương tự như width cho chiều sâu để không gian của chúng ta sẽ có chiều rộng từ 0 đến chiều rộng pixel, chiều cao từ 0 đến chiều cao pixel, nhưng đối với chiều sâu, giá trị sẽ là -chiều sâu / 2 đến +chiều sâu / 2.
Cuối cùng, chúng ta cần cập nhật mã tính toán ma trận.
// Compute the matrices
var projectionMatrix =
make2DProjection(canvas.width, canvas.height, canvas.width);
var translationMatrix =
makeTranslation(translation[0], translation[1], translation[2]);
var rotationXMatrix = makeXRotation(rotation[0]);
var rotationYMatrix = makeYRotation(rotation[1]);
var rotationZMatrix = makeZRotation(rotation[2]);
var scaleMatrix = makeScale(scale[0], scale[1], scale[2]);
// Multiply the matrices.
var matrix = matrixMultiply(scaleMatrix, rotationZMatrix);
matrix = matrixMultiply(matrix, rotationYMatrix);
matrix = matrixMultiply(matrix, rotationXMatrix);
matrix = matrixMultiply(matrix, translationMatrix);
matrix = matrixMultiply(matrix, projectionMatrix);
// Set the matrix.
gl.uniformMatrix4fv(matrixLocation, false, matrix);
Vấn đề đầu tiên là hình học của chúng ta là một chữ F phẳng, khiến chúng ta khó nhìn thấy bất kỳ hình ảnh 3D nào. Để khắc phục vấn đề đó, hãy mở rộng hình học sang 3D. Chữ F hiện tại của chúng ta được tạo thành từ 3 hình chữ nhật, mỗi hình chữ nhật có 2 hình tam giác. Để tạo hình 3D, bạn cần tổng cộng 16 hình chữ nhật. Có khá nhiều lý do để liệt kê ở đây. 16 hình chữ nhật x 2 hình tam giác trên mỗi hình chữ nhật x 3 đỉnh trên mỗi hình tam giác là 96 đỉnh. Nếu bạn muốn xem tất cả, hãy xem nguồn trên mẫu. Chúng ta phải vẽ thêm các đỉnh, vì vậy
// Draw the geometry.
gl.drawArrays(gl.TRIANGLES, 0, 16 * 6);
Khi di chuyển thanh trượt, bạn sẽ khó nhận biết được đây là hình ảnh 3D. Hãy thử tô mỗi hình chữ nhật bằng một màu khác nhau. Để làm việc này, chúng ta sẽ thêm một thuộc tính khác vào chương trình đổ bóng đỉnh và một biến để truyền thuộc tính đó từ chương trình đổ bóng đỉnh sang chương trình đổ bóng mảnh. Sau đây là chương trình đổ bóng đỉnh mới
<script id="3d-vertex-shader" type="x-shader/x-vertex">
attribute vec4 a_position;
attribute vec4 a_color;
uniform mat4 u_matrix;
varying vec4 v_color;
void main() {
// Multiply the position by the matrix.
gl_Position = u_matrix * a_position;
// Pass the color to the fragment shader.
v_color = a_color;
}
</script>
Và chúng ta cần sử dụng màu đó trong chương trình đổ bóng mảnh
<script id="3d-vertex-shader" type="x-shader/x-fragment">
precision mediump float;
// Passed in from the vertex shader.
varying vec4 v_color;
void main() {
gl_FragColor = v_color;
}
</script>
Chúng ta cần tra cứu vị trí để cung cấp màu sắc, sau đó thiết lập một vùng đệm và thuộc tính khác để cung cấp màu sắc cho vùng đệm đó.
...
var colorLocation = gl.getAttribLocation(program, "a_color");
...
// Create a buffer for colors.
var buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.enableVertexAttribArray(colorLocation);
// We'll supply RGB as bytes.
gl.vertexAttribPointer(colorLocation, 3, gl.UNSIGNED_BYTE, true, 0, 0);
// Set Colors.
setColors(gl);
...
// Fill the buffer with colors for the 'F'.
function setColors(gl) {
gl.bufferData(
gl.ARRAY_BUFFER,
new Uint8Array([
// left column front
200, 70, 120,
200, 70, 120,
200, 70, 120,
200, 70, 120,
200, 70, 120,
200, 70, 120,
// top rung front
200, 70, 120,
200, 70, 120,
...
...
gl.STATIC_DRAW);
}
Ôi, đống bừa bộn gì thế kia? Hoá ra tất cả các phần khác nhau của chữ "F" 3D đó, mặt trước, mặt sau, các cạnh, v.v. đều được vẽ theo thứ tự xuất hiện trong hình học của chúng ta. Điều đó không mang lại kết quả như mong muốn vì đôi khi các phần tử ở phía sau được vẽ sau các phần tử ở phía trước. Các hình tam giác trong WebGL có khái niệm về mặt trước và mặt sau. Một tam giác hướng về phía trước có các đỉnh đi theo chiều kim đồng hồ. Một tam giác hướng về phía sau có các đỉnh đi theo hướng ngược chiều kim đồng hồ.
WebGL có khả năng chỉ vẽ các hình tam giác hướng về phía trước hoặc hướng về phía sau. Chúng tôi có thể bật tính năng đó bằng
gl.enable(gl.CULL_FACE);
chúng ta chỉ thực hiện một lần, ngay khi bắt đầu chương trình. Khi bật tính năng đó, WebGL sẽ mặc định "loại bỏ" các tam giác hướng về phía sau. "Loại bỏ" trong trường hợp này là một từ hoa mỹ cho "không vẽ". Lưu ý rằng theo WebGL, việc một tam giác được coi là đi theo chiều kim đồng hồ hay ngược chiều kim đồng hồ phụ thuộc vào các đỉnh của tam giác đó trong không gian cắt. Nói cách khác, WebGL sẽ xác định xem một tam giác là mặt trước hay mặt sau SAU KHI bạn áp dụng phép toán cho các đỉnh trong chương trình đổ bóng đỉnh. Ví dụ: điều này có nghĩa là một tam giác theo chiều kim đồng hồ được điều chỉnh theo tỷ lệ X là -1 sẽ trở thành tam giác ngược chiều kim đồng hồ hoặc một tam giác theo chiều kim đồng hồ xoay 180 độ quanh trục X hoặc Y sẽ trở thành tam giác ngược chiều kim đồng hồ. Vì đã tắt CULL_FACE, nên chúng ta có thể thấy cả hình tam giác theo chiều kim đồng hồ(mặt trước) và ngược chiều kim đồng hồ(mặt sau). Bây giờ, khi chúng ta đã bật tính năng này, bất cứ khi nào một tam giác hướng về phía trước bị lật ngược do điều chỉnh tỷ lệ hoặc xoay hay vì bất kỳ lý do nào khác, WebGL sẽ không vẽ tam giác đó. Đây là một điều tốt vì khi bạn xoay một vật thể trong không gian 3D, bạn thường muốn bất kỳ tam giác nào hướng về phía bạn đều được coi là mặt trước.
Chào cậu! Tất cả các hình tam giác đã đi đâu? Hoá ra, nhiều tấm pin đang quay sai hướng. Xoay nó và bạn sẽ thấy chúng xuất hiện khi bạn nhìn vào phía bên kia. May mắn là vấn đề này rất dễ khắc phục. Chúng ta chỉ cần xem những tam giác nào bị ngược và đổi 2 đỉnh của chúng. Ví dụ: nếu một hình tam giác ngược là
1, 2, 3,
40, 50, 60,
700, 800, 900,
chúng ta chỉ cần lật 2 đỉnh cuối cùng để làm cho nó tiến lên.
1, 2, 3,
700, 800, 900,
40, 50, 60,
Kết quả này gần đạt kỳ vọng của bạn nhưng vẫn còn một vấn đề nữa. Ngay cả khi tất cả các tam giác đều hướng về đúng hướng và các tam giác hướng về phía sau bị loại bỏ, chúng ta vẫn có những vị trí mà các tam giác lẽ ra phải ở phía sau lại được vẽ đè lên các tam giác lẽ ra phải ở phía trước.
Nhập DEPTH BUFFER.
Bộ đệm độ sâu (đôi khi được gọi là Bộ đệm Z) là một hình chữ nhật gồm depth pixel, một pixel độ sâu cho mỗi pixel màu được dùng để tạo hình ảnh. Khi WebGL vẽ từng pixel màu, nó cũng có thể vẽ một pixel độ sâu. Thao tác này được thực hiện dựa trên các giá trị mà chúng ta trả về từ chương trình đổ bóng đỉnh cho Z. Cũng giống như việc chúng ta phải chuyển đổi sang không gian cắt cho X và Y, Z cũng nằm trong không gian cắt hoặc (-1 đến +1). Sau đó, giá trị đó được chuyển đổi thành giá trị không gian độ sâu (0 đến +1).
Trước khi WebGL vẽ một điểm ảnh màu, WebGL sẽ kiểm tra điểm ảnh có chiều sâu tương ứng. Nếu giá trị độ sâu của pixel mà WebGL sắp vẽ lớn hơn giá trị của pixel độ sâu tương ứng, thì WebGL sẽ không vẽ pixel màu mới. Nếu không, nó sẽ vẽ cả pixel màu mới bằng màu từ chương trình đổ bóng mảnh VÀ vẽ pixel độ sâu bằng giá trị độ sâu mới. Điều này có nghĩa là các pixel phía sau các pixel khác sẽ không được vẽ.
Chúng ta có thể bật tính năng này gần như đơn giản như khi bật tính năng loại bỏ bằng
gl.enable(gl.DEPTH_TEST);
Chúng ta cũng cần xoá vùng đệm độ sâu về 1.0 trước khi bắt đầu vẽ.
// Draw the scene.
function drawScene() {
// Clear the canvas AND the depth buffer.
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
...
Trong bài đăng tiếp theo, tôi sẽ hướng dẫn cách tạo phối cảnh cho hình ảnh.
Tại sao thuộc tính là vec4 nhưng kích thước gl.vertexAttribPointer là 3
Đối với những người chú ý đến chi tiết, bạn có thể nhận thấy chúng ta đã xác định 2 thuộc tính là
attribute vec4 a_position;
attribute vec4 a_color;
cả hai đều là "vec4" nhưng khi chúng ta cho WebGL biết cách lấy dữ liệu ra khỏi vùng đệm, chúng ta đã sử dụng
gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
gl.vertexAttribPointer(colorLocation, 3, gl.UNSIGNED_BYTE, true, 0, 0);
Số "3" trong mỗi thuộc tính đó cho biết chỉ lấy ra 3 giá trị cho mỗi thuộc tính. Điều này hoạt động vì trong chương trình đổ bóng đỉnh, WebGL cung cấp giá trị mặc định cho những giá trị bạn không cung cấp. Giá trị mặc định là 0, 0, 0, 1 trong đó x = 0, y = 0, z = 0 và w = 1. Đây là lý do tại sao trong chương trình đổ bóng đỉnh 2D cũ, chúng ta phải cung cấp rõ ràng giá trị 1. Chúng ta đã truyền x và y, đồng thời cần 1 cho z nhưng vì giá trị mặc định cho z là 0 nên chúng ta phải cung cấp rõ ràng 1. Tuy nhiên, đối với 3D, ngay cả khi chúng ta không cung cấp "w", thì giá trị mặc định của nó là 1, đây là giá trị chúng ta cần để toán học ma trận hoạt động.