Cette page a été traduite par l'API Cloud Translation.

Nouveautés de WebGPU (Chrome 131)

François Beaufort

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 clip_distances intégré 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 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 indiqué 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 inclusive des analyses de toutes les invocations value actives du sous-groupe.
subgroupInclusiveMul(value) : renvoie la multiplication inclusive de l'analyse de toutes les invocations value actives du sous-groupe.

Prise en charge expérimentale du dessin indirect multiple

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 le flag "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. Cela signifie qu'elle est uniquement destinée à être utilisée 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.
Traitement de -0 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 });

Supprimer 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'avis de suppression.

Mises à jour de l'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 points clés. Consultez la liste exhaustive des commits.