Three.js 画布纹理：像素世界的魔法编织术

想象一下，你手中握着一把像素编织针，能将 2D 画布上的斑斓图案编织进 3D 世界的每一个角落 ------ 这就是 Three.js 中 canvas 纹理的魔力。作为数字世界的 "织匠"，我们不仅要会用工具，更要懂每一根线的来龙去脉。今天就让我们剥开这层魔法的外衣，看看像素是如何从 2D 画布跳上 3D 舞台的。

像素的迁徙：从 Canvas 到 Mesh

在计算机图形学的王国里，纹理映射（Texture Mapping） 就像给 3D 模型贴墙纸的艺术，但这墙纸可不是普通的纸张。当我们用 canvas 作为纹理源时，其实是在指挥一群像素移民从 2D 的 canvas 画布搬迁到 3D 模型的表面。

这些像素移民的迁徙路线遵循着严格的数学法则：每个像素都有一对 UV 坐标作为通行证，U 代表水平方向，V 代表垂直方向，取值范围都是 0 到 1。就像城市里的门牌号，(0,0) 是左下角，(1,1) 是右上角，3D 模型表面的每个顶点都拿着这样的坐标卡，告诉像素 "我该站在这里"。

让我们用一段代码搭建像素的 "移民局"：

ini 复制代码

// 创建2D画布作为像素源
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
canvas.width = 512;
canvas.height = 512;
// 在画布上绘制像素图案（这里画个彩虹渐变）
const gradient = ctx.createLinearGradient(0, 0, canvas.width, canvas.height);
gradient.addColorStop(0, '#ff0000');
gradient.addColorStop(0.2, '#ffff00');
gradient.addColorStop(0.4, '#00ff00');
gradient.addColorStop(0.6, '#00ffff');
gradient.addColorStop(0.8, '#0000ff');
gradient.addColorStop(1, '#8b00ff');
ctx.fillStyle = gradient;
ctx.fillRect(0, 0, canvas.width, canvas.height);
// 创建纹理移民局，办理像素迁徙手续
const texture = new THREE.CanvasTexture(canvas);
// 给移民局配置一些规则（纹理参数）
texture.wrapS = THREE.RepeatWrapping; // 水平方向重复
texture.wrapT = THREE.RepeatWrapping; // 垂直方向重复
texture.magFilter = THREE.LinearFilter; // 放大时的像素插值方式
texture.minFilter = THREE.LinearMipmapLinearFilter; // 缩小时的像素插值方式

这段代码里藏着一个关键的底层逻辑：当我们创建CanvasTexture实例时，Three.js 会自动完成纹理单元（Texture Unit） 的分配。就像给每个纹理分配一个专属的 "移民通道"，GPU 通过这个通道可以快速访问纹理数据。在 WebGL 的规范中，这些通道通常有 16 个（编号 0-15），Three.js 会默默帮我们管理这些通道的分配。

画布纹理的底层密码

如果把 Three.js 比作一家高级餐厅，CanvasTexture就是为我们精心准备的一道佳肴，而 WebGL 则是烹饪这道佳肴的厨房。当我们调用new THREE.CanvasTexture(canvas)时，背后发生了一系列精密的操作：

像素数据采集：浏览器从 canvas 元素中读取 RGBA 格式的像素信息，每个通道占 8 位（0-255）

纹理对象创建：WebGL 创建WebGLTexture对象，作为 GPU 中纹理数据的容器

数据上传：像素数据通过texImage2D函数上传到 GPU 内存（这是最耗时的一步）

参数配置：设置纹理过滤方式、环绕模式等，就像给打印机装纸时调整纸张类型

让我们用更贴近底层的方式创建一个会呼吸的纹理：

ini 复制代码

