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

Novedades de WebGPU (Chrome 132)

François Beaufort

Fecha de publicación: 8 de enero de 2025

Uso de la vista de textura

Actualmente, las vistas de textura de la GPU heredan todas las marcas de uso de su textura de GPU de origen. Esto puede ser problemático, ya que algunos formatos de vista no son compatibles con ciertos usos. Para solucionar este problema, llamar a createView() con el miembro opcional usage te permite especificar explícitamente un subconjunto de las marcas de uso de la textura de origen que sean 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 que la renderización HDR conserve un amplio rango de valores de color y evite 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 archivo 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 según 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, GPUAdapterInfo ahora se expone a través del atributo GPUDevice adapterInfo. Son similares al atributo info 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.
  }
}

La configuración del contexto del lienzo con un formato no válido arroja un error de JavaScript.

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 lanzar un TypeError de JavaScript. Esto evita situaciones en las que getCurrentTexture() muestra 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 de filtro de muestras en texturas

Anteriormente, se permitía usar texturas de formato "sint", "uint" y "depth" con muestras de filtrado. Ahora, no se permite usar una textura de formato "sint" o "uint" con un muestreador de filtrado. Ten en cuenta que, actualmente, se 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 implican 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 de subgrupos extendida

La experimentación de subgrupos, que inicialmente debía 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 enfocó en el rendimiento, carecía de garantías de portabilidad cruciales. 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 DevTools 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 combinar 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 demasiado grande. Consulta el problema 374167798.

Compatibilidad experimental con formatos de textura normalizados de 16 bits

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

Estas funciones agregan compatibilidad con formatos de textura normalizados de 16 bits con usos de COPY_SRC, COPY_DST, TEXTURE_BINDING, RENDER_ATTACHMENT, multimuestreo y capacidades de resolución. Los formatos adicionales son "r16unorm", "rg16unorm", "rgba16unorm", "r16snorm", "rg16snorm" y "rgba16snorm".

Hasta que se estandaricen estas funciones experimentales, habilita la marca "Compatibilidad no segura con WebGPU" 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 los reemplazó por GetFeatures(SupportedFeatures * features). Consulta el problema 368672123.

La API de C webgpu.h cambió 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 más destacados. Consulta la lista exhaustiva de confirmaciones.