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.

Die GPUSupportedFeatures Schnittstelle 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 wird über die GPUAdapter.features Eigenschaft zugegriffen — verwenden Sie dies, um zu testen, welche Funktionen Ihr aktuelles System unterstützt. Um ein GPUDevice mit einer bestimmten Funktion zu erstellen, müssen Sie diese im requiredFeatures Array des GPUAdapter.requestDevice() Deskriptors angeben.

Es sollte beachtet werden, dass nicht alle Funktionen in allen Browsern verfügbar sein werden, die WebGPU unterstützen, 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. Zum Beispiel:

Das zugrunde liegende System könnte möglicherweise nicht garantieren, dass eine Funktion auf eine Weise verfügbar gemacht wird, die mit einem bestimmten Browser kompatibel ist.
Der Browser-Anbieter hat möglicherweise keinen sicheren Weg gefunden, um die Unterstützung für diese Funktion zu implementieren, oder hat es einfach noch nicht geschafft.

Wenn Sie hoffen, eine bestimmte zusätzliche Funktion in einer WebGPU-Anwendung zu nutzen, wird gründliches Testen empfohlen.

Verfügbare Funktionen

Die folgenden zusätzlichen Funktionen sind in WebGPU definiert. Bedenken Sie, dass die genaue Menge an verfügbaren Funktionen sich zwischen Implementierungen und physischen Geräten unterscheiden und sich im Laufe der Zeit ändern wird.

