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

No momento, as visualizações de textura da GPU herdam todas as flags de uso da textura da GPU de origem. Isso pode ser problemático, já que alguns formatos de visualização são incompatíveis com determinados usos. Para resolver esse problema, chamar createView() com o membro opcional usage permite especificar explicitamente um subconjunto das 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 de gráficos em que 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 a questão 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.
});

Fusão de texturas de ponto flutuante de 32 bits

Texturas de ponto flutuante de 32 bits são essenciais para a renderização HDR, preservando uma ampla variedade de valores de cores e evitando artefatos de bandas de cores. Por exemplo, na visualização científica.

O novo recurso de GPU "float32-blendable" permite a fusão de texturas de GPU com formatos "r32float", "rg32float" e "rgba32float". Agora é possível criar um pipeline de renderização que usa a combinação com qualquer anexo de 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 GPUDevice adapterInfo

É importante que as bibliotecas que usam objetos GPUDevice fornecidos pelo usuário acessem informações sobre a GPU física, já que talvez seja necessário 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 obtê-las apenas com um GPUDevice. Isso pode ser inconveniente, já que pode exigir que os usuários forneçam mais informações além do GPUDevice.

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

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.
  }
}

Configurar o contexto de tela com formato inválido gera um erro de JavaScript

Antes, usar um formato de textura inválido com o método configure() do contexto de tela do 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 de GPU válida, mesmo que o contexto de tela da GPU esteja configurado incorretamente. Para mais informações, consulte o problema 372837859.

Filtrar restrições de amostragem em texturas

Antes, era permitido usar "sint", "uint" e "depth" format textures with filtering samples. Agora, ele não permite o uso de uma textura de formato "sint" ou "uint" com um sampler de filtragem. No momento, ele emite um aviso se você usa uma textura "depth" com um amostrador de filtragem, já que isso será proibido no futuro. Consulte o problema 376497143.

Essas restrições significam que o uso de uma textura de profundidade com um sampler sem filtragem exige a criação manual de layouts de grupo de vinculação. Isso ocorre porque os layouts de grupo de vinculação gerados automaticamente ainda não são compatíveis com essa combinação. O problema de especificação 4952 contém uma proposta em consideração para resolver essa limitação no futuro.

Experimentos com subgrupos estendidos

O teste de subgrupos, inicialmente programado para terminar no Chrome 131, foi estendido para o Chrome 133, concluindo em 16 de abril de 2025. Embora o primeiro teste de origem tenha se concentrado na performance, ele não tinha proteções 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 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 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 por trás dos recursos de GPU "chromium-experimental-snorm16-texture-formats" e "chromium-experimental-unorm16-texture-formats" enquanto estão sendo 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 e RENDER_ATTACHMENT, além de recursos de multiamostragem e resolução. Os formatos adicionais são "r16unorm", "rg16unorm", "rgba16unorm", "r16snorm", "rg16snorm" e "rgba16snorm".

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

Confira 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 amanhecer

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 todos os char const * para uma estrutura WGPUStringView que define uma visualização em uma string codificada em UTF-8. Ele funciona como um ponteiro para os dados da string, junto com um comprimento. Isso permite trabalhar 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 commits.

Novidades no WebGPU

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

Chrome 140

Chrome 139

Chrome 138

Chrome 137

Chrome 136

Chrome 135

Chrome 134

Chrome 133

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