GPUSupportedFeatures

Eingeschränkt verfügbar

Diese Funktion ist nicht Baseline, da sie in einigen der am weitesten verbreiteten Browser nicht funktioniert.

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 wird über die GPUAdapter.features Eigenschaft aufgerufen — verwenden Sie dies, um zu prüfen, welche Funktionen Ihre aktuelle Konfiguration unterstützt. Um ein GPUDevice mit einer bestimmten aktivierten Funktion zu erstellen, müssen Sie diese im requiredFeatures Array des GPUAdapter.requestDevice() Deskriptors angeben.

Sie sollten beachten, dass nicht alle Funktionen in allen Browsern verfügbar sind, die WebGPU unterstützen, selbst wenn die Funktionen durch die zugrunde liegende 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 kann möglicherweise die Bereitstellung einer Funktion nicht in einer Weise garantieren, die mit einem bestimmten Browser kompatibel ist.
Der Browseranbieter hat möglicherweise keinen sicheren Weg gefunden, um die Unterstützung für diese Funktion zu implementieren, oder möglicherweise hat er es einfach noch nicht getan.

Wenn Sie hoffen, in einer WebGPU-Anwendung von einer bestimmten zusätzlichen Funktion zu profitieren, ist gründliches Testen ratsam.

Verfügbare Funktionen

Die folgenden zusätzlichen Funktionen sind in WebGPU definiert. Beachten Sie, dass der genaue Satz verfügbarer Funktionen je nach Implementierungen und physikalischen Geräten variieren wird und sich im Laufe der Zeit ändern kann.

Funktionsname	Beschreibung
`bgra8unorm-storage`	Wenn aktiviert, ermöglicht es die `STORAGE_BINDING` `usage` von `bgra8unorm`-`format` `GPUTexture`s.
`clip-distances`	Wenn aktiviert, erlaubt es die Verwendung von `clip_distances` in WGSL.
`core-features-and-limits`	Wenn aktiviert, bedeutet dies, dass der `GPUAdapter` / `GPUDevice` in der Lage ist, alle "Kern"-WebGPU-Funktionen und -Grenzen zu verwenden, was es Anwendungen ermöglicht, Geräte zu unterstützen, die moderne Plattform-Grafik-APIs verwenden. Standardmäßig haben alle Adapter die Funktion `core-features-and-limits` aktiviert und unterstützen daher das Kern-WebGPU. Um einen "Kompatibilitätsmodus"-Adapter zu erstellen, geben Sie einen `featureLevel` Wert von `compatibility` in Ihrem `GPU.requestAdapter()` Aufruf an. Der Kompatibilitätsmodus unterstützt ältere Grafik-APIs (wie Direct3D 11 und OpenGL ES 3.1) auf Kosten der Leistung und Funktionsumfang. Beachten Sie, dass ein Adapter im Kompatibilitätsmodus nur auf Geräten erstellt wird, die das Kern-WebGPU nicht unterstützen. Auf Geräten, die das Kern-WebGPU unterstützen, wird der Adapter das `core-features-and-limits` unterstützen, und Sie können moderne Funktionen verwenden (siehe Verwendung des Kompatibilitätsmodus nur bei Bedarf für ein Beispiel, wie dies funktioniert).
`depth-clip-control`	Wenn aktiviert, erlaubt es, Tiefenschneiden zu deaktivieren. Wenn `depth-clip-control` aktiviert ist, ist die `unclippedDepth` Eigenschaft im `primitive` Objekt verfügbar, das Teil des `createRenderPipeline()` oder `createRenderPipelineAsync()` Deskriptors ist, wenn Sie eine `GPURenderPipeline` erstellen. `primitive` beschreibt, wie eine Pipeline Primitiven aus ihren Vertex-Eingaben konstruiert und rastert. Setzen Sie `unclipped-depth` auf `true`, um das Tiefenschneiden 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 verwendet werden, wenn eine `GPUTexture` erstellt wird.
`dual-source-blending`	Wenn aktiviert, erlaubt es die Verwendung von `dual_source_blending` in WGSL, das beide Pixelshader-Ausgaben (`@blend_src(0)` und `@blend_src(1)`) als Eingaben für eine Mischoperation mit dem einzigen Farbanhang bei `@location(0)` nutzt. In WebGPU ermöglicht `dual-source-blending` die folgenden Blendfaktor-Operationen (angegeben 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 Verwendung von Nicht-Null-`firstInstance` Werten in der `indirectBuffer` Eigenschaft der `drawIndirect()` und `drawIndexedIndirect()` Methoden auf `GPURenderPassEncoder` und `GPURenderBundleEncoder` Instanzen.
`primitive-index`	Wenn aktiviert, erlaubt es die Verwendung der `primitive_index` eingebauten Variablen in WGSL. Dieser eingebauten Eingabewert bietet einen per-Primitive-Index für Fragment-Shader auf unterstützter Hardware, ähnlich zu den bestehenden `vertex_index` und `instance_index` eingebauten Variablen. Die `primitive_index` eingebauten Variable ist nützlich für fortgeschrittene grafische Techniken wie virtualisierte Geometrie.
`rg11b10ufloat-renderable`	Wenn aktiviert, erlaubt es die `RENDER_ATTACHMENT` `usage` von `rg11b10ufloat`-`format` `GPUTexture`s, sowie deren Blending und Multisampling.
`shader-f16`	Wenn aktiviert, erlaubt es die Verwendung des halbpräzisen Gleitkommatyps `f16` in WGSL.
`subgroups`	Wenn aktiviert, erlaubt es die Verwendung von Subgruppen in WGSL. Subgruppen ermöglichen SIMD-Level-Parallelismus, der es Threads in einer Arbeitsgruppe erlaubt, kollektive mathematische Operationen wie das Berechnen einer Summe von Zahlen auszuführen, und bieten eine effiziente Methode für den datenübergreifenden Datenaustausch. Beachten Sie, dass die `subgroupMinSize` und `subgroupMaxSize` Eigenschaften nützlich sein können, um zu prüfen, ob Sie beispielsweise einen hartcodierten Algorithmus haben, der eine Subgruppe einer bestimmten Größe erfordert. Sie können f16 Werte mit Subgruppen 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 Sprachfunktion.
`texture-component-swizzle`	Wenn aktiviert, erlaubt es die `swizzle` Eigenschaft festzulegen, wenn `GPUTexture.createView()` aufgerufen wird. Diese Funktion erlaubt es, die Rot-, Grün-, Blau- und Alphakanalwerte einer Textur in einer Texturansicht umzuschalten oder zu ersetzen, wenn sie von einem Shader abgerufen werden.
`texture-compression-bc`	Wenn aktiviert, erlaubt 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 verwendet werden, wenn eine `GPUTexture` erstellt wird: `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, erlaubt 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 in den ersten beiden Dimensionen aktiviert (siehe `texture-compression-bc`, oben). `texture-compression-bc-sliced-3d` ermöglicht es, dieselben Texturen in der dritten Dimension zu verwenden.
`texture-compression-astc`	Wenn aktiviert, erlaubt 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 verwendet werden, wenn eine `GPUTexture` erstellt wird: `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, erlaubt 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 in den ersten beiden Dimensionen aktiviert (siehe `texture-compression-astc`, oben). `texture-compression-astc-sliced-3d` ermöglicht es, dieselben Texturen in der dritten Dimension zu verwenden.
`texture-compression-etc2`	Wenn aktiviert, erlaubt 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 verwendet werden, wenn eine `GPUTexture` erstellt wird: `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 die Funktion `rg11b10ufloat-renderable` und erlaubt die Erstellung von `GPUTexture`s (über `GPUDevice.createTexture()`) mit den Formaten, die in Tier 1 angegeben sind. Der Tier-1-Satz von Texturformaten ist so entworfen, dass Entwickler bestehenden Inhalt ins Web portieren können, ohne ihn umschreiben zu müssen, um die niedrigeren Fähigkeiten von WebGPU zu nutzen.
`texture-formats-tier2`	Wenn aktiviert, aktiviert es automatisch die Funktionen `rg11b10ufloat-renderable` und `texture-formats-tier1` und erlaubt die Erstellung von `GPUTexture`s (über `GPUDevice.createTexture()`) mit den Formaten, die in Tier 2 angegeben sind. Der Tier-2-Satz von Texturformaten unterstützt Speichertexturformate, die in "Kern"-WebGPU nicht unterstützt werden, und sind für fortgeschrittene Verwendungen erforderlich.
`timestamp-query`	Wenn aktiviert, erlaubt es, Zeitstempel-Abfragen durchzuführen, die die zum Ausführen von Rechen- und Renderpassagen benötigte Zeit messen. Wenn `timestamp-query` aktiviert ist, kann der Wert `timestamp` für die `type` Eigenschaft des `createQuerySet()` Deskriptors festgelegt werden, wenn ein `GPUQuerySet` erstellt wird. Zusätzlich kann die `timestampWrites` Eigenschaft auf den `beginComputePass()` und `beginRenderPass()` Deskriptors festgelegt werden, wenn ein `GPUComputePassEncoder` und `GPURenderPassEncoder` entsprechend erstellt werden. `GPUQuerySet` Objekte werden innerhalb der Objekte referenziert, die zur `timestampWrites` Eigenschaft gehören, um anzugeben, wo die Zeitstempel geschrieben werden sollen.

Instanzeigenschaften

Die folgenden Eigenschaften stehen allen schreibgeschützten Set-ähnlichen Objekten zur Verfügung (die unten stehenden Links verweisen auf die Set globale Objekt-Referenzseite).

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

Instanzmethoden

Die folgenden Methoden stehen allen schreibgeschützten Set-ähnlichen Objekten zur Verfügung (die unten stehenden Links verweisen auf die Set globale Objekt-Referenzseite).

has(): Gibt einen boolean zurück, der angibt, ob ein Element mit dem angegebenen 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 aus [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 der 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

Spezifikation
WebGPU # gpusupportedfeatures

Browser-Kompatibilität

Siehe auch

Die WebGPU API
Die Spezifikation Feature Index

Help improve MDN

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

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