Nouveautés de WebGPU (Chrome 131)

François Beaufort
François Beaufort
GitHub

Distances de clipping dans WGSL

Les distances de clipping vous permettent de limiter le volume de clipping des primitives avec des demi-espaces définis par l'utilisateur dans la sortie de l'étape des vertex. Définir vos propres plans de clipping vous permet de mieux contrôler ce qui est visible dans vos scènes WebGPU. Cette technique est particulièrement utile pour les applications telles que les logiciels de CAO, où un contrôle précis de la visualisation est essentiel.

Lorsque la fonctionnalité "clip-distances" est disponible dans un GPUAdapter, demandez un GPUDevice avec cette fonctionnalité pour obtenir la prise en charge des distances de clipping dans WGSL, et activez explicitement cette extension dans votre code WGSL avec enable clip_distances;. Une fois activé, vous pouvez utiliser le tableau intégré clip_distances dans votre nuanceur de vertex. Ce tableau contient les distances par rapport à un plan de clipping défini par l'utilisateur :

  • Une distance de clipping de 0 signifie que le sommet se trouve sur le plan.
  • Une distance positive signifie que le sommet se trouve à l'intérieur du demi-espace de clipping (le côté que vous souhaitez conserver).
  • Une distance négative signifie que le sommet se trouve en dehors du demi-espace de clipping (le côté que vous souhaitez supprimer).

Consultez l'extrait de code suivant, l'entrée Chromestatus et le problème 358408571.

const adapter = await navigator.gpu.requestAdapter();
if (!adapter.features.has("clip-distances")) {
  throw new Error("Clip distances support is not available");
}
// Explicitly request clip distances support.
const device = await adapter.requestDevice({
  requiredFeatures: ["clip-distances"],
});

const vertexShaderModule = device.createShaderModule({ code: `
  enable clip_distances;

  struct VertexOut {
    @builtin(clip_distances) my_clip_distances : array<f32, 1>,
    @builtin(position) my_position : vec4f,
  }
  @vertex fn main() -> VertexOut {
    var output : VertexOut;
    output.my_clip_distances[0] = 1;
    output.my_position = vec4f(0, 0, 0, 1);
    return output;
  }
`,
});

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

GPUCanvasContext getConfiguration()

Une fois que GPUCanvasContext configure() a été appelé avec un dictionnaire de configuration, la méthode GPUCanvasContext getConfiguration() vous permet de vérifier la configuration du contexte du canevas. Il inclut les membres device, format, usage, viewFormats, colorSpace, toneMapping et alphaMode. Cela est utile pour des tâches telles que la vérification de la compatibilité du navigateur avec le canevas HDR, comme illustré dans l'exemple de particules (HDR). Consultez l'extrait suivant, l'entrée chromestatus et le problème 370109829.

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const canvas = document.querySelector("canvas");
const context = canvas.getContext("webgpu");

// Configure the canvas for HDR.
context.configure({
  device,
  format: "rgba16float",
  toneMapping: { mode: "extended" },
});

const configuration = context.getConfiguration();
if (configuration.toneMapping.mode === "extended") {
  // The browser supports HDR canvas.
  // Warning! The user still needs a HDR display to enjoy HDR content.
}

Les primitives de points et de lignes ne doivent pas avoir de biais de profondeur.

Comme annoncé précédemment, la spécification WebGPU considère désormais comme une erreur de validation le fait de définir depthBias, depthBiasSlopeScale et depthBiasClamp sur une valeur non nulle lorsque la topologie d'un pipeline de rendu est de type ligne ou point. Consultez le problème 352567424.

Fonctions intégrées d'analyse inclusive pour les sous-groupes

Dans le cadre de l'expérimentation sur les sous-groupes, les fonctions intégrées de sous-groupe suivantes ont été ajoutées dans l'issue 361330160 :

  • subgroupInclusiveAdd(value) : renvoie la somme des analyses inclusives de toutes les invocations value actives du sous-groupe.
  • subgroupInclusiveMul(value) : renvoie la multiplication du scan inclusif de toutes les invocations value actives du sous-groupe.

Prise en charge expérimentale de multi-draw indirect

La fonctionnalité GPU de dessin indirect multiple vous permet d'émettre plusieurs appels de dessin avec une seule commande GPU. Cela est particulièrement utile dans les situations où un grand nombre d'objets doivent être rendus, comme les systèmes de particules, l'instanciation et les grandes scènes. Les méthodes drawIndirect() et drawIndexedIndirect() de GPURenderPassEncoder ne peuvent émettre qu'un seul appel de dessin à la fois à partir d'une certaine région d'un tampon GPU.

