使用 javascript 检测设备 CPU/GPU 性能？

Question

（这个问题不是针对 three.js 的，但我会以它为例）

我最近一直在使用 three.js 开发 web 应用程序界面，并在 WebGL 和 Canvas 渲染器（用于桌面浏览器）之间编写了一些不错的后备。

但是现在问题变成了如何正确检测设备能力，问题有两个方面：

1. 浏览器功能（静态功能，如 webgl/canvas）：这在 web 社区中使用简单的功能检测在很大程度上得到了解决。
2. 设备能力：这是困难的部分，如果不能直接访问设备的硬件信息，我们需要一些方法来判断我们是否应该回退到对硬件要求较低的代码。

一个值得注意的例子：Firefox 移动/Opera 移动声称支持 WebGL，但存在错误或受设备硬件限制。

到目前为止，我提出了一些解决方法：

1. 使用通用功能作为性能指标- 例如，触摸设备通常具有不太强大的硬件。 缺点：它不是面向未来的。
2. 黑名单已知有问题的浏览器/设备- UA 嗅探将是不可避免的，并且可能难以维护。
3. 性能测试——因此问题是，除了运行代码和测量帧率之外，还有更好的选择吗？

或者也许它不必这么难，还有其他建议吗？

Answer 1

我最终在一个项目中使用了性能测量方法，我们希望利用高规格CPU / GPU桌面上的画布功能，以及桌面和手机等低速设备。

基本上我们从最小的场景复杂度开始，如果renderloop花费不到33ms，我们就增加了复杂性（如果renderloop以后开始花费太长时间，我们也会降低复杂性）。

我想在您的情况下，您可能需要运行快速画布和webgl性能测试，然后选择一个。 花了一些时间研究这个我没有遇到一些棘手的非显而易见的技术，可以更好地解决这个问题。

Answer 2

您可以使用http://webglstats.com/进行WebGL硬件支持和功能检测。

Answer 3

如果您使用three.js，您可以使用detector.js来查明是否启用了webgl。 也远离canvasrenderer将有所帮助。 使用webglrenderer或softwarerender。 因为它们允许更多顶点。 softwarerender相当新，需要一些工作但可以使用。

Answer 4

这是我使用 three.js 写给基准 webgl 的代码片段：

import {
  Mesh,
  MeshStandardMaterial,
  PerspectiveCamera,
  Scene,
  SphereGeometry,
  WebGLRenderer,
} from "three";

function sleep(ms: number) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

export enum GPUPerformanceLevel {
  HIGH = "HIGH",
  LOW = "LOW",
}

/**
 * Three.js based webgl benchmark
 *
 * In summary, the `run` method adds `meshPerStep` new spheres every step (frame)
 * and measures the fps. If we're able to perform >=`thresholds.steps` of these
 * steps, without the fps dropping below `thresholds.fps`, then we label the device
 * `GPUPerformanceLevel.HIGH`.
 */
export class GPUBenchmark {
  scene = new Scene();
  material = new MeshStandardMaterial();
  geometry = new SphereGeometry();

  static thresholds = { fps: 10, steps: 40 };
  static meshPerStep = 1000;

  async run(debug = false): Promise<GPUPerformanceLevel> {
    const camera = new PerspectiveCamera(75);
    const renderer = new WebGLRenderer();

    let tPrev = performance.now() / 1000;
    let steps = 0;

    let passedThreshold = false;

    const animate = async () => {
      const time = performance.now() / 1000;
      const fps = 1 / (time - tPrev);
      tPrev = time;

      if (debug) {
        console.log(`fps: ${fps} steps: ${steps}`);
      }

      if (
        fps > GPUBenchmark.thresholds.fps &&
        steps < GPUBenchmark.thresholds.steps
      ) {
        requestAnimationFrame(animate);

        this.step();
        steps++;
        renderer.render(this.scene, camera);
      } else {
        passedThreshold = true;
      }
    };

    animate();

    while (!passedThreshold) {
      await sleep(1);
    }

    this.cleanup();
    const level = GPUBenchmark.stepsToPerfLevel(steps);

    if (debug) {
      console.log("device benchmarked at level:", level);
    }

    return level;
  }

  private step() {
    for (let i = 0; i < GPUBenchmark.meshPerStep; i++) {
      const sphere = new Mesh(this.geometry, this.material);
      sphere.frustumCulled = false;

      this.scene.add(sphere);
    }
  }

  private cleanup() {
    for (const obj of this.scene.children) {
      this.scene.remove(obj);
    }

    //@ts-ignore
    this.scene = null;

    this.material.dispose();
    this.geometry.dispose();

    //@ts-ignore
    this.material = null;
    //@ts-ignore
    this.geometry = null;
  }

  private static stepsToPerfLevel(numSteps: number): GPUPerformanceLevel {
    if (numSteps >= GPUBenchmark.thresholds.steps) {
      return GPUPerformanceLevel.HIGH;
    } else {
      return GPUPerformanceLevel.LOW;
    }
  }
}