Canvas 大规模渲染优化

核心原则

Canvas 的瓶颈不是「画多少」，而是「每帧画多少」。

分离静态和动态元素，只重绘变化的部分。

三层渲染管线

Layer 1: 静态层 (OffscreenCanvas)

class StaticLayer {
  private canvas: OffscreenCanvas;
  private ctx: OffscreenCanvasRenderingContext2D;
  private dirty = true;

  constructor(width: number, height: number) {
    this.canvas = new OffscreenCanvas(width, height);
    this.ctx = this.canvas.getContext('2d')!;
  }

  render(items: StaticItem[]) {
    if (!this.dirty) return;
    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
    items.forEach(item => this.drawItem(item));
    this.dirty = false;
  }

  // 数据变化时调用
  invalidate() { this.dirty = true; }

  // 合成到主画布
  composite(target: CanvasRenderingContext2D) {
    target.drawImage(this.canvas, 0, 0);
  }
}

⚠️ 兼容性：Safari 16.4+ 才支持 OffscreenCanvas，需要 fallback：

const useOffscreen = typeof OffscreenCanvas !== 'undefined';
const canvas = useOffscreen ? new OffscreenCanvas(w, h) : document.createElement('canvas');

Layer 2: 动态层 (脏矩形追踪)

class DynamicLayer {
  private dirtyRects: Set\x3Cstring> = new Set();
  private minRectSize = 64; // 最小合并阈值

  markDirty(x: number, y: number, w: number, h: number) {
    // 合并小矩形，避免碎片段过多
    const rx = Math.floor(x / this.minRectSize);
    const ry = Math.floor(y / this.minRectSize);
    this.dirtyRects.add(`${rx},${ry}`);
  }

  render(ctx: CanvasRenderingContext2D, marks: DynamicItem[]) {
    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
    marks.forEach(mark => {
      this.drawMark(ctx, mark);
    });
    this.dirtyRects.clear();
  }
}

Layer 3: UI 叠加层

// tooltip、坐标轴、图例等，独立 Canvas 或在主 Canvas 上最后绘制
function renderOverlay(ctx: CanvasRenderingContext2D, ui: UIState) {
  if (ui.tooltip) drawTooltip(ctx, ui.tooltip);
  if (ui.selection) drawSelection(ctx, ui.selection);
  drawAxes(ctx);
  drawLegend(ctx);
}

空间哈希视口裁剪

draw calls 从 O(n) 降到 O(visible)

class SpatialGrid {
  private grid = new Map\x3Cstring, T[]>();
  private cellSize: number;

  constructor(items: T[], cellSize: number) {
    this.cellSize = cellSize;
    items.forEach(item => {
      const key = `${Math.floor(item.x / cellSize)},${Math.floor(item.y / cellSize)}`;
      if (!this.grid.has(key)) this.grid.set(key, []);
      this.grid.get(key)!.push(item);
    });
  }

  // 只返回视口内的元素
  query(viewport: Rect): T[] {
    const result: T[] = [];
    const startX = Math.floor(viewport.x / this.cellSize);
    const endX = Math.ceil((viewport.x + viewport.w) / this.cellSize);
    const startY = Math.floor(viewport.y / this.cellSize);
    const endY = Math.ceil((viewport.y + viewport.h) / this.cellSize);

    for (let x = startX; x \x3C= endX; x++) {
      for (let y = startY; y \x3C= endY; y++) {
        const items = this.grid.get(`${x},${y}`);
        if (items) result.push(...items);
      }
    }
    return result;
  }
}

LOD (细节层次)

function getLOD(zoom: number): 'full' | 'simple' | 'block' {
  if (zoom >= 2) return 'full';      // 完整绘制含边框
  if (zoom >= 0.5) return 'simple';  // 纯色块无边框
  return 'block';                     // 合并为区域色块
}

帧调度

class FrameScheduler {
  private rafId: number | null = null;
  private lastTime = 0;
  private targetFPS = 60;
  private frameInterval = 1000 / 60;

  start(loop: (dt: number) => void) {
    const tick = (time: number) => {
      this.rafId = requestAnimationFrame(tick);
      const dt = time - this.lastTime;
      if (dt \x3C this.frameInterval) return; // 帧率限制
      this.lastTime = time - (dt % this.frameInterval);
      loop(dt);
    };
    this.rafId = requestAnimationFrame(tick);
  }

  stop() {
    if (this.rafId) cancelAnimationFrame(this.rafId);
  }
}

完整组合

class WaferMapRenderer {
  private staticLayer: StaticLayer;
  private dynamicLayer: DynamicLayer;
  private spatialGrid: SpatialGrid;
  private scheduler: FrameScheduler;

  constructor(canvas: HTMLCanvasElement, dies: DieData[]) {
    this.staticLayer = new StaticLayer(canvas.width, canvas.height);
    this.dynamicLayer = new DynamicLayer();
    this.spatialGrid = new SpatialGrid(dies, DIE_SIZE);
    this.scheduler = new FrameScheduler();

    this.staticLayer.render(dies);
    this.scheduler.start(() => this.frame());
  }

  private frame() {
    const ctx = this.mainCanvas.getContext('2d')!;
    ctx.clearRect(0, 0, this.mainCanvas.width, this.mainCanvas.height);

    // Layer 1: 合成静态层
    this.staticLayer.composite(ctx);

    // Layer 2: 只画视口内的动态元素
    const visible = this.spatialGrid.query(this.viewport);
    this.dynamicLayer.render(ctx, visible.filter(isDynamic));

    // Layer 3: UI
    renderOverlay(ctx, this.uiState);
  }
}

实测数据

适用场景

• 晶圆图 (WaferMap) 可视化
• 热力图 / 散点图
• 地图标注点
• 甘特图 / 时间线
• 大型 Canvas 表格

一句话总结

分层、裁剪、按需重绘 — draw calls O(n) → O(visible)。