En attendant que cette fonctionnalité expérimentale soit normalisée, activez l'indicateur "Unsafe WebGPU Support" (Prise en charge non sécurisée de WebGPU) sur chrome://flags/#enable-unsafe-webgpu pour la rendre disponible dans Chrome.

Avec la fonctionnalité GPU non standard "chromium-experimental-multi-draw-indirect" disponible dans un GPUAdapter, demandez un GPUDevice avec cette fonctionnalité. Créez ensuite un GPUBuffer avec l'utilisation GPUBufferUsage.INDIRECT pour stocker les appels de dessin. Vous pourrez l'utiliser ultérieurement dans les nouvelles méthodes multiDrawIndirect() et multiDrawIndexedIndirect() GPURenderPassEncoder pour émettre des appels de dessin dans un pass de rendu. Consultez l'extrait suivant et le problème 356461286.

const adapter = await navigator.gpu.requestAdapter();
if (!adapter.features.has("chromium-experimental-multi-draw-indirect")) {
  throw new Error("Experimental multi-draw indirect support is not available");
}
// Explicitly request experimental multi-draw indirect support.
const device = await adapter.requestDevice({
  requiredFeatures: ["chromium-experimental-multi-draw-indirect"],
});

// Draw call have vertexCount, instanceCount, firstVertex, and firstInstance parameters.
const drawData = new Uint32Array([
  3, 1, 0, 0, // First draw call
  3, 1, 3, 0, // Second draw call
]);
// Create a buffer to store the draw calls.
const drawBuffer = device.createBuffer({
  size: drawData.byteLength,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_DST,
});
device.queue.writeBuffer(drawBuffer, 0, drawData);

// Create a render pipeline, a vertex buffer, and a render pass encoder...

// Inside a render pass, issue the draw calls.
myPassEncoder.setPipeline(myPipeline);
myPassEncoder.setVertexBuffer(0, myVertexBuffer);
myPassEncoder.multiDrawIndirect(drawBuffer, /*offset=*/ 0, /*maxDrawCount=*/ 2);
myPassEncoder.end();

Option de compilation du module de nuanceur "strict math"

Une option pour les développeurs booléenne strictMath a été ajoutée à GPUShaderModuleDescriptor pour vous permettre d'activer ou de désactiver les calculs stricts lors de la compilation du module de nuanceur. Elle est disponible derrière le flag "WebGPU Developer Features" (Fonctionnalités pour les développeurs WebGPU) sur chrome://flags/#enable-webgpu-developer-features, ce qui signifie qu'il s'agit d'une fonctionnalité destinée à être utilisée uniquement pendant le développement. Consultez le problème 42241455.

Cette option est actuellement compatible avec Metal et Direct3D. Lorsque le mode mathématique strict est désactivé, le compilateur peut optimiser vos nuanceurs en :

  • en ignorant la possibilité de valeurs NaN et Infinity.
  • -0 est traité comme +0.
  • Remplacer la division par une multiplication plus rapide par l'inverse.
  • Réorganiser les opérations en fonction des propriétés associatives et distributives.
const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const code = `
  // Examines the bit pattern of the floating-point number to
  // determine if it represents a NaN according to the IEEE 754 standard.
  fn isNan(x : f32) -> bool {
    bool ones_exp = (bitcast<u32>(x) & 0x7f8) == 0x7f8;
    bool non_zero_sig = (bitcast<u32>(x) & 0x7ffff) != 0;
    return ones_exp && non_zero_sig;
  }
  // ...
`;

// Enable strict math during shader compilation.
const shaderModule = device.createShaderModule({ code, strictMath: true });

Suppression de GPUAdapter requestAdapterInfo()

La méthode asynchrone requestAdapterInfo() de GPUAdapter est redondante, car vous pouvez déjà obtenir GPUAdapterInfo de manière synchrone à l'aide de l'attribut info de GPUAdapter. Par conséquent, la méthode requestAdapterInfo() non standard de GPUAdapter est désormais supprimée. Consultez l'intention de suppression.

Nouveautés de l'application Aube

L'exécutable tint_benchmark mesure le coût de la traduction des nuanceurs de WGSL vers chaque langage de backend. Pour en savoir plus, consultez la nouvelle documentation.

Il ne s'agit que de quelques-uns des principaux points à retenir. Consultez la liste exhaustive des commits.

Nouveautés de WebGPU

Liste de tous les sujets abordés dans la série Nouveautés de WebGPU.

Chrome 155-156

Chrome 153-154

Chrome 151-152

Chrome 149-150

Chrome 147-148

Chrome 146

Chrome 145

Chrome 144

Chrome 143

Chrome 142

Chrome 141

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