Novidades da WebGPU (Chrome 132)

François Beaufort
François Beaufort
GitHub

Publicado em 8 de janeiro de 2025

Uso da visualização de textura

As visualizações de textura da GPU atualmente herdam todas as flags de uso da textura de origem da GPU. Isso pode ser problemático, já que alguns formatos de visualização são incompatíveis com determinados usos. Para resolver esse problema, chame createView() com o membro opcional usage para especificar explicitamente um subconjunto dos flags de uso da textura de origem que são compatíveis com o formato de visualização escolhido.

Essa mudança permite a validação antecipada e um controle mais refinado sobre como a visualização é usada. Ela também se alinha a outras APIs gráficas em que os flags de uso são parâmetros comuns na criação de visualizações, oferecendo oportunidades de otimização.

Consulte o snippet a seguir, a entrada do chromestatus e o 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.
});

Mesclagem de texturas flutuantes de 32 bits

As texturas de ponto flutuante de 32 bits são essenciais para a renderização HDR preservar uma ampla gama de valores de cor e evitar artefatos de faixas de cor. Por exemplo, na visualização científica.

O novo recurso de GPU "float32-blendable" permite mesclar texturas de GPU com formatos "r32float", "rg32float" e "rgba32float". Agora é possível criar um pipeline de renderização que usa mesclagem com qualquer anexo no formato float32 ao solicitar um dispositivo de GPU com esse recurso.

Consulte o snippet a seguir, a entrada do chromestatus e o 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 do GPUDevice

É importante que as bibliotecas que usam objetos GPUDevice fornecidos pelo usuário acessem informações sobre a GPU física, porque elas podem precisar otimizar ou implementar soluções alternativas com base na arquitetura da GPU. Embora seja possível acessar essas informações pelo objeto GPUAdapter, não há uma maneira direta de acessá-las apenas com um GPUDevice. Isso pode ser inconveniente, já que pode exigir que os usuários forneçam informações adicionais junto com o GPUDevice.

Para resolver esse problema, o GPUAdapterInfo agora é exposto pelo atributo GPUDevice adapterInfo. Eles são semelhantes ao atributo GPUAdapter info.

Consulte o snippet a seguir, a entrada do chromestatus e o 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.
  }
}

A configuração do contexto da tela com um formato inválido gera um erro JavaScript

Anteriormente, o uso de um formato de textura inválido com o método configure() do contexto da tela da GPU resultava em um erro de validação da GPU. Isso foi alterado para gerar um TypeError do JavaScript. Isso evita cenários em que getCurrentTexture() retorna uma textura válida da GPU, mesmo que o contexto da tela da GPU esteja configurado incorretamente. Para mais informações, consulte o problema 372837859.

Filtrar restrições de amostragem em texturas

Anteriormente, era permitido usar "sint", "uint" e "depth"" para formatar texturas com amostras de filtragem. Agora, o uso de uma textura de formato "sint" ou "uint" com um amostrador de filtragem não é mais permitido. No momento, ele emite um aviso se você usar uma textura "depth" com um amostrador de filtragem, porque isso não será permitido no futuro. Consulte o problema 376497143.

Essas restrições significam que o uso de uma textura de profundidade com um sampler sem filtragem requer a criação manual de layouts de grupo de vinculação. Isso ocorre porque os layouts de grupo de vinculação gerados de forma "automática" ainda não oferecem suporte a essa combinação. O Problema de especificação 4952 contém uma proposta em análise para resolver essa limitação no futuro.

Experimentação de subgrupos estendida

A experimentação de subgrupos, inicialmente programada para terminar no Chrome 131, foi estendida para o Chrome 133 e vai ser concluída em 16 de abril de 2025. Embora o primeiro teste de origem tenha se concentrado na performance, ele não tinha garantias de portabilidade essenciais. Essas proteções serão adicionadas, o que pode causar erros no código atual.

Melhorar a experiência do desenvolvedor

Agora, um aviso aparece no DevTools quando a opção powerPreference é usada com requestAdapter() no Windows. Esse aviso será removido quando o Chrome souber como usar duas GPUs diferentes e combinar os resultados entre elas. Consulte o problema 369219127.

O tamanho do buffer da GPU agora está presente na mensagem de erro ao criar um buffer da GPU muito grande. Consulte o problema 374167798.

Suporte experimental para formatos de textura normalizados de 16 bits

Os formatos de textura normalizados assinados e não assinados de 16 bits agora estão disponíveis experimentalmente, respectivamente, nos recursos da GPU "chromium-experimental-snorm16-texture-formats" e "chromium-experimental-unorm16-texture-formats", enquanto são discutidos para padronização.

Esses recursos adicionam suporte a formatos de textura normalizados de 16 bits com usos de COPY_SRC, COPY_DST, TEXTURE_BINDING, RENDER_ATTACHMENT, multiamostragem e recursos de resolução. Os formatos adicionais são "r16unorm", "rg16unorm", "rgba16unorm", "r16snorm", "rg16snorm" e "rgba16snorm".

Até que esses recursos experimentais sejam padronizados, ative a flag "Unsafe WebGPU Support" em chrome://flags/#enable-unsafe-webgpu para disponibilizá-los no Chrome.

Consulte o snippet a seguir e o 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...

Atualizações do Dawn

Os métodos EnumerateFeatures(FeatureName * features) de wgpu::Adapter e wgpu::Device foram descontinuados em favor do uso de GetFeatures(SupportedFeatures * features). Consulte o problema 368672123.

A API C webgpu.h mudou todas as char const * para uma estrutura WGPUStringView que define uma visualização em uma string codificada em UTF-8. Ele atua como um ponteiro para os dados da string, associado a um comprimento. Isso permite que você trabalhe com partes de uma string sem precisar copiá-la. Consulte o problema 42241188.

Isso abrange apenas alguns dos principais destaques. Confira a lista completa de confirmações.

Novidades na WebGPU

Uma lista de tudo o que foi abordado na série O que há de novo na WebGPU.

Chrome 132

Chrome 131

Chrome 130

Chrome 129

Chrome 128

Chrome 127

Chrome 126

Chrome 125

Chrome 124

Chrome 123

Chrome 122

Chrome 121

Chrome 120

Chrome 119

Chrome 118

Chrome 117

Chrome 116

Chrome 115

Chrome 114

Chrome 113