Se usó la API de Cloud Translation para traducir esta página.

Novedades de WebGPU (Chrome 132)

François Beaufort

Publicado: 8 de enero de 2025

Uso de la vista de textura

Actualmente, las vistas de texturas de GPU heredan todas las marcas de uso de su textura de GPU fuente. Esto puede ser problemático, ya que algunos formatos de vista son incompatibles con ciertos usos. Para solucionar este problema, llamar a createView() con el miembro opcional usage te permite especificar de forma explícita un subconjunto de las marcas de uso de la textura de origen que son compatibles con el formato de vista elegido.

Este cambio permite la validación por adelantado y un control más detallado sobre cómo se usa la vista. También se alinea con otras APIs de gráficos en las que las marcas de uso son parámetros comunes en la creación de vistas, lo que ofrece oportunidades de optimización.

Consulta el siguiente fragmento, la entrada de chromestatus y el problema 363903526.

const texture = myDevice.createTexture({
  size: [4, 4],
  format: "rgba8unorm",
  usage:
    GPUTextureUsage.RENDER_ATTACHMENT |
    GPUTextureUsage.TEXTURE_BINDING |
    GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ["rgba8unorm-srgb"],
});

const view = texture.createView({
  format: 'rgba8unorm-srgb',
  usage: GPUTextureUsage.RENDER_ATTACHMENT, // Restrict allowed usage.
});

Combinación de texturas de punto flotante de 32 bits

Las texturas de punto flotante de 32 bits son esenciales para la renderización HDR, ya que conservan una amplia gama de valores de color y evitan los artefactos de bandas de color. Por ejemplo, en la visualización científica.

La nueva función de GPU "float32-blendable" permite combinar texturas de GPU con los formatos "r32float", "rg32float" y "rgba32float". Ahora es posible crear una canalización de renderización que use la combinación con cualquier adjunto en formato float32 cuando se solicita un dispositivo de GPU con esta función.

Consulta el siguiente fragmento, la entrada de chromestatus y el problema 369649348.

const adapter = await navigator.gpu.requestAdapter();
if (!adapter.features.has("float32-blendable")) {
  throw new Error("32-bit float textures blending support is not available");
}
// Explicitly request 32-bit float textures blending support.
const device = await adapter.requestDevice({
  requiredFeatures: ["float32-blendable"],
});

// ... Creation of shader modules is omitted for readability.

// Create a render pipeline that uses blending for the rgba32float format.
device.createRenderPipeline({
  vertex: { module: myVertexShaderModule },
  fragment: {
    module: myFragmentShaderModule,
    targets: [
      {
        format: "rgba32float",
        blend: { color: {}, alpha: {} },
      },
    ],
  },
  layout: "auto",
});

// Create the GPU texture with rgba32float format and
// send the appropriate commands to the GPU...

Atributo `adapterInfo` de GPUDevice

Es importante que las bibliotecas que toman objetos GPUDevice proporcionados por el usuario accedan a información sobre la GPU física, ya que es posible que deban optimizar o implementar soluciones alternativas basadas en la arquitectura de la GPU. Si bien es posible acceder a esta información a través del objeto GPUAdapter, no hay una forma directa de obtenerla solo desde un GPUDevice. Esto puede ser inconveniente, ya que es posible que los usuarios deban proporcionar información adicional junto con el GPUDevice.

Para abordar este problema, ahora se expone GPUAdapterInfo a través del atributo adapterInfo de GPUDevice. Son similares al atributo info de GPUAdapter existente.

Consulta el siguiente fragmento, la entrada de ChromeStatus y el problema 376600838.

function optimizeForGpuDevice(device) {
  if (device.adapterInfo.vendor === "amd") {
    // Use AMD-specific optimizations.
  } else if (device.adapterInfo.architecture.includes("turing")) {
    // Optimize for NVIDIA Turing architecture.
  }
}

Se produce un error de JavaScript cuando se configura el contexto del lienzo con un formato no válido

Anteriormente, usar un formato de textura no válido con el método configure() del contexto del lienzo de la GPU generaba un error de validación de la GPU. Se cambió para que arroje un TypeError de JavaScript. Esto evita situaciones en las que getCurrentTexture() devuelve una textura de GPU válida a pesar de que el contexto del lienzo de la GPU esté configurado de forma incorrecta. Puedes encontrar más información en el problema 372837859.

