Web 图形与 3D / 系统课时

用射线拾取确定点击的物体

用射线拾取确定点击的物体

点击 Canvas 得到的是屏幕坐标,场景中的立方体却位于三维世界。本课把鼠标位置反投影为世界空间射线,逐一检测射线与包围盒的交点,选择沿射线最近的对象,并通过模型变色与文字显示选择结果。

学习目标

  • 把 CSS 像素坐标换算为 NDC,并通过投影、视图矩阵的逆变换生成射线。
  • 使用三个轴向区间计算射线与 AABB 的相交距离,选择最近命中项。
  • 在 WebGL 2 中运行拾取演示,辨别坐标偏差和包围盒误命中。

把点击位置反投影为世界射线

click 事件的 clientX、clientY 是相对浏览器视口的 CSS 像素。先减去 canvas.getBoundingClientRect() 的 left、top,再除以矩形的 width、height,得到画布内的相对位置。换算为归一化设备坐标(NDC):

xndc=2xcss/wcss−1x_{ndc}=2x_{css}/w_{css}-1,yndc=1−2ycss/hcssy_{ndc}=1-2y_{css}/h_{css}。

左上角对应 (−1,1)(-1,1),画布中心对应 (0,0)(0,0)。WebGL 的 NDC 近、远深度分别为 −1-1 和 11。构造这两个深度处的齐次点,用 (PV)−1(PV)^{-1} 反变换到世界空间(PP 为投影矩阵、VV 为视图矩阵),然后分别除以结果中的 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 的列主序存储,投影和拾取共享同一组相机参数。

js
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 也可能覆盖模型的空隙,精确选择时需对命中的候选进一步做三角形相交测试。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用射线拾取确定点击的物体

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通