GPUSupportedFeatures

Limited availability

This feature is not Baseline because it does not work in some of the most widely-used browsers.

Sicherer Kontext: Diese Funktion ist nur in sicheren Kontexten (HTTPS) in einigen oder allen unterstützenden Browsern verfügbar.

Hinweis: Diese Funktion ist in Web Workers verfügbar.

Das GPUSupportedFeatures-Interface der WebGPU API ist ein set-ähnliches Objekt, das zusätzliche Funktionalitäten beschreibt, die von einem GPUAdapter unterstützt werden.

Das GPUSupportedFeatures-Objekt für den aktuellen Adapter kann über die GPUAdapter.features-Eigenschaft abgerufen werden — verwenden Sie dies, um zu testen, welche Features Ihre aktuelle Konfiguration unterstützt. Um ein GPUDevice mit einem bestimmten aktivierten Feature zu erstellen, müssen Sie dieses im requiredFeatures-Array des GPUAdapter.requestDevice()-Deskriptors angeben.

Sie sollten beachten, dass nicht alle Funktionen in allen Browsern, die WebGPU unterstützen, verfügbar sein werden, selbst wenn die Funktionen von der zugrunde liegenden Hardware unterstützt werden. Dies könnte auf Einschränkungen im zugrunde liegenden System, Browser oder Adapter zurückzuführen sein. Beispielsweise:

Das zugrunde liegende System kann möglicherweise die Bereitstellung eines Features nicht auf eine Weise garantieren, die mit einem bestimmten Browser kompatibel ist.
Der Browserhersteller hat möglicherweise keine sichere Möglichkeit gefunden, die Unterstützung für dieses Feature zu implementieren, oder hat schlichtweg noch keine Zeit dafür gefunden.

Wenn Sie hoffen, ein bestimmtes zusätzliches Feature in einer WebGPU-Anwendung zu nutzen, wird gründliches Testen empfohlen.

Verfügbare Features

Die folgenden zusätzlichen Features sind in WebGPU definiert. Beachten Sie, dass der genaue Umfang der verfügbaren Features je nach Implementierung und physischer Geräte variieren und sich im Laufe der Zeit ändern wird.

