Web 图形与 3D / 系统课时

根据表面法线计算漫反射

根据表面法线计算漫反射

让立方体的不同面随光照方向呈现不同亮度,需要为每个面提供正确法线,并在片元着色器中计算法线与光照方向的点积。完成后,你会得到一个能切换光照方向的 WebGL 2 示例,并用数值和画面核对结果。

学习目标

  • 区分表面外法线与“表面指向光源”的方向,理解归一化点积。
  • 为立方体上传逐面法线,在 GLSL ES 3.00 中实现 Lambert 漫反射。
  • 切换光源方向,验证受光强度及常见坐标空间错误。

用点积决定受光强度

法线 N\mathbf{N} 垂直于表面并指向物体外侧;光照方向 L\mathbf{L} 从表面指向光源。两者必须处于同一坐标空间,并各自归一化为单位向量。Lambert 漫反射因子为:

d=max⁡(N⋅L,0)d=\max(\mathbf{N}\cdot\mathbf{L},0)

当光正对表面时,d=1d=1;光与表面平行时,d=0d=0;光在背面时,负点积被截为 0。示例额外加入 0.20 的环境光基底,最终颜色为 base * (0.20 + 0.80 * d),这不是 Lambert 公式本身的一部分。

下表中的方向均先归一化,数值四舍五入到三位小数:

可见面 外法线 光从右上前方来 (1,2,3) 光从左上前方来 (-1,2,3)
右侧面 (1,0,0) 0.267 0.000
顶面 (0,1,0) 0.535 0.535
正面 (0,0,1) 0.802 0.802

立方体各面法线与两种光照方向的明暗对比

为立方体提供正确法线

立方体的六个外法线分别为 (+1,0,0)、(-1,0,0)、(0,+1,0)、(0,-1,0)、(0,0,+1)、(0,0,-1)。虽然只有八个不同空间角点,但硬边模型要按面复制为 24 个顶点、36 个索引,让同一角点在相邻面使用不同法线;若把角点法线平均,会得到不符合立方体硬边特征的平滑明暗。

下面使用交错 VBO:每顶点依次存三个位置分量、三个法线分量,合计 6 × 4 = 24 字节。着色器属性位置 0 对应位置,位置 1 对应法线,偏移分别为 0 和 12 字节。模型保持在世界原点,不施加模型变换,因此输入法线就是世界空间法线,能直接与世界空间光照方向计算点积。

运行可切换光照方向的示例

将以下内容保存为 index.html,用支持 WebGL 2 的浏览器打开。示例自带六面网格、视图和透视投影矩阵,不需要引入第三方库。

html
<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <title>Lambert 漫反射</title>
  <style>
    body { font: 16px sans-serif; }
    canvas { display: block; margin-top: 12px; border: 1px solid #dbe3ee; }
  </style>
</head>
<body>
<button id="light-right">光从右上前方来</button>
<button id="light-left">光从左上前方来</button>
<canvas id="scene" width="640" height="400"></canvas>
<script>
const canvas = document.querySelector("#scene");
const gl = canvas.getContext("webgl2");
if (!gl) throw new Error("需要支持 WebGL 2 的浏览器");

const vs = `#version 300 es
precision highp float;
layout(location=0) in vec3 aPosition;
layout(location=1) in vec3 aNormal;
uniform mat4 uView, uProjection;
out vec3 vNormal;
void main() {
  // 未施加模型变换,局部法线就是世界空间法线
  vNormal = aNormal;
  gl_Position = uProjection * uView * vec4(aPosition, 1.0);
}`;
const fs = `#version 300 es
precision highp float;
in vec3 vNormal;
uniform vec3 uLightDir;
out vec4 outColor;
void main() {
  vec3 N = normalize(vNormal);
  vec3 L = normalize(uLightDir);
  float d = max(dot(N, L), 0.0);
  vec3 base = vec3(0.25, 0.55, 0.85);
  outColor = vec4(base * (0.20 + 0.80 * d), 1.0);
}`;
function compile(type, source) {
  const shader = gl.createShader(type);
  gl.shaderSource(shader, source);
  gl.compileShader(shader);
  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))
    throw new Error(gl.getShaderInfoLog(shader));
  return shader;
}
const program = gl.createProgram();
gl.attachShader(program, compile(gl.VERTEX_SHADER, vs));
gl.attachShader(program, compile(gl.FRAGMENT_SHADER, fs));
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS))
  throw new Error(gl.getProgramInfoLog(program));