// 创建带动画的画布纹理
function createAnimatedTexture() {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  canvas.width = 256;
  canvas.height = 256;
  
  // 动画状态变量
  let phase = 0;
  
  // 每帧更新纹理内容
  function update() {
    phase += 0.02;
    
    // 清画布
    ctx.fillStyle = '#000';
    ctx.fillRect(0, 0, canvas.width, canvas.height);
    
    // 绘制动态图形（跳动的圆形）
    const radius = 50 + Math.sin(phase) * 20;
    ctx.beginPath();
    ctx.arc(canvas.width/2, canvas.height/2, radius, 0, Math.PI * 2);
    ctx.fillStyle = `hsl(${(phase * 30) % 360}, 100%, 50%)`;
    ctx.fill();
    
    requestAnimationFrame(update);
  }
  
  // 启动动画
  update();
  
  // 创建纹理并设置合理参数
  const texture = new THREE.CanvasTexture(canvas);
  texture.anisotropy = renderer.capabilities.getMaxAnisotropy(); // 各向异性过滤
  texture.needsUpdate = true; // 告诉Three.js纹理已更新
  
  return texture;
}
// 使用这个纹理
const material = new THREE.MeshBasicMaterial({
  map: createAnimatedTexture()
});
const mesh = new THREE.SphereGeometry(5, 32, 32);
scene.add(new THREE.Mesh(geometry, material));

这里的needsUpdate = true是个容易被忽略的细节，它就像给 Three.js 递了一张便条："嘿，这个纹理的内容变了，麻烦帮我更新一下 GPU 里的副本"。如果没有这行代码，GPU 会一直使用旧的像素数据，我们精心制作的动画就成了凝固的雕塑。

过滤与环绕：像素的变形术

当纹理被贴到 3D 模型上时，很少能刚好 1:1 匹配。这时候就需要纹理过滤（Texture Filtering） 来解决 "像素不够用" 或 "像素太多" 的问题：

放大过滤（Mag Filter） ：当纹理被放大时（比如近距离观察），GPU 需要决定如何在像素之间插值

- THREE.NearestFilter：直接取最近的像素，像马赛克画一样锐利

- THREE.LinearFilter：混合周围像素，像水彩画一样柔和

缩小过滤（Min Filter） ：当纹理被缩小时（比如远距离观察），GPU 需要处理像素合并

- 带Mipmap的过滤方式会预先创建不同分辨率的纹理副本，根据距离自动切换

而纹理环绕（Texture Wrapping） 则决定了当纹理坐标超出 0-1 范围时该如何处理：

ini 复制代码

// 让纹理像瓷砖一样重复
texture.wrapS = THREE.RepeatWrapping;
texture.wrapT = THREE.RepeatWrapping;
texture.repeat.set(2, 3); // 水平重复2次，垂直重复3次
// 或者让纹理镜像重复
texture.wrapS = THREE.MirroredRepeatWrapping;
texture.wrapT = THREE.MirroredRepeatWrapping;
// 或者拉伸边缘像素
texture.wrapS = THREE.ClampToEdgeWrapping;
texture.wrapT = THREE.ClampToEdgeWrapping;

想象一下，RepeatWrapping就像用邮票铺满信封，MirroredRepeatWrapping则像布料的正反交替，而ClampToEdgeWrapping则像用胶带把图片边缘粘住并拉伸。这些模式的选择直接影响最终视觉效果，也关系到性能 ------ 比如MirroredRepeatWrapping在某些设备上可能比RepeatWrapping稍慢。

实战：创建会画画的 3D 球体

让我们把学到的知识融会贯通，创建一个能在表面实时绘制的 3D 球体。这个例子展示了画布纹理最强大的特性：动态交互。

ini 复制代码

