WebGL 正交 3D

Gregg Tavares
Gregg Tavares

WebGL 正射 3D

本文是 WebGL 系列文章的延续。 第一篇从基础知识开始,上一篇是关于 2D 矩阵。如果您尚未阅读这些内容,请先查看。 在上一篇博文中,我们介绍了 2D 矩阵的工作原理。我们讨论了平移、旋转、缩放,甚至从像素投影到裁剪空间,都可以通过一个矩阵和一些神奇的矩阵数学运算来完成。从这里到 3D 只有一小步。 在之前的 2D 示例中,我们有 2D 点 (x, y),并将其乘以 3x3 矩阵。要进行 3D 变换,我们需要 3D 点 (x, y, z) 和 4x4 矩阵。 我们来看最后一个示例,并将其更改为 3D。我们再次使用 F,但这次是 3D“F”。 我们首先需要更改顶点着色器,以处理 3D。这是旧着色器。

<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>

这是新版

<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>

现在更简单了! 然后,我们需要提供 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);
}

接下来,我们需要将所有矩阵函数从 2D 更改为 3D 以下是 makeTranslation、makeRotation 和 makeScale 的 2D(之前)版本

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
];
}

这是更新后的 3D 版本。

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,
];
}

请注意,我们现在有 3 个旋转函数。在 2D 中,我们只需要一个,因为我们实际上只围绕 Z 轴旋转。现在,为了实现 3D 效果,我们还希望能够围绕 X 轴和 Y 轴旋转。从这些示例中可以看出,它们都非常相似。如果我们把它们算出来,你会发现它们会像之前一样简化

Z 轴旋转

newX = x * c + y * s;
newY = x * -s + y * c;

Y 轴旋转


newX = x * c + z * s;
newZ = x * -s + z * c;

X 轴旋转

newY = y * c + z * s;
newZ = y * -s + z * 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
];
}

它将像素转换为裁剪空间。我们先尝试将它扩展到 3D

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,
];
}

就像我们需要将 x 和 y 从像素转换为裁剪空间一样,对于 z,我们也需要执行相同的操作。在本例中,我将 Z 空间也设为像素单位。我会为深度传入一个类似于 width 的值,这样我们的空间宽度将为 0 到 width 像素,高度将为 0 到 height 像素,但深度将为 -depth / 2 到 +depth / 2。 最后,我们需要更新计算矩阵的代码。

// 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);

我们遇到的第一个问题是,我们的几何图形是一个扁平的 F,很难看出任何 3D 效果。为了解决这个问题,我们将几何图形扩展到 3D。我们当前的 F 由 3 个矩形组成,每个矩形由 2 个三角形组成。要将其转换为 3D,总共需要 16 个矩形。这里列出的数量相当多。 16 个矩形 x 每个矩形 2 个三角形 x 每个三角形 3 个顶点,共 96 个顶点。如果您想查看所有这些内容,请查看示例的源代码。 我们需要绘制更多顶点

// Draw the geometry.
gl.drawArrays(gl.TRIANGLES, 0, 16 * 6);

移动滑块时,很难看出这是 3D 效果。我们尝试为每个矩形涂上不同的颜色。为此,我们将向顶点着色器添加另一个属性,并添加一个可变变量,以便将其从顶点着色器传递到片段着色器。 以下是新的顶点着色器

<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>

我们需要在片段着色器中使用该颜色

<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>

我们需要查找位置来提供颜色,然后设置另一个缓冲区和属性来为其提供颜色。

...
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);
}

哎呀,怎么这么乱?原来,3D“F”的所有不同部分(正面、背面、侧面等)都是按照它们在几何图形中出现的顺序绘制的。这并不能带来我们想要的结果,因为有时后面的元素会在前面的元素之后绘制。 WebGL 中的三角形有正面和背面的概念。正面三角形的顶点按顺时针方向排列。背面三角形的顶点按逆时针方向排列。

三角形绕线。

WebGL 能够仅绘制朝前或朝后的三角形。我们可以使用

gl.enable(gl.CULL_FACE);

