Web 图形与 3D / 系统课时
用射线拾取确定点击的物体
用射线拾取确定点击的物体
点击 Canvas 得到的是屏幕坐标,场景中的立方体却位于三维世界。本课把鼠标位置反投影为世界空间射线,逐一检测射线与包围盒的交点,选择沿射线最近的对象,并通过模型变色与文字显示选择结果。
学习目标
- 把 CSS 像素坐标换算为 NDC,并通过投影、视图矩阵的逆变换生成射线。
- 使用三个轴向区间计算射线与 AABB 的相交距离,选择最近命中项。
- 在 WebGL 2 中运行拾取演示,辨别坐标偏差和包围盒误命中。
把点击位置反投影为世界射线
click 事件的 clientX、clientY 是相对浏览器视口的 CSS 像素。先减去 canvas.getBoundingClientRect() 的 left、top,再除以矩形的 width、height,得到画布内的相对位置。换算为归一化设备坐标(NDC):
,。
左上角对应 ,画布中心对应 。WebGL 的 NDC 近、远深度分别为 和 。构造这两个深度处的齐次点,用 反变换到世界空间( 为投影矩阵、 为视图矩阵),然后分别除以结果中的 w。以近点为射线起点,远点减近点并归一化得到方向。

沿三个坐标轴测试包围盒
AABB 是与世界坐标轴平行的盒子,由 min 和 max 两个三维点定义。本例立方体边长为 1.0,所以每个盒子的边界是 center ± 0.5。射线表示为 origin + t * direction,其中方向已归一化,t 就是世界空间距离。
对 X、Y、Z 轴分别算射线进入、离开该轴区间的参数,再取最大的进入值 tEnter 与最小的离开值 tExit。若 tEnter > tExit,三个区间没有共同部分,即未命中;若某方向分量接近零,则必须检查射线起点是否处在对应区间内,不能直接除以零。
只接受近裁剪面到远裁剪面之间的 t,并在所有盒子的命中值中取最小者。例如同一射线先后与 A、B 相交,距离分别为 2.2、4.6,应选 A,而不是最后遍历到的 B。下面的 rayAABB 函数会把候选距离限制在 [0, maxT]。
运行三个立方体的点击选择
在支持 WebGL 2 的浏览器打开普通网页,按 F12 进入开发者工具的 Console,粘贴并执行下方完整 JavaScript。它会创建一个画布、三个不同深度的立方体和结果文字;无需第三方库。矩阵按 WebGL 的列主序存储,投影和拾取共享同一组相机参数。
const canvas = document.createElement('canvas');
canvas.style.cssText = 'display:block;width:min(720px,100%);height:400px;cursor:crosshair';
const label = document.createElement('p');
label.textContent = '点击立方体进行选择';
document.body.append(canvas, label);
const gl = canvas.getContext('webgl2');
if (!gl) throw new Error('当前浏览器不支持 WebGL 2');
function shader(type, source) {
const s = gl.createShader(type);
gl.shaderSource(s, source);
gl.compileShader(s);
if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
throw new Error(gl.getShaderInfoLog(s));
}
return s;
}
const vs = `#version 300 es
in vec4 aVertex;
uniform mat4 uPV;
uniform vec3 uCenter;
out float vShade;
void main() {
vShade = aVertex.w;
gl_Position = uPV * vec4(aVertex.xyz + uCenter, 1.0);
}`;
const fs = `#version 300 es
precision highp float;
in float vShade;
uniform vec3 uColor;
out vec4 outColor;
void main() {
outColor = vec4(uColor * vShade, 1.0);
}`;
const program = gl.createProgram();
gl.attachShader(program, shader(gl.VERTEX_SHADER, vs));
gl.attachShader(program, shader(gl.FRAGMENT_SHADER, fs));
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
throw new Error(gl.getProgramInfoLog(program));
}
// 每个面附带亮度,帮助辨认立方体而不是只看到平面色块。
const corners = [
[-.5,-.5,-.5], [.5,-.5,-.5], [.5,.5,-.5], [-.5,.5,-.5],
[-.5,-.5,.5], [.5,-.5,.5], [.5,.5,.5], [-.5,.5,.5]
];
const faces = [
[[4,5,6,4,6,7],1], [[1,0,3,1,3,2],.55],
[[0,4,7,0,7,3],.75], [[5,1,2,5,2,6],.85],
[[3,7,6,3,6,2],1.1], [[0,1,5,0,5,4],.5]
];
const packed = new Float32Array(faces.flatMap(([ids, shade]) =>
ids.flatMap(i => [...corners[i], shade])));
const vao = gl.createVertexArray();
gl.bindVertexArray(vao);
const buffer = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
gl.bufferData(gl.ARRAY_BUFFER, packed, gl.STATIC_DRAW);
const aVertex = gl.getAttribLocation(program, 'aVertex');
gl.enableVertexAttribArray(aVertex);
gl.vertexAttribPointer(aVertex, 4, gl.FLOAT, false, 16, 0);
const uPV = gl.getUniformLocation(program, 'uPV');
const uCenter = gl.getUniformLocation(program, 'uCenter');
const uColor = gl.getUniformLocation(program, 'uColor');
gl.enable(gl.DEPTH_TEST);
const sub = (a, b) => a.map((v, i) => v - b[i]);
const dot = (a, b) => a.reduce((s, v, i) => s + v * b[i], 0);
const cross = (a, b) => [
a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]
];
const unit = a => a.map(v => v / Math.hypot(...a));
function lookAt(eye, target) {
const z = unit(sub(eye, target));
const x = unit(cross([0, 1, 0], z));
const y = cross(z, x);
return new Float32Array([
x[0],y[0],z[0],0, x[1],y[1],z[1],0,
x[2],y[2],z[2],0, -dot(x,eye),-dot(y,eye),-dot(z,eye),1
]);
}
function perspective(fovy, aspect, near, far) {
const f = 1 / Math.tan(fovy / 2);
return new Float32Array([
f/aspect,0,0,0, 0,f,0,0, 0,0,(far+near)/(near-far),-1,
0,0,2*far*near/(near-far),0
]);
}
function multiply(a, b) {
const out = new Float32Array(16);
for (let c=0; c<4; c++) for (let r=0; r<4; r++) {
for (let k=0; k<4; k++) out[c*4+r] += a[k*4+r] * b[c*4+k];
}
return out;
}
// 用高斯-约旦消元求逆,避免依赖外部矩阵库。
function inverse4(a) {
const m = Array.from({length:4}, (_, r) => [
...Array.from({length:4}, (_, c) => a[c*4+r]),
...Array.from({length:4}, (_, c) => +(r===c))
]);
for (let k=0; k<4; k++) {
let pivot = k;
for (let r=k+1; r<4; r++) {
if (Math.abs(m[r][k]) > Math.abs(m[pivot][k])) pivot = r;
}
if (Math.abs(m[pivot][k]) < 1e-10) throw new Error('矩阵不可逆');
[m[k], m[pivot]] = [m[pivot], m[k]];
const divisor = m[k][k];
for (let c=0; c<8; c++) m[k][c] /= divisor;
for (let r=0; r<4; r++) if (r !== k) {
const factor = m[r][k];
for (let c=0; c<8; c++) m[r][c] -= factor * m[k][c];
}
}
return new Float32Array(Array.from({length:16}, (_, i) =>
m[i%4][4+Math.floor(i/4)]));
}
function unproject(inv, x, y, z) {
const p = [x, y, z, 1];
const q = [0,1,2,3].map(r =>
p.reduce((sum, v, c) => sum + inv[c*4+r] * v, 0));
return q.slice(0,3).map(v => v / q[3]); // 齐次除法不可省略
}
function rayAABB(origin, dir, min, max, maxT) {
let enter = 0, exit = maxT;
for (let i=0; i<3; i++) {
if (Math.abs(dir[i]) < 1e-8) {
if (origin[i] < min[i] || origin[i] > max[i]) return null;
} else {
let a = (min[i] - origin[i]) / dir[i];
let b = (max[i] - origin[i]) / dir[i];
if (a > b) [a, b] = [b, a];
enter = Math.max(enter, a);
exit = Math.min(exit, b);
if (enter > exit) return null;
}
}
return enter;
}
const objects = [
{name:'A', center:[-1.6,0,.4], color:[.15,.42,.85]},
{name:'B', center:[0,0,-.6], color:[.2,.65,.48]},
{name:'C', center:[1.6,0,-1.6], color:[.8,.42,.18]}
];
const view = lookAt([0,1,6], [0,0,-.7]);
let invPV, selected = null;
function draw() {
const rect = canvas.getBoundingClientRect();
const dpr = window.devicePixelRatio || 1;
const w = Math.max(1, Math.round(rect.width*dpr));
const h = Math.max(1, Math.round(rect.height*dpr));
if (canvas.width !== w || canvas.height !== h) {
canvas.width = w; canvas.height = h;
}
gl.viewport(0, 0, w, h);
const pv = multiply(perspective(Math.PI/3, w/h, .1, 50), view);
invPV = inverse4(pv);
gl.clearColor(.97, .98, 1, 1);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
gl.useProgram(program);
gl.bindVertexArray(vao);
gl.uniformMatrix4fv(uPV, false, pv);
for (const obj of objects) {
gl.uniform3fv(uCenter, obj.center);
gl.uniform3fv(uColor, obj.name === selected ? [1,.75,.13] : obj.color);
gl.drawArrays(gl.TRIANGLES, 0, packed.length/4);
}
}
canvas.addEventListener('click', event => {
const rect = canvas.getBoundingClientRect();
const x = 2*(event.clientX-rect.left)/rect.width-1;
const y = 1-2*(event.clientY-rect.top)/rect.height;
const near = unproject(invPV, x, y, -1);
const far = unproject(invPV, x, y, 1);
const span = sub(far, near);
const maxT = Math.hypot(...span);
const dir = span.map(v => v/maxT);
let hit = null, nearest = maxT;
for (const obj of objects) {
const min = obj.center.map(v => v-.5);
const max = obj.center.map(v => v+.5);
const t = rayAABB(near, dir, min, max, maxT);
if (t !== null && t < nearest) {
nearest = t;
hit = obj;
}
}
selected = hit ? hit.name : null;
label.textContent = selected ? `选中:${selected}` : '未选中';
console.log(label.textContent);
draw(); // 更改选中高亮,但不更改拾取的几何数据
});
window.addEventListener('resize', draw);
draw();预期结果:页面出现三个有明暗面的立方体;点击中间的绿色立方体,文字与控制台显示 选中:B,该模型转为金黄色;点击空白区域显示 未选中,高亮取消。窗口尺寸改变后,点击位置仍与模型对齐。
检查遮挡顺序与误命中
先把示例里 A 的 center 改为 [0,0,.4],刷新页面后重新执行代码。A 与 B 会在画面中央部分重叠,点击重叠处应优先选 A;因为只取最小正向交距,循环的对象顺序不影响结果。保留 gl.enable(gl.DEPTH_TEST) 让绘制遮挡也符合这个判断。
此例只适用于没有旋转、尺寸为 1×1×1 的世界轴对齐盒。若模型旋转,应使用模型矩阵的逆把射线变换到局部空间,再与局部 AABB 求交;方向按向量处理(齐次 w=0),若需要跨对象比较世界距离,不要在局部空间重新归一化方向。AABB 也可能覆盖模型的空隙,精确选择时需对命中的候选进一步做三角形相交测试。