gl.useProgram(program);

// 每个面独立持有四个顶点,保持硬边法线
const faces = [
  [[0,0,1], [1,0,0], [0,1,0]],
  [[0,0,-1], [-1,0,0], [0,1,0]],
  [[1,0,0], [0,0,-1], [0,1,0]],
  [[-1,0,0], [0,0,1], [0,1,0]],
  [[0,1,0], [1,0,0], [0,0,-1]],
  [[0,-1,0], [1,0,0], [0,0,1]]
];
const vertices = [], indices = [];
for (const [n, right, up] of faces) {
  const start = vertices.length / 6;
  for (const [u, v] of [[-1,-1], [1,-1], [1,1], [-1,1]]) {
    vertices.push(...n.map((c,i) => 0.7 * (c + u*right[i] + v*up[i])), ...n);
  }
  indices.push(start, start+1, start+2, start, start+2, start+3);
}
const vao = gl.createVertexArray();
gl.bindVertexArray(vao);
const vbo = gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
const ebo = gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
gl.enableVertexAttribArray(0);
gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 24, 0);
gl.enableVertexAttribArray(1);
gl.vertexAttribPointer(1, 3, gl.FLOAT, false, 24, 12);

const unit = v => v.map(c => c / Math.hypot(...v));
const dot = (a,b) => a.reduce((s,c,i) => s + c*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 eye = [3,2,4], z = unit(eye);
const x = unit(cross([0,1,0], z));
const y = cross(z, x);
// 列主序视图矩阵:相机位于eye并朝向原点
const view = 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
]);
const f = 1 / Math.tan(Math.PI / 6), near = 0.1, far = 100;
const projection = new Float32Array([
  f/(canvas.width/canvas.height), 0, 0, 0,
  0, f, 0, 0,
  0, 0, (far+near)/(near-far), -1,
  0, 0, 2*far*near/(near-far), 0
]);
gl.uniformMatrix4fv(gl.getUniformLocation(program, "uView"), false, view);
gl.uniformMatrix4fv(gl.getUniformLocation(program, "uProjection"), false, projection);
gl.enable(gl.DEPTH_TEST);
gl.enable(gl.CULL_FACE);

function draw(direction) {
  gl.viewport(0, 0, canvas.width, canvas.height);
  gl.clearColor(0.96, 0.98, 1, 1);
  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
  gl.uniform3fv(gl.getUniformLocation(program, "uLightDir"), direction);
  gl.drawElements(gl.TRIANGLES, indices.length, gl.UNSIGNED_SHORT, 0);
}
document.querySelector("#light-right").onclick = () => draw([1,2,3]);
document.querySelector("#light-left").onclick = () => draw([-1,2,3]);
draw([1,2,3]);
</script>
</body>
</html>

预期结果:画布出现能同时看到顶面、正面和右侧面的蓝色立方体,三面亮度不同。点击“光从左上前方来”后,右侧面变暗至只剩环境光,顶面与正面亮度保持不变;切回右侧光源,右侧面恢复受光。

排查光照反向与法线失真

如果照亮了错误的一面,先检查 uLightDir 是否表示从表面指向光源。有些项目存储的是光线传播方向,这时应将该向量取反后再计算点积,不能仅修改 max 的阈值。

如果模型发生旋转或非等比缩放,顶点位置与法线也必须变到同一世界空间。对于可逆仿射模型矩阵 uModel,法线应使用 normalize(mat3(transpose(inverse(uModel))) * aNormal);不能把缩放后的法线直接当作原方向,也不能在世界空间法线上直接点乘观察空间的光向量。

最后可临时把 base * (0.20 + 0.80 * d) 改为 vec3(d) 来排除材质颜色干扰:右侧光源下右侧面的灰度应约为 0.267,切到左侧后应为 0。若棱角出现连续柔化,检查是否错误地让相邻面共用了同一顶点法线。

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

目录与阅读设置

阅读设置

17

记录一个想法

根据表面法线计算漫反射

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

登录哪都通