Funktionsname	Beschreibung
`bgra8unorm-storage`	Wenn aktiviert, ermöglicht das `STORAGE_BINDING` `usage` von `bgra8unorm`-`format` `GPUTexture`s.
`clip-distances`	Wenn aktiviert, erlaubt die Verwendung von `clip_distances` in WGSL.
`core-features-and-limits`	Wenn aktiviert, zeigt an, dass der `GPUAdapter` / `GPUDevice` alle grundlegenden WebGPU-Funktionen und -Grenzen verwenden kann, was es Anwendungen ermöglicht, Geräte mit den Grafikschnittstellen-APIs Direct 3D 12, Metal und Vulkan zu unterstützen (beachten Sie, dass Safari nur Metal unterstützt). Dies wird auch als "core" WebGPU bezeichnet. Derzeit haben alle Adapter "core" WebGPU verfügbar, und es wird auf allen Geräten automatisch aktiviert, selbst wenn es nicht angefordert wird. Diese Funktion ermöglicht es Adaptern und Geräten, zwischen "core" WebGPU und "Kompatibilitätsmodus" zu unterscheiden, was Unterstützung für ältere Grafik-APIs (wie Direct 3D 11 und OpenGL ES) bietet, jedoch auf Kosten von Leistung und Funktionsumfang.
`depth-clip-control`	Wenn aktiviert, kann die depth-clipping deaktiviert werden. Wenn `depth-clip-control` aktiviert ist, steht die `unclippedDepth` Eigenschaft auf dem `primitive` Objekt zur Verfügung, das als Teil des `createRenderPipeline()` oder `createRenderPipelineAsync()` Deskriptors beim Erstellen einer `GPURenderPipeline` enthalten ist. `primitive` beschreibt, wie eine Pipeline Primitiven aus ihren Vertex-Eingaben konstruiert und rastert. Setzen Sie `unclipped-depth` auf `true`, um das Depth-Clipping zu deaktivieren.
`depth32float-stencil8`	Wenn aktiviert, ermöglicht 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 verwendet werden, wenn eine `GPUTexture` erstellt wird.
`dual-source-blending`	Wenn aktiviert, ermöglicht die Verwendung von `dual_source_blending` in WGSL, das beide Pixel-Shader-Ausgaben (`@blend_src(0)` und `@blend_src(1)`) als Eingaben für eine Mischoperation mit dem einzigen Farb-Anhang bei `@location(0)` verwendet. In WebGPU ermöglicht `dual-source-blending` die folgenden Mischfaktoroperationen (angegeben in den `dstFactor` und `srcFactor` Eigenschaften von `createRenderPipeline()` und `createRenderPipelineAsync()` Deskriptoren): `src1`, `one-minus-src1`, `src1-alpha` und `one-minus-src1-alpha`.
`float32-blendable`	Wenn aktiviert, ermöglicht Blending von `r32float`-, `rg32float`-, und `rgba32float`-`format` `GPUTexture`s.
`float32-filterable`	Wenn aktiviert, ermöglicht Filtern von `r32float`-, `rg32float`-, und `rgba32float`-`format` `GPUTexture`s.
`indirect-first-instance`	Wenn aktiviert, ermöglicht die Verwendung von Nicht-Null-Werten von `firstInstance` in der `indirectBuffer` Eigenschaft der `drawIndirect()` und `drawIndexedIndirect()` Methoden, die auf `GPURenderPassEncoder` und `GPURenderBundleEncoder` Instanzen verfügbar sind.
`primitive-index`	Wenn aktiviert, ermöglicht die Verwendung der eingebauten Variable `primitive_index` in WGSL. Dieser eingebaute Eingabewert liefert einen Index pro Primitive an Fragmente-Shader auf unterstützter Hardware, ähnlich den bereits vorhandenen eingebauten Variablen `vertex_index` und `instance_index`. Die `primitive_index` eingebaute Variable ist nützlich für fortgeschrittene grafische Techniken, wie virtualisierte Geometrie.
`rg11b10ufloat-renderable`	Wenn aktiviert, ermöglicht das `RENDER_ATTACHMENT` `usage` von `rg11b10ufloat`-`format` `GPUTexture`s sowie deren Blending und Multisampling.
`shader-f16`	Wenn aktiviert, ermöglicht die Verwendung des halben Präzisionstyp `f16` in WGSL.
`subgroups`	Wenn aktiviert, ermöglicht die Verwendung von Subgroups in WGSL. Subgroups ermöglichen SIMD-Level-Parallelität, wodurch Threads in einer Workgroup kommunizieren und kollektive mathematische Operationen wie das Berechnen einer Summe von Zahlen ausführen können, sowie eine effiziente Methode zum Teilen von Daten zwischen Threads bieten. Beachten Sie, dass die Eigenschaften `subgroupMinSize` und `subgroupMaxSize` nützlich sein können, um zu überprüfen, ob beispielsweise ein hartkodierter Algorithmus eine Subgroup einer bestimmten Größe erfordert. Sie können `f16` Werte mit Subgroups verwenden, wenn Sie ein `GPUDevice` mit den Funktionen `shader-f16` und `subgroups` anfordern. Wenn `subgroups` aktiviert ist, erlaubt es auch die Verwendung der `subgroup_id` WGSL-Spracheigenschaft.
`texture-component-swizzle`	Wenn aktiviert, erlaubt die `swizzle` Eigenschaft eingestellt zu werden, wenn `GPUTexture.createView()` aufgerufen wird. Diese Funktion erlaubt es, die Rot-, Grün-, Blau- und Alpha-Kanalwerte einer Textur in einer Texturansicht beim Zugriff durch einen Shader neu zu ordnen oder zu ersetzen.
`texture-compression-bc`	Wenn aktiviert, ermöglicht 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 die Erstellung von dreidimensionalen BC-komprimierten Texturen. Wenn `texture-compression-bc-sliced-3d` aktiviert ist, muss `texture-compression-bc` ebenfalls aktiviert sein, da es die BC-Texturformate in den ersten beiden Dimensionen ermöglicht (siehe `texture-compression-bc` oben). `texture-compression-bc-sliced-3d` ermöglicht dieselben Texturen in der dritten Dimension zu verwenden.
`texture-compression-astc`	Wenn aktiviert, ermöglicht 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 die Erstellung von dreidimensionalen ASTC-komprimierten Texturen. Wenn `texture-compression-astc-sliced-3d` aktiviert ist, muss `texture-compression-astc` ebenfalls aktiviert sein, da es die ASTC-Texturformate in den ersten beiden Dimensionen ermöglicht (siehe `texture-compression-astc` oben). `texture-compression-astc-sliced-3d` ermöglicht dieselben Texturen in der dritten Dimension zu verwenden.
`texture-compression-etc2`	Wenn aktiviert, ermöglicht 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, wird automatisch die Funktion `rg11b10ufloat-renderable` aktiviert und ermöglicht die Erstellung von `GPUTexture`s (über `GPUDevice.createTexture()`) mit den in Tier 1 angegebenen Formaten. Die Tier 1 Menge an Texturformaten ist darauf ausgelegt, Entwicklern zu ermöglichen, bestehende Inhalte ins Web zu portieren, ohne diese umschreiben zu müssen, um WebGPUs geringere Kapazitäten zu nutzen.
`texture-formats-tier2`	Wenn aktiviert, werden automatisch die Funktionen `rg11b10ufloat-renderable` und `texture-formats-tier1` aktiviert und ermöglicht die Erstellung von `GPUTexture`s (über `GPUDevice.createTexture()`) mit den in Tier 2 angegebenen Formaten. Die Tier 2 Menge an Texturformaten unterstützt Speichertexturformate, die in "core" WebGPU nicht unterstützt werden und für fortgeschrittene Verwendung benötigt werden.
`timestamp-query`	Wenn aktiviert, ermöglicht das Ausführen von Zeitstempel-Anfragen, die die Zeit messen, die benötigt wird, um Berechnungs- und Render-Pässe auszuführen. 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 Eigenschaft `timestampWrites` auf den `beginComputePass()` und `beginRenderPass()` Deskriptoren beim Erstellen eines `GPUComputePassEncoder` und `GPURenderPassEncoder`, beziehungsweise, eingestellt werden. `GPUQuerySet` Objekte werden innerhalb der in der Eigenschaft `timestampWrites` enthaltenen Objekte referenziert, um anzugeben, wo Zeitstempel geschrieben werden sollen.

Instanz-Eigenschaften

Die folgenden Eigenschaften sind für alle schreibgeschützten Set-ähnlichen Objekte verfügbar (die unten stehenden Links verweisen auf die Set globale Objekt-Referenzseite).

size: Gibt die Anzahl der Werte im Set zurück.

Instanz-Methoden

Die folgenden Methoden sind für alle schreibgeschützten Set-ähnlichen Objekte verfügbar (die unten stehenden Links verweisen auf die Set globale Objekt-Referenzseite).

has(): Gibt einen booleanischen Wert zurück, der angibt, ob ein Element mit dem gegebenen Wert im Set vorhanden ist oder nicht.
values(): Gibt ein neues Iterator-Objekt zurück, das die Werte für jedes Element im Set in Einfügereihenfolge liefert.
keys(): Ein Alias für values().
entries(): Gibt ein neues Iterator-Objekt zurück, das ein Array von [value, value] für jedes Element im Set in Einfügereihenfolge enthält.
forEach(): Ruft eine bereitgestellte Rückruffunktion einmal für jeden im Set vorhandenen Wert in Einfügereihenfolge 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