Restricciones del muestreador de filtrado en texturas

Anteriormente, se permitía usar "sint", "uint" y texturas con formato "depth" con muestras de filtrado. Ahora, se prohíbe correctamente el uso de una textura de formato "sint" o "uint" con un muestreador de filtrado. Ten en cuenta que, actualmente, emite una advertencia si usas una textura "depth" con un muestreador de filtrado, ya que no se permitirá en el futuro. Consulta el problema 376497143.

Esas restricciones significan que usar una textura de profundidad con un muestreador sin filtrado requiere la creación manual de diseños de grupos de vinculación. Esto se debe a que los diseños de grupos de vinculación generados automáticamente aún no admiten esta combinación. El problema de especificación 4952 contiene una propuesta en consideración para abordar esta limitación en el futuro.

Experimentación con subgrupos extendidos

El experimento de subgrupos, que inicialmente se estableció para finalizar en Chrome 131, se extendió hasta Chrome 133 y concluirá el 16 de abril de 2025. Si bien la primera prueba de origen se centró en el rendimiento, carecía de protecciones de portabilidad cruciales. Ahora se agregarán estas protecciones, lo que podría causar errores en el código existente.

Mejora la experiencia de los desarrolladores

Ahora se muestra una advertencia en Herramientas para desarrolladores cuando se usa la opción powerPreference con requestAdapter() en Windows. Esta advertencia se quitará cuando Chrome sepa cómo usar dos GPUs diferentes y componer los resultados entre ellas. Consulta el problema 369219127.

El tamaño del búfer de la GPU ahora está presente en el mensaje de error cuando se crea un búfer de la GPU que es demasiado grande. Consulta el problema 374167798.

Compatibilidad experimental con formatos de texturas normalizadas de 16 bits

Los formatos de textura normalizados con signo de 16 bits y normalizados sin signo ahora están disponibles de forma experimental detrás de las funciones de GPU "chromium-experimental-snorm16-texture-formats" y "chromium-experimental-unorm16-texture-formats", respectivamente, mientras se analiza su estandarización.

Estas funciones agregan compatibilidad con formatos de texturas normalizadas de 16 bits con usos de COPY_SRC, COPY_DST, TEXTURE_BINDING y RENDER_ATTACHMENT, capacidades de resolución y muestreo múltiple. Los formatos adicionales son "r16unorm", "rg16unorm", "rgba16unorm", "r16snorm", "rg16snorm" y "rgba16snorm".

Hasta que estas funciones experimentales se estandaricen, habilita la función experimental "Unsafe WebGPU Support" en chrome://flags/#enable-unsafe-webgpu para que estén disponibles en Chrome.

Consulta el siguiente fragmento y el problema 374790898.

const adapter = await navigator.gpu.requestAdapter();
if (!adapter.features.has("chromium-experimental-snorm16-texture-formats")) {
  throw new Error("16-bit signed normalized formats support is not available");
}
// Explicitly request 16-bit signed normalized formats support.
const device = await adapter.requestDevice({
  requiredFeatures: ["chromium-experimental-snorm16-texture-formats"],
});

// Create a texture with the rgba16snorm format which consists of four
// components, each of which is a 16-bit, normalized, signed integer value.
const texture = device.createTexture({
  size: [4, 4],
  format: "rgba16snorm",
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});

// Send the appropriate commands to the GPU...

Actualizaciones de Dawn

Los métodos EnumerateFeatures(FeatureName * features) de wgpu::Adapter y wgpu::Device dejaron de estar disponibles y se recomienda usar GetFeatures(SupportedFeatures * features). Consulta el problema 368672123.

En la API de C de webgpu.h, se cambiaron todos los char const * a una estructura WGPUStringView que define una vista en una cadena codificada en UTF-8. Actúa como un puntero a los datos de la cadena, junto con una longitud. Esto te permite trabajar con partes de una cadena sin necesidad de copiarla. Consulta el problema 42241188.

Esto solo abarca algunos de los aspectos destacados clave. Consulta la lista exhaustiva de confirmaciones.