Feature-Name	Beschreibung
`bgra8unorm-storage`	Wenn aktiviert, erlaubt es `STORAGE_BINDING` `usage` von `bgra8unorm`-`format`-`GPUTexture`s.
`clip-distances`	Wenn aktiviert, erlaubt es die Nutzung von `clip_distances` in WGSL.
`core-features-and-limits`	Wenn aktiviert, bedeutet dies, dass der `GPUAdapter` / `GPUDevice` in der Lage ist, alle Kern-WebGPU-Features und -Grenzen zu verwenden. Dies ermöglicht Anwendungen die Unterstützung von Geräten mit den Grafik-APIs Direct 3D 12, Metal und Vulkan (beachten Sie, dass Safari nur Metal unterstützt). Dies wird auch als "Kern" WebGPU bezeichnet. Derzeit sind alle Adapter mit "Kern" WebGPU ausgestattet und es wird automatisch auf allen Geräten aktiviert, selbst wenn es nicht angefordert wurde. Dieses Feature ermöglicht es Adaptern und Geräten, zwischen "Kern" WebGPU und "Kompatibilitätsmodus" zu unterscheiden, der Unterstützung für ältere Grafik-APIs (wie Direct 3D 11 und OpenGL ES) auf Kosten von Leistung und Funktionsumfang bieten wird.
`depth-clip-control`	Wenn aktiviert, erlaubt es, Tiefen-Clipping zu deaktivieren. Wenn `depth-clip-control` aktiviert ist, steht die `unclippedDepth`-Eigenschaft im `primitive`-Objekt zur Verfügung, das Teil des `createRenderPipeline()`- oder `createRenderPipelineAsync()`-Deskriptors ist, wenn ein `GPURenderPipeline` erstellt wird. `primitive` beschreibt, wie eine Pipeline Primitiven aus ihren Vertex-Eingaben konstruiert und rasterisiert. Setzen Sie `unclipped-depth` auf `true`, um Tiefen-Clipping zu deaktivieren.
`depth32float-stencil8`	Wenn aktiviert, erlaubt es die Erstellung von Texturen mit dem Format `depth32float-stencil8`. Wenn `depth32float-stencil8` aktiviert ist, kann der Wert `depth32float-stencil8` für die `format`-Eigenschaft des `createTexture()`-Deskriptors beim Erstellen einer `GPUTexture` verwendet werden.
`dual-source-blending`	Wenn aktiviert, ermöglicht es die Nutzung von `dual_source_blending` in WGSL, welches sowohl Pixelergebnisausgaben (`@blend_src(0)` und `@blend_src(1)`) als Eingaben für eine Mischoperation mit dem einzelnen Farbanhang an `@location(0)` verwendet. Bei WebGPU ermöglicht `dual-source-blending` die folgenden Mischfaktoroperationen (spezifiziert in den `dstFactor`- und `srcFactor`-Eigenschaften der `createRenderPipeline()`- und `createRenderPipelineAsync()`-Deskriptoren): `src1`, `one-minus-src1`, `src1-alpha` und `one-minus-src1-alpha`.
`float32-blendable`	Wenn aktiviert, erlaubt es das Blending von `r32float`-, `rg32float`- und `rgba32float`-`format`-`GPUTexture`s.
`float32-filterable`	Wenn aktiviert, erlaubt es das Filtern von `r32float`-, `rg32float`- und `rgba32float`-`format`-`GPUTexture`s.
`indirect-first-instance`	Wenn aktiviert, erlaubt es die Nutzung von nicht-null `firstInstance`-Werten im `indirectBuffer`-Eigenschaft der `drawIndirect()`- und `drawIndexedIndirect()`-Methoden, die auf Instanzen von `GPURenderPassEncoder` und `GPURenderBundleEncoder` verfügbar sind.
`primitive-index`	Wenn aktiviert, erlaubt es die Nutzung der `primitive_index`-Eingebauten Variable in WGSL. Dieser eingebaute Eingabewert bietet auf unterstützter Hardware einen pro-Primitive-Index für Fragment-Shader, ähnlich den vorhandenen `vertex_index`- und `instance_index`-Eingebauten. Die `primitive_index`-Eingebaute Variable ist nützlich für fortgeschrittene grafische Techniken, wie virtualisierte Geometrie.
`rg11b10ufloat-renderable`	Wenn aktiviert, erlaubt es `RENDER_ATTACHMENT` `usage` von `rg11b10ufloat`-`format`-`GPUTexture`s sowie deren Blending und Multisampling.
`shader-f16`	Wenn aktiviert, erlaubt es die Nutzung des halbpräzisen Fließkomma-Typs `f16` in WGSL.
`subgroups`	Wenn aktiviert, erlaubt es die Nutzung von Subgruppen in WGSL. Subgruppen ermöglichen SIMD-Level-Parallelität, wodurch Threads in einer Arbeitsgruppe kommunizieren und kollektive mathematische Operationen ausführen können, wie das Berechnen einer Summe von Zahlen, und bieten eine effiziente Methode für das Teilen von Daten zwischen Threads. Beachten Sie, dass die `subgroupMinSize`- und `subgroupMaxSize`-Eigenschaften nützlich sein können, um zu überprüfen, ob Sie beispielsweise einen fest codierten Algorithmus haben, der eine Subgruppe einer bestimmten Größe erfordert. Sie können f16-Werte mit Subgruppen verwenden, wenn Sie ein GPUDevice mit den Features `shader-f16` und `subgroups` anfordern.
`texture-compression-bc`	Wenn aktiviert, ermöglicht es die Erstellung von zweidimensionalen BC-komprimierten Texturen. Wenn `texture-compression-bc` aktiviert ist, können die folgenden Werte für die `format`-Eigenschaft des `createTexture()`-Deskriptors beim Erstellen einer `GPUTexture` verwendet werden: `bc1-rgba-unorm`, `bc1-rgba-unorm-srgb`, `bc2-rgba-unorm`, `bc2-rgba-unorm-srgb`, `bc3-rgba-unorm`, `bc3-rgba-unorm-srgb`, `bc4-r-unorm`, `bc4-r-snorm`, `bc5-rg-unorm`, `bc5-rg-snorm`, `bc6h-rgb-ufloat`, `bc6h-rgb-float`, `bc7-rgba-unorm` und `bc7-rgba-unorm-srgb`.
`texture-compression-bc-sliced-3d`	Wenn aktiviert, ermöglicht es die Erstellung von dreidimensionalen BC-komprimierten Texturen. Wenn `texture-compression-bc-sliced-3d` aktiviert ist, muss auch `texture-compression-bc` aktiviert sein, da es die BC-Texturformate zur Nutzung (wie unter `texture-compression-bc` beschrieben) in den ersten zwei Dimensionen ermöglicht. `texture-compression-bc-sliced-3d` ermöglicht es, diese gleichen Texturen in der dritten Dimension zu verwenden.
`texture-compression-astc`	Wenn aktiviert, ermöglicht es die Erstellung von zweidimensionalen ASTC-komprimierten Texturen. Wenn `texture-compression-astc` aktiviert ist, können die folgenden Werte für die `format`-Eigenschaft des `createTexture()`-Deskriptors beim Erstellen einer `GPUTexture` verwendet werden: `astc-4x4-unorm`, `astc-4x4-unorm-srgb`, `astc-5x4-unorm`, `astc-5x4-unorm-srgb`, `astc-5x5-unorm`, `astc-5x5-unorm-srgb`, `astc-6x5-unorm`, `astc-6x5-unorm-srgb`, `astc-6x6-unorm`, `astc-6x6-unorm-srgb`, `astc-8x5-unorm`, `astc-8x5-unorm-srgb`, `astc-8x6-unorm`, `astc-8x6-unorm-srgb`, `astc-8x8-unorm`, `astc-8x8-unorm-srgb`, `astc-10x5-unorm`, `astc-10x5-unorm-srgb`, `astc-10x6-unorm`, `astc-10x6-unorm-srgb`, `astc-10x8-unorm`, `astc-10x8-unorm-srgb`, `astc-10x10-unorm`, `astc-10x10-unorm-srgb`, `astc-12x10-unorm`, `astc-12x10-unorm-srgb` und astc-12x12-unorm``astc-12x12-unorm-srgb.
`texture-compression-astc-sliced-3d`	Wenn aktiviert, ermöglicht es die Erstellung von dreidimensionalen ASTC-komprimierten Texturen. Wenn `texture-compression-astc-sliced-3d` aktiviert ist, muss auch `texture-compression-astc` aktiviert sein, da es die ASTC-Texturformate zur Nutzung (wie unter `texture-compression-astc` beschrieben) in den ersten zwei Dimensionen ermöglicht. `texture-compression-astc-sliced-3d` ermöglicht es, diese gleichen Texturen in der dritten Dimension zu verwenden.
`texture-compression-etc2`	Wenn aktiviert, ermöglicht es die Erstellung von zweidimensionalen ETC2-komprimierten Texturen. Wenn `texture-compression-etc2` aktiviert ist, können die folgenden Werte für die `format`-Eigenschaft des `createTexture()`-Deskriptors beim Erstellen einer `GPUTexture` verwendet werden: `etc2-rgb8unorm`, `etc2-rgb8unorm-srgb`, `etc2-rgb8a1unorm`, `etc2-rgb8a1unorm-srgb`, `etc2-rgba8unorm`, `etc2-rgba8unorm-srgb`, `eac-r11unorm`, `eac-r11snorm`, `eac-rg11unorm`, und `eac-rg11snorm`.
`texture-formats-tier1`	Wenn aktiviert, aktiviert es automatisch das `rg11b10ufloat-renderable`-Feature und ermöglicht die Erstellung von `GPUTexture`s (über `GPUDevice.createTexture()`) mit den in Tier 1 angegebenen Formaten. Der Tier 1 Satz von Texturformaten ist darauf ausgelegt, Entwicklern zu ermöglichen, vorhandene Inhalte auf das Web zu portieren, ohne diese umschreiben zu müssen, um WebGPU's geringere Fähigkeiten zu nutzen.
`texture-formats-tier2`	Wenn aktiviert, aktiviert es automatisch die `rg11b10ufloat-renderable`- und `texture-formats-tier1`-Features und ermöglicht die Erstellung von `GPUTexture`s (über `GPUDevice.createTexture()`) mit den in Tier 2 angegebenen Formaten. Der Tier 2 Satz von Texturformaten unterstützt Speichertexturformate, die in "Kern" WebGPU keine Unterstützung haben und für die erweiterte Nutzung erforderlich sind.
`timestamp-query`	Wenn aktiviert, erlaubt es, Zeitstempel-Abfragen durchzuführen, die die Zeit messen, die für das Ausführen von Compute- und Render-Passes benötigt wird. Wenn `timestamp-query` aktiviert ist, kann der Wert `timestamp` für die `type`-Eigenschaft des `createQuerySet()`-Deskriptors beim Erstellen eines `GPUQuerySet` eingestellt werden. Zusätzlich kann die `timestampWrites`-Eigenschaft beim Erstellen eines `GPUComputePassEncoder` und `GPURenderPassEncoder` in den Deskriptoren `beginComputePass()` und `beginRenderPass()` eingestellt werden. `GPUQuerySet`-Objekte werden innerhalb der Objekte referenziert, die in der `timestampWrites`-Eigenschaft enthalten sind, um anzugeben, wo Zeitstempel geschrieben werden sollen.

