Novidades da WebGPU (Chrome 119)

François Beaufort
François Beaufort
GitHub

Texturas flutuantes de 32 bits com filtro

As texturas de ponto flutuante de 32 bits são usadas para armazenar dados de alta precisão, como imagens HDR e mapas de profundidade. Elas são especialmente importantes para GPUs usadas em jogos e aplicativos profissionais de última geração.

O suporte a texturas de ponto flutuante de 32 bits com filtro descreve a capacidade de uma GPU de filtrar texturas de ponto flutuante de 32 bits. Isso significa que a GPU pode suavizar as bordas das texturas de ponto flutuante, fazendo com que elas pareçam menos irregulares. Ela é semelhante à extensão "OES_texture_float_linear" no WebGL.

Nem todas as GPUs oferecem suporte a texturas flutuantes filtráveis de 32 bits. Quando o recurso "float32-filterable" está disponível em um GPUAdapter, agora você pode solicitar um GPUDevice com esse recurso e filtrar texturas com os formatos "r32float", "rg32float" e " rgba32float". Confira o exemplo a seguir e issue dawn:1664.

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

// Create a sampler with linear filtering.
const sampler = device.createSampler({
  magFilter: "linear",
});

// Create a texture with rgba32float format.
const texture = device.createTexture({
  size: [100, 100],
  format: "rgba32float",
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});

// Write data to texture, create a bindgroup with sampler and texture and
// send the appropriate commands to the GPU....

Formato de vértice unorm10-10-10-2

Um novo formato de vértice chamado "unorm10-10-10-2", também conhecido como " rgb10a2 ", foi adicionado à especificação WebGPU. Ele consiste em um valor de 32 bits compactado com quatro valores inteiros não assinados normalizados, organizados como 10 bits, 10 bits, 10 bits e 2 bits. Confira o exemplo a seguir e o problema dawn:2044 (link em inglês).

// Define the layout of vertex attribute data with unorm10-10-10-2 format.
const buffers = [
  {
    arrayStride: 0,
    attributes: [
      { format: "unorm10-10-10-2", offset: 0, shaderLocation: 0 },
    ],
  },
];

// Describe the vertex shader entry point and its input buffer layouts.
const vertex = {
  module: myVertexShaderModule,
  entryPoint: "main",
  buffers,
};

// Pass vertex to device.createRenderPipeline() and
// use vec4<f32> type in WGSL shader code to manipulate data.

formato de textura rgb10a2uint

Um novo formato de textura chamado "rgb10a2uint" foi adicionado à especificação da WebGPU. Ele consiste em um formato de pixel empacotado de 32 bits com quatro componentes inteiros não assinados: vermelho de 10 bits, verde de 10 bits, azul de 10 bits e alfa de 2 bits. Confira o exemplo a seguir e o problema dawn:1936 (link em inglês).

// Create a texture with rgb10a2uint format.
const texture = device.createTexture({
  size: [100, 100],
  format: "rgb10a2uint",
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
});

// Write data to texture, create a bindgroup with texture and
// send the appropriate commands to the GPU....

Atualizações do amanhecer

As consultas de carimbo de data/hora permitem que os aplicativos da WebGPU meçam com precisão (até o nanossegundo) o tempo que os comandos da GPU levam para ser executados. A forma da API para capturar consultas de carimbos de data/hora no início e no fim dos passes foi atualizada para corresponder à especificação da WebGPU. Confira o exemplo a seguir e solução dawn:1800.

// Create a timestamp query set that will store the timestamp values.
wgpu::QuerySetDescriptor querySetDescriptor = {
    .count = 2,
    .type = wgpu::QueryType::Timestamp};
wgpu::QuerySet querySet = device.CreateQuerySet(&querySetDescriptor);

wgpu::RenderPassTimestampWrites timestampWrites = {
    .querySet = querySet,
    .beginningOfPassWriteIndex = 0,
    .endOfPassWriteIndex = 1};
wgpu::ComputePassDescriptor pass{.timestampWrites = &timestampWrites};

// Write the queue timestamp into beginningOfPassWriteIndex and
// endOfPassWriteIndex of myQuerySet respectively before and after the pass
// commands execute.
myEncoder.BeginComputePass(&pass);

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