// 初始化场景
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer();
renderer.setSize(window.innerWidth, window.innerHeight);
document.body.appendChild(renderer.domElement);
// 创建绘图画布
const canvas = document.createElement('canvas');
const ctx = canvas.getContext('2d');
canvas.width = 512;
canvas.height = 512;
// 初始化画布为白色
ctx.fillStyle = '#fff';
ctx.fillRect(0, 0, canvas.width, canvas.height);
// 创建纹理
const texture = new THREE.CanvasTexture(canvas);
texture.needsUpdate = true;
// 创建球体
const geometry = new THREE.SphereGeometry(5, 64, 64);
const material = new THREE.MeshBasicMaterial({ map: texture });
const sphere = new THREE.Mesh(geometry, material);
scene.add(sphere);
camera.position.z = 15;
// 鼠标绘图功能
let isDrawing = false;
let lastX, lastY;
// 把鼠标坐标转换为画布坐标
function getCanvasCoords(clientX, clientY) {
  const rect = renderer.domElement.getBoundingClientRect();
  const x = ((clientX - rect.left) / rect.width) * 2 - 1;
  const y = -((clientY - rect.top) / rect.height) * 2 + 1;
  
  // 创建射线投射器检测与球体的交点
  const raycaster = new THREE.Raycaster();
  raycaster.setFromCamera({ x, y }, camera);
  const intersects = raycaster.intersectObject(sphere);
  
  if (intersects.length > 0) {
    // 获取交点的UV坐标
    const uv = intersects[0].uv;
    return {
      x: uv.x * canvas.width,
      y: (1 - uv.y) * canvas.height // 注意Y轴方向相反
    };
  }
  return null;
}
// 鼠标事件处理
renderer.domElement.addEventListener('mousedown', (e) => {
  isDrawing = true;
  const coords = getCanvasCoords(e.clientX, e.clientY);
  if (coords) {
    [lastX, lastY] = [coords.x, coords.y];
  }
});
renderer.domElement.addEventListener('mousemove', (e) => {
  if (isDrawing) {
    const coords = getCanvasCoords(e.clientX, e.clientY);
    if (coords) {
      // 在画布上绘制
      ctx.lineWidth = 5;
      ctx.strokeStyle = '#ff0000';
      ctx.lineCap = 'round';
      ctx.beginPath();
      ctx.moveTo(lastX, lastY);
      ctx.lineTo(coords.x, coords.y);
      ctx.stroke();
      
      // 更新纹理
      texture.needsUpdate = true;
      
      [lastX, lastY] = [coords.x, coords.y];
    }
  }
});
window.addEventListener('mouseup', () => { isDrawing = false; });
// 动画循环
function animate() {
  requestAnimationFrame(animate);
  sphere.rotation.y += 0.01;
  renderer.render(scene, camera);
}
animate();

这个例子中最精妙的部分是 UV 坐标与画布坐标的转换 ------ 我们就像在球体表面铺了一张可伸缩的画布，无论球体如何转动，我们画的每一笔都能准确地 "粘" 在对应的位置上。这背后是纹理坐标插值的数学魔法：GPU 会自动计算三角形每个像素对应的 UV 坐标，再从纹理中找到对应的像素颜色。

性能优化：像素的交通管制

虽然 canvas 纹理非常灵活，但它也有自己的脾气。就像城市交通需要管制一样，我们也需要合理管理像素的流动：

画布尺寸：尽量使用 2 的幂次方尺寸（如 256、512、1024），GPU 对这种尺寸的纹理处理效率更高

更新频率：避免每帧更新大尺寸纹理，这会造成带宽瓶颈

内存管理：不再使用的纹理要及时销毁（texture.dispose()），释放 GPU 内存

分辨率权衡：根据模型大小和观察距离选择合适的分辨率，远处的物体不需要高清纹理

想象一下，GPU 就像一个高速收费站，小而规则的纹理（2 的幂次方尺寸）能快速通过，而大而不规则的纹理则需要排队等待，影响整体通行效率。

结语：像素织匠的进阶之路

当你能用 canvas 纹理在 3D 世界中挥洒自如时，你已经从一个工具使用者成长为像素世界的织匠了。但记住，真正的大师不仅知道如何编织图案，更懂得像素背后的每一条物理法则。

下一次当你看到游戏中精致的皮肤、电影里逼真的布料时，不妨想想那些默默工作的纹理坐标，它们就像无数个看不见的锚点，将 2D 的像素牢牢固定在 3D 的世界里。而你，已经掌握了召唤这些锚点的咒语。

现在，拿起你的像素编织针，去创造属于自己的数字奇迹吧！画布就在那里，像素正等待着你的指挥 ------ 它们已经整装待发，只缺一位技艺精湛的织匠。