我们只需在程序开始时执行一次此操作。启用该功能后,WebGL 会默认“剔除”背面三角形。 这里的“剔除”是“不绘制”的专业术语。 请注意,就 WebGL 而言,三角形是顺时针还是逆时针取决于该三角形在裁剪空间中的顶点。换句话说,WebGL 会在您对顶点着色器中的顶点应用数学运算后,确定三角形是正面还是背面。例如,如果顺时针三角形在 X 轴方向上缩放 -1,则会变为逆时针三角形;如果顺时针三角形绕 X 轴或 Y 轴旋转 180 度,则会变为逆时针三角形。由于我们停用了 CULL_FACE,因此可以看到顺时针(正面)和逆时针(背面)三角形。现在我们已经开启了该功能,每当正面三角形因缩放、旋转或任何其他原因而翻转时,WebGL 都不会绘制它。 这是一件好事,因为当您在 3D 空间中旋转某个对象时,通常希望将面向您的三角形视为正面。

嘿!三角形都去哪了?结果发现,其中许多都朝向错误的方向。旋转它,您会在另一侧看到它们。好在问题很容易解决。我们只需查看哪些三角形是反向的,并交换其 2 个顶点。例如,如果一个后退三角形

1,   2,   3,
40,  50,  60,
700, 800, 900,

我们只需翻转最后 2 个顶点,使其向前。

1,   2,   3,
700, 800, 900,
40,  50,  60,

这样更接近了,但还有一个问题。即使所有三角形都朝向正确的方向,并且朝后的三角形已被剔除,我们仍然会遇到一些情况,即本应在后面的三角形被绘制在本应在前面的三角形之上。 输入 DEPTH BUFFER。 深度缓冲区(有时称为 Z 缓冲区)是一个由 depth 像素组成的矩形,其中每个深度像素对应一个用于生成图像的颜色像素。当 WebGL 绘制每个颜色像素时,它也可以绘制深度像素。它会根据我们从顶点着色器返回的 Z 值来执行此操作。就像我们必须将 X 和 Y 转换为裁剪空间一样,Z 也在裁剪空间中(-1 到 +1)。然后,该值会转换为深度空间值(0 到 +1)。 在 WebGL 绘制颜色像素之前,它会检查相应的深度像素。如果即将绘制的像素的深度值大于对应深度像素的值,则 WebGL 不会绘制新的颜色像素。否则,它会使用片元着色器中的颜色绘制新的颜色像素,并使用新的深度值绘制深度像素。这意味着,位于其他像素后面的像素不会被绘制。 我们可以开启此功能,其操作几乎与使用

gl.enable(gl.DEPTH_TEST);

在开始绘制之前,我们还需要将深度缓冲区清除回 1.0。

// Draw the scene.
function drawScene() {
// Clear the canvas AND the depth buffer.
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
...

在下一篇帖子中,我将介绍如何让它具有透视效果。

为什么属性是 vec4,但 gl.vertexAttribPointer 的大小是 3

细心的你可能已经注意到,我们将这两个属性定义为

attribute vec4 a_position;
attribute vec4 a_color;

它们都是“vec4”,但当我们告诉 WebGL 如何从缓冲区中提取数据时,我们使用了

gl.vertexAttribPointer(positionLocation, 3, gl.FLOAT, false, 0, 0);
gl.vertexAttribPointer(colorLocation, 3, gl.UNSIGNED_BYTE, true, 0, 0);

其中每个“3”都表示每个属性仅提取 3 个值。 之所以能这样做,是因为在顶点着色器中,WebGL 会为您未提供的属性提供默认值。默认值为 0、0、0、1,其中 x = 0、y = 0、z = 0 且 w = 1。这就是为什么在旧版 2D 顶点着色器中,我们必须明确提供 1。我们传入了 x 和 y,并且需要 z 为 1,但由于 z 的默认值为 0,我们必须明确提供 1。不过,对于 3D,即使我们不提供“w”,它也会默认为 1,这是矩阵数学运算正常运行所必需的。