Instanz-Eigenschaften

Die folgenden Eigenschaften stehen allen schreibgeschützten set-ähnlichen Objekten zur Verfügung (die Links unten führen zur Set-Referenzseite des globalen Objekts).

size: Gibt die Anzahl der Werte in der Menge zurück.

Instanz-Methoden

Die folgenden Methoden stehen allen schreibgeschützten set-ähnlichen Objekten zur Verfügung (die Links unten führen zur Set-Referenzseite des globalen Objekts).

has(): Gibt einen Boolean zurück, der angibt, ob ein Element mit dem angegebenen Wert in der Menge vorhanden ist oder nicht.
values(): Gibt ein neues Iterator-Objekt zurück, das die Werte für jedes Element in der Menge in Einfüge-Reihenfolge erzeugt.
keys(): Ein Alias für values().
entries(): Gibt ein neues Iterator-Objekt zurück, das ein Array aus [value, value] für jedes Element in der Menge in Einfüge-Reihenfolge enthält.
forEach(): Ruft einmal für jedes in der Menge vorhandene Wert eine bereitgestellte Callback-Funktion in Einfüge-Reihenfolge auf.

Beispiele

async function init() {
  if (!navigator.gpu) {
    throw Error("WebGPU not supported.");
  }

  const adapter = await navigator.gpu.requestAdapter();
  if (!adapter) {
    throw Error("Couldn't request WebGPU adapter.");
  }

  const adapterFeatures = adapter.features;

  // Return the size of the set
  console.log(adapterFeatures.size);

  // Check whether a feature is supported by the adapter
  console.log(adapterFeatures.has("texture-compression-astc"));

  // Iterate through all the set values using values()
  const valueIterator = adapterFeatures.values();
  for (const value of valueIterator) {
    console.log(value);
  }

  // Iterate through all the set values using keys()
  const keyIterator = adapterFeatures.keys();
  for (const value of keyIterator) {
    console.log(value);
  }

  // Iterate through all the set values using entries()
  const entryIterator = adapterFeatures.entries();
  for (const entry of entryIterator) {
    console.log(entry[0]);
  }

  // Iterate through all the set values using forEach()
  adapterFeatures.forEach((value) => {
    console.log(value);
  });

  // …
}

Spezifikationen

Specification
WebGPU # gpusupportedfeatures

Browser-Kompatibilität

Siehe auch

Die WebGPU API
Die Spezifikation Feature Index

Help improve MDN

Learn how to contribute Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden