diff --git a/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/KeyboardToXml.java b/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/KeyboardToXml.java new file mode 100644 index 0000000000..05199f02d5 --- /dev/null +++ b/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/KeyboardToXml.java @@ -0,0 +1,201 @@ +package org.unicode.cldr.draft.keyboard.out; + +import static com.google.common.base.Preconditions.checkNotNull; + +import java.io.Writer; + +import org.unicode.cldr.draft.keyboard.CharacterMap; +import org.unicode.cldr.draft.keyboard.IsoLayoutPosition; +import org.unicode.cldr.draft.keyboard.KeyMap; +import org.unicode.cldr.draft.keyboard.Keyboard; +import org.unicode.cldr.draft.keyboard.KeyboardId.Platform; +import org.unicode.cldr.draft.keyboard.KeyboardSettings.FallbackSetting; +import org.unicode.cldr.draft.keyboard.KeyboardSettings.TransformFailureSetting; +import org.unicode.cldr.draft.keyboard.KeyboardSettings.TransformPartialSetting; +import org.unicode.cldr.draft.keyboard.ModifierKeyCombinationSet; +import org.unicode.cldr.draft.keyboard.Transform; + +import com.google.common.base.Joiner; +import com.google.common.collect.ImmutableMap; +import com.ibm.icu.lang.UCharacter; +import com.ibm.icu.text.DecimalFormat; +import com.ibm.icu.text.UCharacterIterator; +import com.ibm.icu.text.UnicodeSet; + +public final class KeyboardToXml { + private final Keyboard keyboard; + private final XmlWriter xmlWriter; + + private KeyboardToXml(Keyboard keyboard, XmlWriter xmlWriter) { + this.keyboard = checkNotNull(keyboard); + this.xmlWriter = checkNotNull(xmlWriter); + } + + /** Writes the given keyboard map in XML format to the provided writer. */ + public static void writeToXml(Keyboard keyboard, Writer writer) { + XmlWriter xmlWriter = XmlWriter.newXmlWriter(writer); + KeyboardToXml keyboardToXml = new KeyboardToXml(keyboard, xmlWriter); + keyboardToXml.toXml(); + } + + private void toXml() { + xmlWriter.startDocument("keyboard", "../dtd/ldmlKeyboard.dtd"); + xmlWriter.startElement("keyboard", ImmutableMap.of("locale", keyboard.keyboardId())); + addMetadata(); + addKeyMaps(); + addTransforms(); + xmlWriter.endElement(); + xmlWriter.endDocument(); + } + + private static DecimalFormat VERSION_FORMAT = new DecimalFormat("#.#"); + + private void addMetadata() { + Platform platform = keyboard.keyboardId().platform(); + ImmutableMap versionAttributes = ImmutableMap.of( + "platform", VERSION_FORMAT.format(platform.version()), + "number", "$Revision$"); + xmlWriter.addElement("version", versionAttributes); + // xmlWriter.addElement("generation", ImmutableMap.of("date", "$Date$")); + xmlWriter.startElement("names"); + for (String name : keyboard.names()) { + xmlWriter.addElement("name", ImmutableMap.of("value", name)); + } + xmlWriter.endElement(); + // Settings. + ImmutableMap.Builder settingsBuilder = ImmutableMap.builder(); + if (platform.settings().fallbackSetting() == FallbackSetting.OMIT) { + FallbackSetting fallbackSetting = platform.settings().fallbackSetting(); + settingsBuilder.put("fallback", fallbackSetting.toString().toLowerCase()); + } + boolean hasTransform = keyboard.transforms().size() > 0; + if (hasTransform + && platform.settings().transformFailureSetting() == TransformFailureSetting.OMIT) { + TransformFailureSetting transformFailure = platform.settings().transformFailureSetting(); + settingsBuilder.put("transformFailure", transformFailure.toString()); + } + if (hasTransform + && platform.settings().transformPartialSetting() == TransformPartialSetting.HIDE) { + TransformPartialSetting transformPartial = platform.settings().transformPartialSetting(); + settingsBuilder.put("transformPartial", transformPartial.toString()); + } + ImmutableMap settingsAttributes = settingsBuilder.build(); + if (!settingsAttributes.isEmpty()) { + xmlWriter.addElement("settings", settingsAttributes); + } + } + + private static final Joiner COMMA_JOINER = Joiner.on(","); + + private void addKeyMaps() { + for (KeyMap keyMap : keyboard.keyMaps()) { + ImmutableMap.Builder keyMapAttributes = ImmutableMap.builder(); + ModifierKeyCombinationSet modifiers = keyMap.modifierKeyCombinationSet(); + if (!modifiers.isBase()) { + keyMapAttributes.put("modifiers", modifiers.toString()); + } + xmlWriter.startElement("keyMap", keyMapAttributes.build()); + for (CharacterMap characterMap : keyMap.isoLayoutToCharacterMap().values()) { + String output = characterMap.output(); + ImmutableMap.Builder mapAttributes = ImmutableMap.builder(); + mapAttributes.put("iso", "" + characterMap.position()); + String escapedOutput = escapeOutput(output); + mapAttributes.put("to", escapedOutput); + if (!characterMap.longPressKeys().isEmpty()) { + mapAttributes.put("longPress", COMMA_JOINER.join(characterMap.longPressKeys())); + } + if (characterMap.isTransformNo()) { + mapAttributes.put("transform", "no"); + } + String comment = buildReadabilityComment(characterMap, escapedOutput); + xmlWriter.addElement("map", mapAttributes.build(), comment); + } + xmlWriter.endElement(); + } + } + + private static final UnicodeSet ESCAPED_CHARACTERS_NO_SPACE = new UnicodeSet("[[:di:][:c:][:M:][:whitespace:][\"]-[\\u0020]]").freeze(); + + private String escapeOutput(String output) { + StringBuilder stringBuilder = new StringBuilder(); + UCharacterIterator it = UCharacterIterator.getInstance(output); + int character; + while ((character = it.nextCodePoint()) != UCharacterIterator.DONE) { + if (ESCAPED_CHARACTERS_NO_SPACE.contains(character)) { + stringBuilder.append(String.format("\\u{%X}", character)); + } else { + stringBuilder.append(UCharacter.toString(character)); + } + } + return stringBuilder.toString(); + } + + private static final UnicodeSet ILLEGAL_COMMENT_CHARACTERS = new UnicodeSet("[[:di:][:c:][:whitespace:]]").freeze(); + + private String buildReadabilityComment(CharacterMap characterMap, String escapedOutput) { + StringBuilder comment = new StringBuilder(); + String output = characterMap.output(); + IsoLayoutPosition position = characterMap.position(); + // English Key Name (Only if it is non-trivial) + if (!output.toUpperCase().equals(position.englishKeyName())) { + comment.append(position.englishKeyName()); + } + // Base (Only if it is different than the english key and non-trivial). + KeyMap baseMap = keyboard.baseMap(); + CharacterMap baseKey = baseMap.isoLayoutToCharacterMap().get(position); + if (baseKey != null && !baseKey.output().toUpperCase().equals(output.toUpperCase()) + && !baseKey.output().toUpperCase().equals(position.englishKeyName())) { + comment.append(" base="); + comment.append(baseKey.output()); + } + // Output (Only if the output is safe for comment) + if (escapedOutput.contains("\\u{") && !ILLEGAL_COMMENT_CHARACTERS.contains(output)) { + comment.append(" to= " + output + " "); + } + /* + // Long press + if (longPressString.contains("\\u{")) { + StringBuilder longPressBuilder = new StringBuilder(); + for (String longPress : longPressKeys) { + if (!CommonUtil.ILLEGAL_COMMENT_CHARACTERS.contains(longPress)) { + longPressBuilder.append(longPress); + longPressBuilder.append(" "); + } + } + + if (longPressBuilder.length() > 0) { + comment.append(" long="); + comment.append(longPressBuilder.toString()); + } + } + */ + return comment.toString(); + } + + private void addTransforms() { + if (keyboard.transforms().isEmpty()) { + return; + } + xmlWriter.startElement("transforms", ImmutableMap.of("type", "simple")); + for (Transform transform : keyboard.transforms()) { + String escapedSequence = escapeOutput(transform.sequence()); + String escapedOutput = escapeOutput(transform.output()); + String comment = buildTransformReadabilityComment(transform, escapedSequence, escapedOutput); + xmlWriter.addElement("transform", + ImmutableMap.of("from", escapedSequence, "to", escapedOutput), + comment); + } + xmlWriter.endElement(); + + } + + private String buildTransformReadabilityComment(Transform transform, String escapedSequence, + String escapedOutput) { + if ((escapedSequence.contains("\\u{") || escapedOutput.contains("\\u{")) + && !ILLEGAL_COMMENT_CHARACTERS.containsSome(transform.sequence()) + && !ILLEGAL_COMMENT_CHARACTERS.contains(transform.output())) { + return transform.sequence() + " → " + transform.output(); + } + return ""; + } +} diff --git a/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/KeycodeMapToXml.java b/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/KeycodeMapToXml.java new file mode 100644 index 0000000000..92ac0a1b0b --- /dev/null +++ b/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/KeycodeMapToXml.java @@ -0,0 +1,44 @@ +package org.unicode.cldr.draft.keyboard.out; + +import static com.google.common.base.Preconditions.checkNotNull; + +import java.io.Writer; +import java.util.Map.Entry; + +import org.unicode.cldr.draft.keyboard.IsoLayoutPosition; +import org.unicode.cldr.draft.keyboard.KeyboardId.Platform; +import org.unicode.cldr.draft.keyboard.KeycodeMap; + +import com.google.common.collect.ImmutableMap; + +/** Utility class that writes the given key code map into the LDML XML format. */ +public final class KeycodeMapToXml { + private final KeycodeMap keycodeMap; + private final Platform platform; + private final XmlWriter xmlWriter; + + private KeycodeMapToXml(KeycodeMap keycodeMap, Platform platform, XmlWriter xmlWriter) { + this.keycodeMap = checkNotNull(keycodeMap); + this.platform = checkNotNull(platform); + this.xmlWriter = checkNotNull(xmlWriter); + } + + /** Writes the given key code map in XML format to the provided writer. */ + public static void writeToXml(KeycodeMap keycodeMap, Platform platform, Writer writer) { + XmlWriter xmlWriter = XmlWriter.newXmlWriter(writer); + KeycodeMapToXml keycodeMapToXml = new KeycodeMapToXml(keycodeMap, platform, xmlWriter); + keycodeMapToXml.toXml(); + } + + private void toXml() { + xmlWriter.startDocument("platform", "../dtd/ldmlPlatform.dtd"); + xmlWriter.startElement("platform", ImmutableMap.of("id", platform)); + xmlWriter.startElement("hardwareMap"); + for (Entry entry : keycodeMap.keycodeToIsoLayout().entrySet()) { + xmlWriter.addElement("map", ImmutableMap.of("keycode", entry.getKey(), "iso", entry.getValue())); + } + xmlWriter.endElement(); + xmlWriter.endElement(); + xmlWriter.endDocument(); + } +} diff --git a/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/XmlWriter.java b/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/XmlWriter.java new file mode 100644 index 0000000000..bb26da8b13 --- /dev/null +++ b/external/cldr/tools/cldr-code/src/main/java/org/unicode/cldr/draft/keyboard/out/XmlWriter.java @@ -0,0 +1,124 @@ +package org.unicode.cldr.draft.keyboard.out; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import java.io.Writer; +import java.util.Map; +import java.util.Map.Entry; + +import javax.xml.stream.XMLOutputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamWriter; + +import com.google.common.collect.ImmutableMap; + +/** + * Object which wraps around an XML stream writer. Automatically adds proper formatting + * (indentation and line breaks) to the written XML elements. + */ +final class XmlWriter { + private final XMLStreamWriter writer; + private int depth = 0; + + private XmlWriter(XMLStreamWriter writer) { + this.writer = checkNotNull(writer); + } + + static XmlWriter newXmlWriter(Writer writer) { + XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); + XMLStreamWriter xmlStreamWriter; + try { + xmlStreamWriter = outputFactory.createXMLStreamWriter(writer); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + return new XmlWriter(xmlStreamWriter); + } + + XmlWriter startDocument(String doctype, String dtdLocation) { + try { + writer.writeStartDocument("UTF-8", "1.0"); + writer.writeCharacters("\n"); + writer.writeDTD(""); + writer.writeCharacters("\n"); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + return this; + } + + XmlWriter endDocument() { + checkState(depth == 0, "Cannot close document with unclosed elements"); + try { + writer.writeEndDocument(); + writer.close(); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + return this; + } + + XmlWriter startElement(String name) { + return startElement(name, ImmutableMap. of()); + } + + XmlWriter startElement(String name, Map attributeToValue) { + addIndent(); + try { + writer.writeStartElement(name); + for (Entry entry : attributeToValue.entrySet()) { + writer.writeAttribute(entry.getKey(), "" + entry.getValue()); + } + writer.writeCharacters("\n"); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + depth++; + return this; + } + + XmlWriter endElement() { + depth--; + addIndent(); + try { + writer.writeEndElement(); + writer.writeCharacters("\n"); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + return this; + } + + XmlWriter addElement(String name, Map attributeToValue) { + return addElement(name, attributeToValue, ""); + } + + XmlWriter addElement(String name, Map attributeToValue, String comment) { + addIndent(); + try { + writer.writeEmptyElement(name); + for (Entry entry : attributeToValue.entrySet()) { + writer.writeAttribute(entry.getKey(), "" + entry.getValue()); + } + if (!comment.isEmpty()) { + writer.writeCharacters(" "); + writer.writeComment(" " + comment + " "); + } + writer.writeCharacters("\n"); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + return this; + } + + private void addIndent() { + for (int i = 0; i < depth; i++) { + try { + writer.writeCharacters("\t"); + } catch (XMLStreamException e) { + throw new RuntimeException(e); + } + } + } +} diff --git a/external/rust/crates/bindgen/out/host-target.txt b/external/rust/crates/bindgen/out/host-target.txt new file mode 100644 index 0000000000..8dd176f8ba --- /dev/null +++ b/external/rust/crates/bindgen/out/host-target.txt @@ -0,0 +1 @@ +x86_64-unknown-linux-gnu \ No newline at end of file diff --git a/external/rust/crates/bindgen/out/tests.rs b/external/rust/crates/bindgen/out/tests.rs new file mode 100644 index 0000000000..e69de29bb2 diff --git a/external/rust/crates/clang-sys/out/common.rs b/external/rust/crates/clang-sys/out/common.rs new file mode 100644 index 0000000000..bc720ca6b0 --- /dev/null +++ b/external/rust/crates/clang-sys/out/common.rs @@ -0,0 +1,311 @@ +// SPDX-License-Identifier: Apache-2.0 + +extern crate glob; + +use std::cell::RefCell; +use std::collections::HashMap; +use std::env; +use std::path::{Path, PathBuf}; +use std::process::Command; + +use glob::{MatchOptions, Pattern}; + +//================================================ +// Commands +//================================================ + +thread_local! { + /// The errors encountered by the build script while executing commands. + static COMMAND_ERRORS: RefCell>> = RefCell::default(); +} + +/// Adds an error encountered by the build script while executing a command. +fn add_command_error(name: &str, path: &str, arguments: &[&str], message: String) { + COMMAND_ERRORS.with(|e| { + e.borrow_mut() + .entry(name.into()) + .or_insert_with(Vec::new) + .push(format!( + "couldn't execute `{} {}` (path={}) ({})", + name, + arguments.join(" "), + path, + message, + )) + }); +} + +/// A struct that prints the errors encountered by the build script while +/// executing commands when dropped (unless explictly discarded). +/// +/// This is handy because we only want to print these errors when the build +/// script fails to link to an instance of `libclang`. For example, if +/// `llvm-config` couldn't be executed but an instance of `libclang` was found +/// anyway we don't want to pollute the build output with irrelevant errors. +#[derive(Default)] +pub struct CommandErrorPrinter { + discard: bool, +} + +impl CommandErrorPrinter { + pub fn discard(mut self) { + self.discard = true; + } +} + +impl Drop for CommandErrorPrinter { + fn drop(&mut self) { + if self.discard { + return; + } + + let errors = COMMAND_ERRORS.with(|e| e.borrow().clone()); + + if let Some(errors) = errors.get("llvm-config") { + println!( + "cargo:warning=could not execute `llvm-config` one or more \ + times, if the LLVM_CONFIG_PATH environment variable is set to \ + a full path to valid `llvm-config` executable it will be used \ + to try to find an instance of `libclang` on your system: {}", + errors + .iter() + .map(|e| format!("\"{}\"", e)) + .collect::>() + .join("\n "), + ) + } + + if let Some(errors) = errors.get("xcode-select") { + println!( + "cargo:warning=could not execute `xcode-select` one or more \ + times, if a valid instance of this executable is on your PATH \ + it will be used to try to find an instance of `libclang` on \ + your system: {}", + errors + .iter() + .map(|e| format!("\"{}\"", e)) + .collect::>() + .join("\n "), + ) + } + } +} + +/// Executes a command and returns the `stdout` output if the command was +/// successfully executed (errors are added to `COMMAND_ERRORS`). +fn run_command(name: &str, path: &str, arguments: &[&str]) -> Option { + let output = match Command::new(path).args(arguments).output() { + Ok(output) => output, + Err(error) => { + let message = format!("error: {}", error); + add_command_error(name, path, arguments, message); + return None; + } + }; + + if output.status.success() { + Some(String::from_utf8_lossy(&output.stdout).into_owned()) + } else { + let message = format!("exit code: {}", output.status); + add_command_error(name, path, arguments, message); + None + } +} + +/// Executes the `llvm-config` command and returns the `stdout` output if the +/// command was successfully executed (errors are added to `COMMAND_ERRORS`). +pub fn run_llvm_config(arguments: &[&str]) -> Option { + let path = env::var("LLVM_CONFIG_PATH").unwrap_or_else(|_| "llvm-config".into()); + run_command("llvm-config", &path, arguments) +} + +/// Executes the `xcode-select` command and returns the `stdout` output if the +/// command was successfully executed (errors are added to `COMMAND_ERRORS`). +pub fn run_xcode_select(arguments: &[&str]) -> Option { + run_command("xcode-select", "xcode-select", arguments) +} + +//================================================ +// Search Directories +//================================================ + +/// `libclang` directory patterns for Haiku. +const DIRECTORIES_HAIKU: &[&str] = &[ + "/boot/system/lib", + "/boot/system/develop/lib", + "/boot/system/non-packaged/lib", + "/boot/system/non-packaged/develop/lib", + "/boot/home/config/non-packaged/lib", + "/boot/home/config/non-packaged/develop/lib", +]; + +/// `libclang` directory patterns for Linux (and FreeBSD). +const DIRECTORIES_LINUX: &[&str] = &[ + "/usr/lib*", + "/usr/lib*/*", + "/usr/lib*/*/*", + "/usr/local/lib*", + "/usr/local/lib*/*", + "/usr/local/lib*/*/*", + "/usr/local/llvm*/lib*", +]; + +/// `libclang` directory patterns for macOS. +const DIRECTORIES_MACOS: &[&str] = &[ + "/usr/local/opt/llvm*/lib", + "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib", + "/Library/Developer/CommandLineTools/usr/lib", + "/usr/local/opt/llvm*/lib/llvm*/lib", +]; + +/// `libclang` directory patterns for Windows. +const DIRECTORIES_WINDOWS: &[&str] = &[ + "C:\\LLVM\\lib", + "C:\\Program Files*\\LLVM\\lib", + "C:\\MSYS*\\MinGW*\\lib", + // LLVM + Clang can be installed as a component of Visual Studio. + // https://github.com/KyleMayes/clang-sys/issues/121 + "C:\\Program Files*\\Microsoft Visual Studio\\*\\BuildTools\\VC\\Tools\\Llvm\\**\\bin", + // LLVM + Clang can be installed using Scoop (https://scoop.sh). + // Other Windows package managers install LLVM + Clang to previously listed + // system-wide directories. + "C:\\Users\\*\\scoop\\apps\\llvm\\current\\bin", +]; + +//================================================ +// Searching +//================================================ + +/// Finds the files in a directory that match one or more filename glob patterns +/// and returns the paths to and filenames of those files. +fn search_directory(directory: &Path, filenames: &[String]) -> Vec<(PathBuf, String)> { + // Escape the specified directory in case it contains characters that have + // special meaning in glob patterns (e.g., `[` or `]`). + let directory = Pattern::escape(directory.to_str().unwrap()); + let directory = Path::new(&directory); + + // Join the escaped directory to the filename glob patterns to obtain + // complete glob patterns for the files being searched for. + let paths = filenames + .iter() + .map(|f| directory.join(f).to_str().unwrap().to_owned()); + + // Prevent wildcards from matching path separators to ensure that the search + // is limited to the specified directory. + let mut options = MatchOptions::new(); + options.require_literal_separator = true; + + paths + .map(|p| glob::glob_with(&p, options)) + .filter_map(Result::ok) + .flatten() + .filter_map(|p| { + let path = p.ok()?; + let filename = path.file_name()?.to_str().unwrap(); + + // The `libclang_shared` library has been renamed to `libclang-cpp` + // in Clang 10. This can cause instances of this library (e.g., + // `libclang-cpp.so.10`) to be matched by patterns looking for + // instances of `libclang`. + if filename.contains("-cpp.") { + return None; + } + + Some((directory.to_owned(), filename.into())) + }) + .collect::>() +} + +/// Finds the files in a directory (and any relevant sibling directories) that +/// match one or more filename glob patterns and returns the paths to and +/// filenames of those files. +fn search_directories(directory: &Path, filenames: &[String]) -> Vec<(PathBuf, String)> { + let mut results = search_directory(directory, filenames); + + // On Windows, `libclang.dll` is usually found in the LLVM `bin` directory + // while `libclang.lib` is usually found in the LLVM `lib` directory. To + // keep things consistent with other platforms, only LLVM `lib` directories + // are included in the backup search directory globs so we need to search + // the LLVM `bin` directory here. + if cfg!(target_os = "windows") && directory.ends_with("lib") { + let sibling = directory.parent().unwrap().join("bin"); + results.extend(search_directory(&sibling, filenames).into_iter()); + } + + results +} + +/// Finds the `libclang` static or dynamic libraries matching one or more +/// filename glob patterns and returns the paths to and filenames of those files. +pub fn search_libclang_directories(filenames: &[String], variable: &str) -> Vec<(PathBuf, String)> { + // Search only the path indicated by the relevant environment variable + // (e.g., `LIBCLANG_PATH`) if it is set. + if let Ok(path) = env::var(variable).map(|d| Path::new(&d).to_path_buf()) { + // Check if the path is a matching file. + if let Some(parent) = path.parent() { + let filename = path.file_name().unwrap().to_str().unwrap(); + let libraries = search_directories(parent, filenames); + if libraries.iter().any(|(_, f)| f == filename) { + return vec![(parent.into(), filename.into())]; + } + } + + // Check if the path is directory containing a matching file. + return search_directories(&path, filenames); + } + + let mut found = vec![]; + + // Search the `bin` and `lib` directories in the directory returned by + // `llvm-config --prefix`. + if let Some(output) = run_llvm_config(&["--prefix"]) { + let directory = Path::new(output.lines().next().unwrap()).to_path_buf(); + found.extend(search_directories(&directory.join("bin"), filenames)); + found.extend(search_directories(&directory.join("lib"), filenames)); + found.extend(search_directories(&directory.join("lib64"), filenames)); + } + + // Search the toolchain directory in the directory returned by + // `xcode-select --print-path`. + if cfg!(target_os = "macos") { + if let Some(output) = run_xcode_select(&["--print-path"]) { + let directory = Path::new(output.lines().next().unwrap()).to_path_buf(); + let directory = directory.join("Toolchains/XcodeDefault.xctoolchain/usr/lib"); + found.extend(search_directories(&directory, filenames)); + } + } + + // Search the directories in the `LD_LIBRARY_PATH` environment variable. + if let Ok(path) = env::var("LD_LIBRARY_PATH") { + for directory in env::split_paths(&path) { + found.extend(search_directories(&directory, filenames)); + } + } + + // Determine the `libclang` directory patterns. + let directories = if cfg!(target_os = "haiku") { + DIRECTORIES_HAIKU + } else if cfg!(any(target_os = "linux", target_os = "freebsd")) { + DIRECTORIES_LINUX + } else if cfg!(target_os = "macos") { + DIRECTORIES_MACOS + } else if cfg!(target_os = "windows") { + DIRECTORIES_WINDOWS + } else { + &[] + }; + + // Search the directories provided by the `libclang` directory patterns. + let mut options = MatchOptions::new(); + options.case_sensitive = false; + options.require_literal_separator = true; + for directory in directories.iter().rev() { + if let Ok(directories) = glob::glob_with(directory, options) { + for directory in directories.filter_map(Result::ok).filter(|p| p.is_dir()) { + found.extend(search_directories(&directory, filenames)); + } + } + } + + found +} diff --git a/external/rust/crates/clang-sys/out/dynamic.rs b/external/rust/crates/clang-sys/out/dynamic.rs new file mode 100644 index 0000000000..39247c803b --- /dev/null +++ b/external/rust/crates/clang-sys/out/dynamic.rs @@ -0,0 +1,262 @@ +// SPDX-License-Identifier: Apache-2.0 + +use std::env; +use std::fs::File; +use std::io::{self, Error, ErrorKind, Read, Seek, SeekFrom}; +use std::path::{Path, PathBuf}; + +use super::common; + +//================================================ +// Validation +//================================================ + +/// Extracts the ELF class from the ELF header in a shared library. +fn parse_elf_header(path: &Path) -> io::Result { + let mut file = File::open(path)?; + let mut buffer = [0; 5]; + file.read_exact(&mut buffer)?; + if buffer[..4] == [127, 69, 76, 70] { + Ok(buffer[4]) + } else { + Err(Error::new(ErrorKind::InvalidData, "invalid ELF header")) + } +} + +/// Extracts the magic number from the PE header in a shared library. +fn parse_pe_header(path: &Path) -> io::Result { + let mut file = File::open(path)?; + + // Extract the header offset. + let mut buffer = [0; 4]; + let start = SeekFrom::Start(0x3C); + file.seek(start)?; + file.read_exact(&mut buffer)?; + let offset = i32::from_le_bytes(buffer); + + // Check the validity of the header. + file.seek(SeekFrom::Start(offset as u64))?; + file.read_exact(&mut buffer)?; + if buffer != [80, 69, 0, 0] { + return Err(Error::new(ErrorKind::InvalidData, "invalid PE header")); + } + + // Extract the magic number. + let mut buffer = [0; 2]; + file.seek(SeekFrom::Current(20))?; + file.read_exact(&mut buffer)?; + Ok(u16::from_le_bytes(buffer)) +} + +/// Checks that a `libclang` shared library matches the target platform. +fn validate_library(path: &Path) -> Result<(), String> { + if cfg!(any(target_os = "linux", target_os = "freebsd")) { + let class = parse_elf_header(path).map_err(|e| e.to_string())?; + + if cfg!(target_pointer_width = "32") && class != 1 { + return Err("invalid ELF class (64-bit)".into()); + } + + if cfg!(target_pointer_width = "64") && class != 2 { + return Err("invalid ELF class (32-bit)".into()); + } + + Ok(()) + } else if cfg!(target_os = "windows") { + let magic = parse_pe_header(path).map_err(|e| e.to_string())?; + + if cfg!(target_pointer_width = "32") && magic != 267 { + return Err("invalid DLL (64-bit)".into()); + } + + if cfg!(target_pointer_width = "64") && magic != 523 { + return Err("invalid DLL (32-bit)".into()); + } + + Ok(()) + } else { + Ok(()) + } +} + +//================================================ +// Searching +//================================================ + +/// Extracts the version components in a `libclang` shared library filename. +fn parse_version(filename: &str) -> Vec { + let version = if let Some(version) = filename.strip_prefix("libclang.so.") { + version + } else if filename.starts_with("libclang-") { + &filename[9..filename.len() - 3] + } else { + return vec![]; + }; + + version.split('.').map(|s| s.parse().unwrap_or(0)).collect() +} + +/// Finds `libclang` shared libraries and returns the paths to, filenames of, +/// and versions of those shared libraries. +fn search_libclang_directories(runtime: bool) -> Result)>, String> { + let mut files = vec![format!( + "{}clang{}", + env::consts::DLL_PREFIX, + env::consts::DLL_SUFFIX + )]; + + if cfg!(target_os = "linux") { + // Some Linux distributions don't create a `libclang.so` symlink, so we + // need to look for versioned files (e.g., `libclang-3.9.so`). + files.push("libclang-*.so".into()); + + // Some Linux distributions don't create a `libclang.so` symlink and + // don't have versioned files as described above, so we need to look for + // suffix versioned files (e.g., `libclang.so.1`). However, `ld` cannot + // link to these files, so this will only be included when linking at + // runtime. + if runtime { + files.push("libclang.so.*".into()); + files.push("libclang-*.so.*".into()); + } + } + + if cfg!(any( + target_os = "freebsd", + target_os = "haiku", + target_os = "netbsd", + target_os = "openbsd", + )) { + // Some BSD distributions don't create a `libclang.so` symlink either, + // but use a different naming scheme for versioned files (e.g., + // `libclang.so.7.0`). + files.push("libclang.so.*".into()); + } + + if cfg!(target_os = "windows") { + // The official LLVM build uses `libclang.dll` on Windows instead of + // `clang.dll`. However, unofficial builds such as MinGW use `clang.dll`. + files.push("libclang.dll".into()); + } + + // Find and validate `libclang` shared libraries and collect the versions. + let mut valid = vec![]; + let mut invalid = vec![]; + for (directory, filename) in common::search_libclang_directories(&files, "LIBCLANG_PATH") { + let path = directory.join(&filename); + match validate_library(&path) { + Ok(()) => { + let version = parse_version(&filename); + valid.push((directory, filename, version)) + } + Err(message) => invalid.push(format!("({}: {})", path.display(), message)), + } + } + + if !valid.is_empty() { + return Ok(valid); + } + + let message = format!( + "couldn't find any valid shared libraries matching: [{}], set the \ + `LIBCLANG_PATH` environment variable to a path where one of these files \ + can be found (invalid: [{}])", + files + .iter() + .map(|f| format!("'{}'", f)) + .collect::>() + .join(", "), + invalid.join(", "), + ); + + Err(message) +} + +/// Finds the "best" `libclang` shared library and returns the directory and +/// filename of that library. +pub fn find(runtime: bool) -> Result<(PathBuf, String), String> { + search_libclang_directories(runtime)? + .iter() + // We want to find the `libclang` shared library with the highest + // version number, hence `max_by_key` below. + // + // However, in the case where there are multiple such `libclang` shared + // libraries, we want to use the order in which they appeared in the + // list returned by `search_libclang_directories` as a tiebreaker since + // that function returns `libclang` shared libraries in descending order + // of preference by how they were found. + // + // `max_by_key`, perhaps surprisingly, returns the *last* item with the + // maximum key rather than the first which results in the opposite of + // the tiebreaking behavior we want. This is easily fixed by reversing + // the list first. + .rev() + .max_by_key(|f| &f.2) + .cloned() + .map(|(path, filename, _)| (path, filename)) + .ok_or_else(|| "unreachable".into()) +} + +//================================================ +// Linking +//================================================ + +/// Finds and links to a `libclang` shared library. +#[cfg(not(feature = "runtime"))] +pub fn link() { + let cep = common::CommandErrorPrinter::default(); + + use std::fs; + + let (directory, filename) = find(false).unwrap(); + println!("cargo:rustc-link-search={}", directory.display()); + + if cfg!(all(target_os = "windows", target_env = "msvc")) { + // Find the `libclang` stub static library required for the MSVC + // toolchain. + let lib = if !directory.ends_with("bin") { + directory + } else { + directory.parent().unwrap().join("lib") + }; + + if lib.join("libclang.lib").exists() { + println!("cargo:rustc-link-search={}", lib.display()); + } else if lib.join("libclang.dll.a").exists() { + // MSYS and MinGW use `libclang.dll.a` instead of `libclang.lib`. + // It is linkable with the MSVC linker, but Rust doesn't recognize + // the `.a` suffix, so we need to copy it with a different name. + // + // FIXME: Maybe we can just hardlink or symlink it? + let out = env::var("OUT_DIR").unwrap(); + fs::copy( + lib.join("libclang.dll.a"), + Path::new(&out).join("libclang.lib"), + ) + .unwrap(); + println!("cargo:rustc-link-search=native={}", out); + } else { + panic!( + "using '{}', so 'libclang.lib' or 'libclang.dll.a' must be \ + available in {}", + filename, + lib.display(), + ); + } + + println!("cargo:rustc-link-lib=dylib=libclang"); + } else { + let name = filename.trim_start_matches("lib"); + + // Strip extensions and trailing version numbers (e.g., the `.so.7.0` in + // `libclang.so.7.0`). + let name = match name.find(".dylib").or_else(|| name.find(".so")) { + Some(index) => &name[0..index], + None => name, + }; + + println!("cargo:rustc-link-lib=dylib={}", name); + } + + cep.discard(); +} diff --git a/external/rust/crates/num-bigint/out/probe0.ll b/external/rust/crates/num-bigint/out/probe0.ll new file mode 100644 index 0000000000..75980c5015 --- /dev/null +++ b/external/rust/crates/num-bigint/out/probe0.ll @@ -0,0 +1,9 @@ +; ModuleID = 'probe0.990c8f4d-cgu.0' +source_filename = "probe0.990c8f4d-cgu.0" +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +!llvm.module.flags = !{!0, !1} + +!0 = !{i32 7, !"PIC Level", i32 2} +!1 = !{i32 2, !"RtLibUseGOT", i32 1} diff --git a/external/rust/crates/num-bigint/out/probe1.ll b/external/rust/crates/num-bigint/out/probe1.ll new file mode 100644 index 0000000000..c92f43c852 --- /dev/null +++ b/external/rust/crates/num-bigint/out/probe1.ll @@ -0,0 +1,9 @@ +; ModuleID = 'probe1.84fcdf3f-cgu.0' +source_filename = "probe1.84fcdf3f-cgu.0" +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +!llvm.module.flags = !{!0, !1} + +!0 = !{i32 7, !"PIC Level", i32 2} +!1 = !{i32 2, !"RtLibUseGOT", i32 1} diff --git a/external/rust/crates/num-bigint/out/probe2.ll b/external/rust/crates/num-bigint/out/probe2.ll new file mode 100644 index 0000000000..a286ca105c --- /dev/null +++ b/external/rust/crates/num-bigint/out/probe2.ll @@ -0,0 +1,9 @@ +; ModuleID = 'probe2.c1d38c83-cgu.0' +source_filename = "probe2.c1d38c83-cgu.0" +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +!llvm.module.flags = !{!0, !1} + +!0 = !{i32 7, !"PIC Level", i32 2} +!1 = !{i32 2, !"RtLibUseGOT", i32 1} diff --git a/external/rust/crates/num-bigint/out/probe3.ll b/external/rust/crates/num-bigint/out/probe3.ll new file mode 100644 index 0000000000..48c0ad3857 --- /dev/null +++ b/external/rust/crates/num-bigint/out/probe3.ll @@ -0,0 +1,9 @@ +; ModuleID = 'probe3.4a60c962-cgu.0' +source_filename = "probe3.4a60c962-cgu.0" +target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-unknown-linux-gnu" + +!llvm.module.flags = !{!0, !1} + +!0 = !{i32 7, !"PIC Level", i32 2} +!1 = !{i32 2, !"RtLibUseGOT", i32 1} diff --git a/external/rust/crates/num-bigint/out/radix_bases.rs b/external/rust/crates/num-bigint/out/radix_bases.rs new file mode 100644 index 0000000000..8702741a40 --- /dev/null +++ b/external/rust/crates/num-bigint/out/radix_bases.rs @@ -0,0 +1,780 @@ +#[deny(overflowing_literals)] +pub(crate) static BASES_16: [(u16, usize); 257] = [ + (0, 0), // 0 + (0, 0), // 1 + (0, 0), // 2 + (59049, 10), // 3 + (0, 0), // 4 + (15625, 6), // 5 + (46656, 6), // 6 + (16807, 5), // 7 + (0, 0), // 8 + (59049, 5), // 9 + (10000, 4), // 10 + (14641, 4), // 11 + (20736, 4), // 12 + (28561, 4), // 13 + (38416, 4), // 14 + (50625, 4), // 15 + (0, 0), // 16 + (4913, 3), // 17 + (5832, 3), // 18 + (6859, 3), // 19 + (8000, 3), // 20 + (9261, 3), // 21 + (10648, 3), // 22 + (12167, 3), // 23 + (13824, 3), // 24 + (15625, 3), // 25 + (17576, 3), // 26 + (19683, 3), // 27 + (21952, 3), // 28 + (24389, 3), // 29 + (27000, 3), // 30 + (29791, 3), // 31 + (0, 0), // 32 + (35937, 3), // 33 + (39304, 3), // 34 + (42875, 3), // 35 + (46656, 3), // 36 + (50653, 3), // 37 + (54872, 3), // 38 + (59319, 3), // 39 + (64000, 3), // 40 + (1681, 2), // 41 + (1764, 2), // 42 + (1849, 2), // 43 + (1936, 2), // 44 + (2025, 2), // 45 + (2116, 2), // 46 + (2209, 2), // 47 + (2304, 2), // 48 + (2401, 2), // 49 + (2500, 2), // 50 + (2601, 2), // 51 + (2704, 2), // 52 + (2809, 2), // 53 + (2916, 2), // 54 + (3025, 2), // 55 + (3136, 2), // 56 + (3249, 2), // 57 + (3364, 2), // 58 + (3481, 2), // 59 + (3600, 2), // 60 + (3721, 2), // 61 + (3844, 2), // 62 + (3969, 2), // 63 + (0, 0), // 64 + (4225, 2), // 65 + (4356, 2), // 66 + (4489, 2), // 67 + (4624, 2), // 68 + (4761, 2), // 69 + (4900, 2), // 70 + (5041, 2), // 71 + (5184, 2), // 72 + (5329, 2), // 73 + (5476, 2), // 74 + (5625, 2), // 75 + (5776, 2), // 76 + (5929, 2), // 77 + (6084, 2), // 78 + (6241, 2), // 79 + (6400, 2), // 80 + (6561, 2), // 81 + (6724, 2), // 82 + (6889, 2), // 83 + (7056, 2), // 84 + (7225, 2), // 85 + (7396, 2), // 86 + (7569, 2), // 87 + (7744, 2), // 88 + (7921, 2), // 89 + (8100, 2), // 90 + (8281, 2), // 91 + (8464, 2), // 92 + (8649, 2), // 93 + (8836, 2), // 94 + (9025, 2), // 95 + (9216, 2), // 96 + (9409, 2), // 97 + (9604, 2), // 98 + (9801, 2), // 99 + (10000, 2), // 100 + (10201, 2), // 101 + (10404, 2), // 102 + (10609, 2), // 103 + (10816, 2), // 104 + (11025, 2), // 105 + (11236, 2), // 106 + (11449, 2), // 107 + (11664, 2), // 108 + (11881, 2), // 109 + (12100, 2), // 110 + (12321, 2), // 111 + (12544, 2), // 112 + (12769, 2), // 113 + (12996, 2), // 114 + (13225, 2), // 115 + (13456, 2), // 116 + (13689, 2), // 117 + (13924, 2), // 118 + (14161, 2), // 119 + (14400, 2), // 120 + (14641, 2), // 121 + (14884, 2), // 122 + (15129, 2), // 123 + (15376, 2), // 124 + (15625, 2), // 125 + (15876, 2), // 126 + (16129, 2), // 127 + (0, 0), // 128 + (16641, 2), // 129 + (16900, 2), // 130 + (17161, 2), // 131 + (17424, 2), // 132 + (17689, 2), // 133 + (17956, 2), // 134 + (18225, 2), // 135 + (18496, 2), // 136 + (18769, 2), // 137 + (19044, 2), // 138 + (19321, 2), // 139 + (19600, 2), // 140 + (19881, 2), // 141 + (20164, 2), // 142 + (20449, 2), // 143 + (20736, 2), // 144 + (21025, 2), // 145 + (21316, 2), // 146 + (21609, 2), // 147 + (21904, 2), // 148 + (22201, 2), // 149 + (22500, 2), // 150 + (22801, 2), // 151 + (23104, 2), // 152 + (23409, 2), // 153 + (23716, 2), // 154 + (24025, 2), // 155 + (24336, 2), // 156 + (24649, 2), // 157 + (24964, 2), // 158 + (25281, 2), // 159 + (25600, 2), // 160 + (25921, 2), // 161 + (26244, 2), // 162 + (26569, 2), // 163 + (26896, 2), // 164 + (27225, 2), // 165 + (27556, 2), // 166 + (27889, 2), // 167 + (28224, 2), // 168 + (28561, 2), // 169 + (28900, 2), // 170 + (29241, 2), // 171 + (29584, 2), // 172 + (29929, 2), // 173 + (30276, 2), // 174 + (30625, 2), // 175 + (30976, 2), // 176 + (31329, 2), // 177 + (31684, 2), // 178 + (32041, 2), // 179 + (32400, 2), // 180 + (32761, 2), // 181 + (33124, 2), // 182 + (33489, 2), // 183 + (33856, 2), // 184 + (34225, 2), // 185 + (34596, 2), // 186 + (34969, 2), // 187 + (35344, 2), // 188 + (35721, 2), // 189 + (36100, 2), // 190 + (36481, 2), // 191 + (36864, 2), // 192 + (37249, 2), // 193 + (37636, 2), // 194 + (38025, 2), // 195 + (38416, 2), // 196 + (38809, 2), // 197 + (39204, 2), // 198 + (39601, 2), // 199 + (40000, 2), // 200 + (40401, 2), // 201 + (40804, 2), // 202 + (41209, 2), // 203 + (41616, 2), // 204 + (42025, 2), // 205 + (42436, 2), // 206 + (42849, 2), // 207 + (43264, 2), // 208 + (43681, 2), // 209 + (44100, 2), // 210 + (44521, 2), // 211 + (44944, 2), // 212 + (45369, 2), // 213 + (45796, 2), // 214 + (46225, 2), // 215 + (46656, 2), // 216 + (47089, 2), // 217 + (47524, 2), // 218 + (47961, 2), // 219 + (48400, 2), // 220 + (48841, 2), // 221 + (49284, 2), // 222 + (49729, 2), // 223 + (50176, 2), // 224 + (50625, 2), // 225 + (51076, 2), // 226 + (51529, 2), // 227 + (51984, 2), // 228 + (52441, 2), // 229 + (52900, 2), // 230 + (53361, 2), // 231 + (53824, 2), // 232 + (54289, 2), // 233 + (54756, 2), // 234 + (55225, 2), // 235 + (55696, 2), // 236 + (56169, 2), // 237 + (56644, 2), // 238 + (57121, 2), // 239 + (57600, 2), // 240 + (58081, 2), // 241 + (58564, 2), // 242 + (59049, 2), // 243 + (59536, 2), // 244 + (60025, 2), // 245 + (60516, 2), // 246 + (61009, 2), // 247 + (61504, 2), // 248 + (62001, 2), // 249 + (62500, 2), // 250 + (63001, 2), // 251 + (63504, 2), // 252 + (64009, 2), // 253 + (64516, 2), // 254 + (65025, 2), // 255 + (0, 0), // 256 +]; +#[deny(overflowing_literals)] +pub(crate) static BASES_32: [(u32, usize); 257] = [ + (0, 0), // 0 + (0, 0), // 1 + (0, 0), // 2 + (3486784401, 20), // 3 + (0, 0), // 4 + (1220703125, 13), // 5 + (2176782336, 12), // 6 + (1977326743, 11), // 7 + (0, 0), // 8 + (3486784401, 10), // 9 + (1000000000, 9), // 10 + (2357947691, 9), // 11 + (429981696, 8), // 12 + (815730721, 8), // 13 + (1475789056, 8), // 14 + (2562890625, 8), // 15 + (0, 0), // 16 + (410338673, 7), // 17 + (612220032, 7), // 18 + (893871739, 7), // 19 + (1280000000, 7), // 20 + (1801088541, 7), // 21 + (2494357888, 7), // 22 + (3404825447, 7), // 23 + (191102976, 6), // 24 + (244140625, 6), // 25 + (308915776, 6), // 26 + (387420489, 6), // 27 + (481890304, 6), // 28 + (594823321, 6), // 29 + (729000000, 6), // 30 + (887503681, 6), // 31 + (0, 0), // 32 + (1291467969, 6), // 33 + (1544804416, 6), // 34 + (1838265625, 6), // 35 + (2176782336, 6), // 36 + (2565726409, 6), // 37 + (3010936384, 6), // 38 + (3518743761, 6), // 39 + (4096000000, 6), // 40 + (115856201, 5), // 41 + (130691232, 5), // 42 + (147008443, 5), // 43 + (164916224, 5), // 44 + (184528125, 5), // 45 + (205962976, 5), // 46 + (229345007, 5), // 47 + (254803968, 5), // 48 + (282475249, 5), // 49 + (312500000, 5), // 50 + (345025251, 5), // 51 + (380204032, 5), // 52 + (418195493, 5), // 53 + (459165024, 5), // 54 + (503284375, 5), // 55 + (550731776, 5), // 56 + (601692057, 5), // 57 + (656356768, 5), // 58 + (714924299, 5), // 59 + (777600000, 5), // 60 + (844596301, 5), // 61 + (916132832, 5), // 62 + (992436543, 5), // 63 + (0, 0), // 64 + (1160290625, 5), // 65 + (1252332576, 5), // 66 + (1350125107, 5), // 67 + (1453933568, 5), // 68 + (1564031349, 5), // 69 + (1680700000, 5), // 70 + (1804229351, 5), // 71 + (1934917632, 5), // 72 + (2073071593, 5), // 73 + (2219006624, 5), // 74 + (2373046875, 5), // 75 + (2535525376, 5), // 76 + (2706784157, 5), // 77 + (2887174368, 5), // 78 + (3077056399, 5), // 79 + (3276800000, 5), // 80 + (3486784401, 5), // 81 + (3707398432, 5), // 82 + (3939040643, 5), // 83 + (4182119424, 5), // 84 + (52200625, 4), // 85 + (54700816, 4), // 86 + (57289761, 4), // 87 + (59969536, 4), // 88 + (62742241, 4), // 89 + (65610000, 4), // 90 + (68574961, 4), // 91 + (71639296, 4), // 92 + (74805201, 4), // 93 + (78074896, 4), // 94 + (81450625, 4), // 95 + (84934656, 4), // 96 + (88529281, 4), // 97 + (92236816, 4), // 98 + (96059601, 4), // 99 + (100000000, 4), // 100 + (104060401, 4), // 101 + (108243216, 4), // 102 + (112550881, 4), // 103 + (116985856, 4), // 104 + (121550625, 4), // 105 + (126247696, 4), // 106 + (131079601, 4), // 107 + (136048896, 4), // 108 + (141158161, 4), // 109 + (146410000, 4), // 110 + (151807041, 4), // 111 + (157351936, 4), // 112 + (163047361, 4), // 113 + (168896016, 4), // 114 + (174900625, 4), // 115 + (181063936, 4), // 116 + (187388721, 4), // 117 + (193877776, 4), // 118 + (200533921, 4), // 119 + (207360000, 4), // 120 + (214358881, 4), // 121 + (221533456, 4), // 122 + (228886641, 4), // 123 + (236421376, 4), // 124 + (244140625, 4), // 125 + (252047376, 4), // 126 + (260144641, 4), // 127 + (0, 0), // 128 + (276922881, 4), // 129 + (285610000, 4), // 130 + (294499921, 4), // 131 + (303595776, 4), // 132 + (312900721, 4), // 133 + (322417936, 4), // 134 + (332150625, 4), // 135 + (342102016, 4), // 136 + (352275361, 4), // 137 + (362673936, 4), // 138 + (373301041, 4), // 139 + (384160000, 4), // 140 + (395254161, 4), // 141 + (406586896, 4), // 142 + (418161601, 4), // 143 + (429981696, 4), // 144 + (442050625, 4), // 145 + (454371856, 4), // 146 + (466948881, 4), // 147 + (479785216, 4), // 148 + (492884401, 4), // 149 + (506250000, 4), // 150 + (519885601, 4), // 151 + (533794816, 4), // 152 + (547981281, 4), // 153 + (562448656, 4), // 154 + (577200625, 4), // 155 + (592240896, 4), // 156 + (607573201, 4), // 157 + (623201296, 4), // 158 + (639128961, 4), // 159 + (655360000, 4), // 160 + (671898241, 4), // 161 + (688747536, 4), // 162 + (705911761, 4), // 163 + (723394816, 4), // 164 + (741200625, 4), // 165 + (759333136, 4), // 166 + (777796321, 4), // 167 + (796594176, 4), // 168 + (815730721, 4), // 169 + (835210000, 4), // 170 + (855036081, 4), // 171 + (875213056, 4), // 172 + (895745041, 4), // 173 + (916636176, 4), // 174 + (937890625, 4), // 175 + (959512576, 4), // 176 + (981506241, 4), // 177 + (1003875856, 4), // 178 + (1026625681, 4), // 179 + (1049760000, 4), // 180 + (1073283121, 4), // 181 + (1097199376, 4), // 182 + (1121513121, 4), // 183 + (1146228736, 4), // 184 + (1171350625, 4), // 185 + (1196883216, 4), // 186 + (1222830961, 4), // 187 + (1249198336, 4), // 188 + (1275989841, 4), // 189 + (1303210000, 4), // 190 + (1330863361, 4), // 191 + (1358954496, 4), // 192 + (1387488001, 4), // 193 + (1416468496, 4), // 194 + (1445900625, 4), // 195 + (1475789056, 4), // 196 + (1506138481, 4), // 197 + (1536953616, 4), // 198 + (1568239201, 4), // 199 + (1600000000, 4), // 200 + (1632240801, 4), // 201 + (1664966416, 4), // 202 + (1698181681, 4), // 203 + (1731891456, 4), // 204 + (1766100625, 4), // 205 + (1800814096, 4), // 206 + (1836036801, 4), // 207 + (1871773696, 4), // 208 + (1908029761, 4), // 209 + (1944810000, 4), // 210 + (1982119441, 4), // 211 + (2019963136, 4), // 212 + (2058346161, 4), // 213 + (2097273616, 4), // 214 + (2136750625, 4), // 215 + (2176782336, 4), // 216 + (2217373921, 4), // 217 + (2258530576, 4), // 218 + (2300257521, 4), // 219 + (2342560000, 4), // 220 + (2385443281, 4), // 221 + (2428912656, 4), // 222 + (2472973441, 4), // 223 + (2517630976, 4), // 224 + (2562890625, 4), // 225 + (2608757776, 4), // 226 + (2655237841, 4), // 227 + (2702336256, 4), // 228 + (2750058481, 4), // 229 + (2798410000, 4), // 230 + (2847396321, 4), // 231 + (2897022976, 4), // 232 + (2947295521, 4), // 233 + (2998219536, 4), // 234 + (3049800625, 4), // 235 + (3102044416, 4), // 236 + (3154956561, 4), // 237 + (3208542736, 4), // 238 + (3262808641, 4), // 239 + (3317760000, 4), // 240 + (3373402561, 4), // 241 + (3429742096, 4), // 242 + (3486784401, 4), // 243 + (3544535296, 4), // 244 + (3603000625, 4), // 245 + (3662186256, 4), // 246 + (3722098081, 4), // 247 + (3782742016, 4), // 248 + (3844124001, 4), // 249 + (3906250000, 4), // 250 + (3969126001, 4), // 251 + (4032758016, 4), // 252 + (4097152081, 4), // 253 + (4162314256, 4), // 254 + (4228250625, 4), // 255 + (0, 0), // 256 +]; +#[deny(overflowing_literals)] +pub(crate) static BASES_64: [(u64, usize); 257] = [ + (0, 0), // 0 + (0, 0), // 1 + (0, 0), // 2 + (12157665459056928801, 40), // 3 + (0, 0), // 4 + (7450580596923828125, 27), // 5 + (4738381338321616896, 24), // 6 + (3909821048582988049, 22), // 7 + (0, 0), // 8 + (12157665459056928801, 20), // 9 + (10000000000000000000, 19), // 10 + (5559917313492231481, 18), // 11 + (2218611106740436992, 17), // 12 + (8650415919381337933, 17), // 13 + (2177953337809371136, 16), // 14 + (6568408355712890625, 16), // 15 + (0, 0), // 16 + (2862423051509815793, 15), // 17 + (6746640616477458432, 15), // 18 + (15181127029874798299, 15), // 19 + (1638400000000000000, 14), // 20 + (3243919932521508681, 14), // 21 + (6221821273427820544, 14), // 22 + (11592836324538749809, 14), // 23 + (876488338465357824, 13), // 24 + (1490116119384765625, 13), // 25 + (2481152873203736576, 13), // 26 + (4052555153018976267, 13), // 27 + (6502111422497947648, 13), // 28 + (10260628712958602189, 13), // 29 + (15943230000000000000, 13), // 30 + (787662783788549761, 12), // 31 + (0, 0), // 32 + (1667889514952984961, 12), // 33 + (2386420683693101056, 12), // 34 + (3379220508056640625, 12), // 35 + (4738381338321616896, 12), // 36 + (6582952005840035281, 12), // 37 + (9065737908494995456, 12), // 38 + (12381557655576425121, 12), // 39 + (16777216000000000000, 12), // 40 + (550329031716248441, 11), // 41 + (717368321110468608, 11), // 42 + (929293739471222707, 11), // 43 + (1196683881290399744, 11), // 44 + (1532278301220703125, 11), // 45 + (1951354384207722496, 11), // 46 + (2472159215084012303, 11), // 47 + (3116402981210161152, 11), // 48 + (3909821048582988049, 11), // 49 + (4882812500000000000, 11), // 50 + (6071163615208263051, 11), // 51 + (7516865509350965248, 11), // 52 + (9269035929372191597, 11), // 53 + (11384956040305711104, 11), // 54 + (13931233916552734375, 11), // 55 + (16985107389382393856, 11), // 56 + (362033331456891249, 10), // 57 + (430804206899405824, 10), // 58 + (511116753300641401, 10), // 59 + (604661760000000000, 10), // 60 + (713342911662882601, 10), // 61 + (839299365868340224, 10), // 62 + (984930291881790849, 10), // 63 + (0, 0), // 64 + (1346274334462890625, 10), // 65 + (1568336880910795776, 10), // 66 + (1822837804551761449, 10), // 67 + (2113922820157210624, 10), // 68 + (2446194060654759801, 10), // 69 + (2824752490000000000, 10), // 70 + (3255243551009881201, 10), // 71 + (3743906242624487424, 10), // 72 + (4297625829703557649, 10), // 73 + (4923990397355877376, 10), // 74 + (5631351470947265625, 10), // 75 + (6428888932339941376, 10), // 76 + (7326680472586200649, 10), // 77 + (8335775831236199424, 10), // 78 + (9468276082626847201, 10), // 79 + (10737418240000000000, 10), // 80 + (12157665459056928801, 10), // 81 + (13744803133596058624, 10), // 82 + (15516041187205853449, 10), // 83 + (17490122876598091776, 10), // 84 + (231616946283203125, 9), // 85 + (257327417311663616, 9), // 86 + (285544154243029527, 9), // 87 + (316478381828866048, 9), // 88 + (350356403707485209, 9), // 89 + (387420489000000000, 9), // 90 + (427929800129788411, 9), // 91 + (472161363286556672, 9), // 92 + (520411082988487293, 9), // 93 + (572994802228616704, 9), // 94 + (630249409724609375, 9), // 95 + (692533995824480256, 9), // 96 + (760231058654565217, 9), // 97 + (833747762130149888, 9), // 98 + (913517247483640899, 9), // 99 + (1000000000000000000, 9), // 100 + (1093685272684360901, 9), // 101 + (1195092568622310912, 9), // 102 + (1304773183829244583, 9), // 103 + (1423311812421484544, 9), // 104 + (1551328215978515625, 9), // 105 + (1689478959002692096, 9), // 106 + (1838459212420154507, 9), // 107 + (1999004627104432128, 9), // 108 + (2171893279442309389, 9), // 109 + (2357947691000000000, 9), // 110 + (2558036924386500591, 9), // 111 + (2773078757450186752, 9), // 112 + (3004041937984268273, 9), // 113 + (3251948521156637184, 9), // 114 + (3517876291919921875, 9), // 115 + (3802961274698203136, 9), // 116 + (4108400332687853397, 9), // 117 + (4435453859151328768, 9), // 118 + (4785448563124474679, 9), // 119 + (5159780352000000000, 9), // 120 + (5559917313492231481, 9), // 121 + (5987402799531080192, 9), // 122 + (6443858614676334363, 9), // 123 + (6930988311686938624, 9), // 124 + (7450580596923828125, 9), // 125 + (8004512848309157376, 9), // 126 + (8594754748609397887, 9), // 127 + (0, 0), // 128 + (9892530380752880769, 9), // 129 + (10604499373000000000, 9), // 130 + (11361656654439817571, 9), // 131 + (12166492167065567232, 9), // 132 + (13021612539908538853, 9), // 133 + (13929745610903012864, 9), // 134 + (14893745087865234375, 9), // 135 + (15916595351771938816, 9), // 136 + (17001416405572203977, 9), // 137 + (18151468971815029248, 9), // 138 + (139353667211683681, 8), // 139 + (147578905600000000, 8), // 140 + (156225851787813921, 8), // 141 + (165312903998914816, 8), // 142 + (174859124550883201, 8), // 143 + (184884258895036416, 8), // 144 + (195408755062890625, 8), // 145 + (206453783524884736, 8), // 146 + (218041257467152161, 8), // 147 + (230193853492166656, 8), // 148 + (242935032749128801, 8), // 149 + (256289062500000000, 8), // 150 + (270281038127131201, 8), // 151 + (284936905588473856, 8), // 152 + (300283484326400961, 8), // 153 + (316348490636206336, 8), // 154 + (333160561500390625, 8), // 155 + (350749278894882816, 8), // 156 + (369145194573386401, 8), // 157 + (388379855336079616, 8), // 158 + (408485828788939521, 8), // 159 + (429496729600000000, 8), // 160 + (451447246258894081, 8), // 161 + (474373168346071296, 8), // 162 + (498311414318121121, 8), // 163 + (523300059815673856, 8), // 164 + (549378366500390625, 8), // 165 + (576586811427594496, 8), // 166 + (604967116961135041, 8), // 167 + (634562281237118976, 8), // 168 + (665416609183179841, 8), // 169 + (697575744100000000, 8), // 170 + (731086699811838561, 8), // 171 + (765997893392859136, 8), // 172 + (802359178476091681, 8), // 173 + (840221879151902976, 8), // 174 + (879638824462890625, 8), // 175 + (920664383502155776, 8), // 176 + (963354501121950081, 8), // 177 + (1007766734259732736, 8), // 178 + (1053960288888713761, 8), // 179 + (1101996057600000000, 8), // 180 + (1151936657823500641, 8), // 181 + (1203846470694789376, 8), // 182 + (1257791680575160641, 8), // 183 + (1313840315232157696, 8), // 184 + (1372062286687890625, 8), // 185 + (1432529432742502656, 8), // 186 + (1495315559180183521, 8), // 187 + (1560496482665168896, 8), // 188 + (1628150074335205281, 8), // 189 + (1698356304100000000, 8), // 190 + (1771197285652216321, 8), // 191 + (1846757322198614016, 8), // 192 + (1925122952918976001, 8), // 193 + (2006383000160502016, 8), // 194 + (2090628617375390625, 8), // 195 + (2177953337809371136, 8), // 196 + (2268453123948987361, 8), // 197 + (2362226417735475456, 8), // 198 + (2459374191553118401, 8), // 199 + (2560000000000000000, 8), // 200 + (2664210032449121601, 8), // 201 + (2772113166407885056, 8), // 202 + (2883821021683985761, 8), // 203 + (2999448015365799936, 8), // 204 + (3119111417625390625, 8), // 205 + (3242931408352297216, 8), // 206 + (3371031134626313601, 8), // 207 + (3503536769037500416, 8), // 208 + (3640577568861717121, 8), // 209 + (3782285936100000000, 8), // 210 + (3928797478390152481, 8), // 211 + (4080251070798954496, 8), // 212 + (4236788918503437921, 8), // 213 + (4398556620369715456, 8), // 214 + (4565703233437890625, 8), // 215 + (4738381338321616896, 8), // 216 + (4916747105530914241, 8), // 217 + (5100960362726891776, 8), // 218 + (5291184662917065441, 8), // 219 + (5487587353600000000, 8), // 220 + (5690339646868044961, 8), // 221 + (5899616690476974336, 8), // 222 + (6115597639891380481, 8), // 223 + (6338465731314712576, 8), // 224 + (6568408355712890625, 8), // 225 + (6805617133840466176, 8), // 226 + (7050287992278341281, 8), // 227 + (7302621240492097536, 8), // 228 + (7562821648920027361, 8), // 229 + (7831098528100000000, 8), // 230 + (8107665808844335041, 8), // 231 + (8392742123471896576, 8), // 232 + (8686550888106661441, 8), // 233 + (8989320386052055296, 8), // 234 + (9301283852250390625, 8), // 235 + (9622679558836781056, 8), // 236 + (9953750901796946721, 8), // 237 + (10294746488738365696, 8), // 238 + (10645920227784266881, 8), // 239 + (11007531417600000000, 8), // 240 + (11379844838561358721, 8), // 241 + (11763130845074473216, 8), // 242 + (12157665459056928801, 8), // 243 + (12563730464589807616, 8), // 244 + (12981613503750390625, 8), // 245 + (13411608173635297536, 8), // 246 + (13854014124583882561, 8), // 247 + (14309137159611744256, 8), // 248 + (14777289335064248001, 8), // 249 + (15258789062500000000, 8), // 250 + (15753961211814252001, 8), // 251 + (16263137215612256256, 8), // 252 + (16786655174842630561, 8), // 253 + (17324859965700833536, 8), // 254 + (17878103347812890625, 8), // 255 + (0, 0), // 256 +]; diff --git a/external/rust/crates/oid-registry/out/oid_db.rs b/external/rust/crates/oid-registry/out/oid_db.rs new file mode 100644 index 0000000000..b5fe081bae --- /dev/null +++ b/external/rust/crates/oid-registry/out/oid_db.rs @@ -0,0 +1,415 @@ +/// 1.3.133.16.840.63.0.2 +pub const OID_KDF_SHA1_SINGLE: Oid<'static> = oid!(1.3.133.16.840.63.0.2); +/// 1.3.6.1.4.1.311.2.1.4 +pub const SPC_INDIRECT_DATA_OBJID: Oid<'static> = oid!(1.3.6.1.4.1.311.2.1.4); +/// 1.3.6.1.4.1.311.2.1.11 +pub const SPC_STATEMENT_TYPE_OBJID: Oid<'static> = oid!(1.3.6.1.4.1.311.2.1.11); +/// 1.3.6.1.4.1.311.2.1.12 +pub const SPC_SP_OPUS_INFO_OBJID: Oid<'static> = oid!(1.3.6.1.4.1.311.2.1.12); +/// 1.3.6.1.4.1.311.2.1.15 +pub const SPC_PE_IMAGE_DATA: Oid<'static> = oid!(1.3.6.1.4.1.311.2.1.15); +/// 1.3.6.1.4.1.311.2.1.21 +pub const SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID : Oid<'static> = oid!(1.3.6.1.4.1.311.2.1.21); +/// 1.3.6.1.4.1.311.10.1 +pub const MS_CTL: Oid<'static> = oid!(1.3.6.1.4.1.311.10.1); +/// 1.3.132.0.34 +pub const OID_NIST_EC_P384: Oid<'static> = oid!(1.3.132.0.34); +/// 1.3.132.0.35 +pub const OID_NIST_EC_P521: Oid<'static> = oid!(1.3.132.0.35); +/// 1.3.14.3.2.26 +pub const OID_HASH_SHA1: Oid<'static> = oid!(1.3.14.3.2.26); +/// 2.16.840.1.101.3.4.1.42 +pub const OID_NIST_ENC_AES256_CBC: Oid<'static> = oid!(2.16.840.1.101.3.4.1.42); +/// 2.16.840.1.101.3.4.2.1 +pub const OID_NIST_HASH_SHA256: Oid<'static> = oid!(2.16.840.1.101.3.4.2.1); +/// 2.16.840.1.101.3.4.2.2 +pub const OID_NIST_HASH_SHA384: Oid<'static> = oid!(2.16.840.1.101.3.4.2.2); +/// 2.16.840.1.101.3.4.2.3 +pub const OID_NIST_HASH_SHA512: Oid<'static> = oid!(2.16.840.1.101.3.4.2.3); +/// 1.2.840.113549.1.1.1 +pub const OID_PKCS1_RSAENCRYPTION: Oid<'static> = oid!(1.2.840.113549.1.1.1); +/// 1.2.840.113549.1.1.2 +pub const OID_PKCS1_MD2WITHRSAENC: Oid<'static> = oid!(1.2.840.113549.1.1.2); +/// 1.2.840.113549.1.1.3 +pub const OID_PKCS1_MD4WITHRSAENC: Oid<'static> = oid!(1.2.840.113549.1.1.3); +/// 1.2.840.113549.1.1.4 +pub const OID_PKCS1_MD5WITHRSAENC: Oid<'static> = oid!(1.2.840.113549.1.1.4); +/// 1.2.840.113549.1.1.5 +pub const OID_PKCS1_SHA1WITHRSA: Oid<'static> = oid!(1.2.840.113549.1.1.5); +/// 1.2.840.113549.1.1.10 +pub const OID_PKCS1_RSASSAPSS: Oid<'static> = oid!(1.2.840.113549.1.1.10); +/// 1.2.840.113549.1.1.11 +pub const OID_PKCS1_SHA256WITHRSA: Oid<'static> = oid!(1.2.840.113549.1.1.11); +/// 1.2.840.113549.1.1.12 +pub const OID_PKCS1_SHA384WITHRSA: Oid<'static> = oid!(1.2.840.113549.1.1.12); +/// 1.2.840.113549.1.1.13 +pub const OID_PKCS1_SHA512WITHRSA: Oid<'static> = oid!(1.2.840.113549.1.1.13); +/// 1.2.840.113549.1.1.14 +pub const OID_PKCS1_SHA224WITHRSA: Oid<'static> = oid!(1.2.840.113549.1.1.14); +/// 1.2.840.113549.1.12 +pub const OID_PKCS12: Oid<'static> = oid!(1.2.840.113549.1.12); +/// 1.2.840.113549.1.12.1 +pub const OID_PKCS12_PBEIDS: Oid<'static> = oid!(1.2.840.113549.1.12.1); +/// 1.2.840.113549.1.12.1.1 +pub const OID_PKCS12_PBE_SHA1_128RC4: Oid<'static> = oid!(1.2.840.113549.1.12.1.1); +/// 1.2.840.113549.1.12.1.2 +pub const OID_PKCS12_PBE_SHA1_40RC4: Oid<'static> = oid!(1.2.840.113549.1.12.1.2); +/// 1.2.840.113549.1.12.1.3 +pub const OID_PKCS12_PBE_SHA1_3K_3DES_CBC: Oid<'static> = oid!(1.2.840.113549.1.12.1.3); +/// 1.2.840.113549.1.12.1.4 +pub const OID_PKCS12_PBE_SHA1_2K_3DES_CBC: Oid<'static> = oid!(1.2.840.113549.1.12.1.4); +/// 1.2.840.113549.1.12.1.5 +pub const OID_PKCS12_PBE_SHA1_128RC2_CBC: Oid<'static> = oid!(1.2.840.113549.1.12.1.5); +/// 1.2.840.113549.1.12.1.6 +pub const OID_PKCS12_PBE_SHA1_40RC2_CBC: Oid<'static> = oid!(1.2.840.113549.1.12.1.6); +/// 1.2.840.113549.1.7.1 +pub const OID_PKCS7_ID_DATA: Oid<'static> = oid!(1.2.840.113549.1.7.1); +/// 1.2.840.113549.1.7.2 +pub const OID_PKCS7_ID_SIGNED_DATA: Oid<'static> = oid!(1.2.840.113549.1.7.2); +/// 1.2.840.113549.1.7.3 +pub const OID_PKCS7_ID_ENVELOPED_DATA: Oid<'static> = oid!(1.2.840.113549.1.7.3); +/// 1.2.840.113549.1.7.4 +pub const OID_PKCS7_ID_SIGNED_ENVELOPED_DATA: Oid<'static> = oid!(1.2.840.113549.1.7.4); +/// 1.2.840.113549.1.7.5 +pub const OID_PKCS7_ID_DIGESTED_DATA: Oid<'static> = oid!(1.2.840.113549.1.7.5); +/// 1.2.840.113549.1.7.6 +pub const OID_PKCS7_ID_ENCRYPTED_DATA: Oid<'static> = oid!(1.2.840.113549.1.7.6); +/// 1.2.840.113549.1.9.1 +pub const OID_PKCS9_EMAIL_ADDRESS: Oid<'static> = oid!(1.2.840.113549.1.9.1); +/// 1.2.840.113549.1.9.2 +pub const OID_PKCS9_UNSTRUCTURED_NAME: Oid<'static> = oid!(1.2.840.113549.1.9.2); +/// 1.2.840.113549.1.9.3 +pub const OID_PKCS9_CONTENT_TYPE: Oid<'static> = oid!(1.2.840.113549.1.9.3); +/// 1.2.840.113549.1.9.4 +pub const OID_PKCS9_ID_MESSAGE_DIGEST: Oid<'static> = oid!(1.2.840.113549.1.9.4); +/// 1.2.840.113549.1.9.5 +pub const OID_PKCS9_SIGNING_TIME: Oid<'static> = oid!(1.2.840.113549.1.9.5); +/// 1.2.840.113549.1.9.14 +pub const OID_PKCS9_EXTENSION_REQUEST: Oid<'static> = oid!(1.2.840.113549.1.9.14); +/// 1.2.840.113549.1.9.15 +pub const OID_PKCS9_SMIME_CAPABILITIES: Oid<'static> = oid!(1.2.840.113549.1.9.15); +/// 2.5 +pub const OID_X500: Oid<'static> = oid!(2.5); +/// 0.9.2342.19200300.100.1.25 +pub const OID_DOMAIN_COMPONENT: Oid<'static> = oid!(0.9.2342.19200300.100.1.25); +/// 1.3.101.112 +pub const OID_SIG_ED25519: Oid<'static> = oid!(1.3.101.112); +/// 1.3.101.113 +pub const OID_SIG_ED448: Oid<'static> = oid!(1.3.101.113); +/// 1.3.6.1.4.1.11129.2.4.2 +pub const OID_CT_LIST_SCT: Oid<'static> = oid!(1.3.6.1.4.1.11129.2.4.2); +/// 1.3.6.1.5.5.7.1.1 +pub const OID_PKIX_AUTHORITY_INFO_ACCESS: Oid<'static> = oid!(1.3.6.1.5.5.7.1.1); +/// 1.3.6.1.5.5.7.48.1 +pub const OID_PKIX_ACCESS_DESCRIPTOR_OCSP: Oid<'static> = oid!(1.3.6.1.5.5.7.48.1); +/// 1.3.6.1.5.5.7.48.2 +pub const OID_PKIX_ACCESS_DESCRIPTOR_CA_ISSUERS: Oid<'static> = oid!(1.3.6.1.5.5.7.48.2); +/// 1.3.6.1.5.5.7.48.3 +pub const OID_PKIX_ACCESS_DESCRIPTOR_TIMESTAMPING: Oid<'static> = oid!(1.3.6.1.5.5.7.48.3); +/// 1.3.6.1.5.5.7.48.4 +pub const OID_PKIX_ACCESS_DESCRIPTOR_DVCS: Oid<'static> = oid!(1.3.6.1.5.5.7.48.4); +/// 1.3.6.1.5.5.7.48.5 +pub const OID_PKIX_ACCESS_DESCRIPTOR_CA_REPOSITORY: Oid<'static> = oid!(1.3.6.1.5.5.7.48.5); +/// 1.3.6.1.5.5.7.48.6 +pub const OID_PKIX_ACCESS_DESCRIPTOR_HTTP_CERTS: Oid<'static> = oid!(1.3.6.1.5.5.7.48.6); +/// 1.3.6.1.5.5.7.48.7 +pub const OID_PKIX_ACCESS_DESCRIPTOR_HTTP_CRLS: Oid<'static> = oid!(1.3.6.1.5.5.7.48.7); +/// 1.3.6.1.5.5.7.48.10 +pub const OID_PKIX_ACCESS_DESCRIPTOR_RPKI_MANIFEST: Oid<'static> = oid!(1.3.6.1.5.5.7.48.10); +/// 1.3.6.1.5.5.7.48.11 +pub const OID_PKIX_ACCESS_DESCRIPTOR_SIGNED_OBJECT: Oid<'static> = oid!(1.3.6.1.5.5.7.48.11); +/// 1.3.6.1.5.5.7.48.12 +pub const OID_PKIX_ACCESS_DESCRIPTOR_CMC: Oid<'static> = oid!(1.3.6.1.5.5.7.48.12); +/// 1.3.6.1.5.5.7.48.13 +pub const OID_PKIX_ACCESS_DESCRIPTOR_RPKI_NOTIFY: Oid<'static> = oid!(1.3.6.1.5.5.7.48.13); +/// 1.3.6.1.5.5.7.48.14 +pub const OID_PKIX_ACCESS_DESCRIPTOR_STIRTNLIST: Oid<'static> = oid!(1.3.6.1.5.5.7.48.14); +/// 2.5.4 +pub const OID_X509: Oid<'static> = oid!(2.5.4); +/// 2.5.4.0 +pub const OID_X509_OBJECT_CLASS: Oid<'static> = oid!(2.5.4.0); +/// 2.5.4.1 +pub const OID_X509_ALIASED_ENTRY_NAME: Oid<'static> = oid!(2.5.4.1); +/// 2.5.4.2 +pub const OID_X509_KNOWLEDGE_INFORMATION: Oid<'static> = oid!(2.5.4.2); +/// 2.5.4.3 +pub const OID_X509_COMMON_NAME: Oid<'static> = oid!(2.5.4.3); +/// 2.5.4.4 +pub const OID_X509_SURNAME: Oid<'static> = oid!(2.5.4.4); +/// 2.5.4.5 +pub const OID_X509_SERIALNUMBER: Oid<'static> = oid!(2.5.4.5); +/// 2.5.4.6 +pub const OID_X509_COUNTRY_NAME: Oid<'static> = oid!(2.5.4.6); +/// 2.5.4.7 +pub const OID_X509_LOCALITY_NAME: Oid<'static> = oid!(2.5.4.7); +/// 2.5.4.8 +pub const OID_X509_STATE_OR_PROVINCE_NAME: Oid<'static> = oid!(2.5.4.8); +/// 2.5.4.9 +pub const OID_X509_STREET_ADDRESS: Oid<'static> = oid!(2.5.4.9); +/// 2.5.4.10 +pub const OID_X509_ORGANIZATION_NAME: Oid<'static> = oid!(2.5.4.10); +/// 2.5.4.11 +pub const OID_X509_ORGANIZATIONAL_UNIT: Oid<'static> = oid!(2.5.4.11); +/// 2.5.4.12 +pub const OID_X509_TITLE: Oid<'static> = oid!(2.5.4.12); +/// 2.5.4.13 +pub const OID_X509_DESCRIPTION: Oid<'static> = oid!(2.5.4.13); +/// 2.5.4.14 +pub const OID_X509_SEARCH_GUIDE: Oid<'static> = oid!(2.5.4.14); +/// 2.5.4.15 +pub const OID_X509_BUSINESS_CATEGORY: Oid<'static> = oid!(2.5.4.15); +/// 2.5.4.16 +pub const OID_X509_POSTAL_ADDRESS: Oid<'static> = oid!(2.5.4.16); +/// 2.5.4.17 +pub const OID_X509_POSTAL_CODE: Oid<'static> = oid!(2.5.4.17); +/// 2.5.4.41 +pub const OID_X509_NAME: Oid<'static> = oid!(2.5.4.41); +/// 2.5.4.42 +pub const OID_X509_GIVEN_NAME: Oid<'static> = oid!(2.5.4.42); +/// 2.5.4.45 +pub const OID_X509_UNIQUE_IDENTIFIER: Oid<'static> = oid!(2.5.4.45); +/// 2.5.29.14 +pub const OID_X509_EXT_SUBJECT_KEY_IDENTIFIER: Oid<'static> = oid!(2.5.29.14); +/// 2.5.29.15 +pub const OID_X509_EXT_KEY_USAGE: Oid<'static> = oid!(2.5.29.15); +/// 2.5.29.16 +pub const OID_X509_EXT_PRIVATE_KEY_USAGE_PERIOD: Oid<'static> = oid!(2.5.29.16); +/// 2.5.29.17 +pub const OID_X509_EXT_SUBJECT_ALT_NAME: Oid<'static> = oid!(2.5.29.17); +/// 2.5.29.18 +pub const OID_X509_EXT_ISSUER_ALT_NAME: Oid<'static> = oid!(2.5.29.18); +/// 2.5.29.19 +pub const OID_X509_EXT_BASIC_CONSTRAINTS: Oid<'static> = oid!(2.5.29.19); +/// 2.5.29.20 +pub const OID_X509_EXT_CRL_NUMBER: Oid<'static> = oid!(2.5.29.20); +/// 2.5.29.21 +pub const OID_X509_EXT_REASON_CODE: Oid<'static> = oid!(2.5.29.21); +/// 2.5.29.23 +pub const OID_X509_EXT_HOLD_INSTRUCTION_CODE: Oid<'static> = oid!(2.5.29.23); +/// 2.5.29.24 +pub const OID_X509_EXT_INVALIDITY_DATE: Oid<'static> = oid!(2.5.29.24); +/// 2.5.29.27 +pub const OID_X509_EXT_DELTA_CRL_INDICATOR: Oid<'static> = oid!(2.5.29.27); +/// 2.5.29.28 +pub const OID_X509_EXT_ISSUER_DISTRIBUTION_POINT: Oid<'static> = oid!(2.5.29.28); +/// 2.5.29.29 +pub const OID_X509_EXT_ISSUER: Oid<'static> = oid!(2.5.29.29); +/// 2.5.29.30 +pub const OID_X509_EXT_NAME_CONSTRAINTS: Oid<'static> = oid!(2.5.29.30); +/// 2.5.29.31 +pub const OID_X509_EXT_CRL_DISTRIBUTION_POINTS: Oid<'static> = oid!(2.5.29.31); +/// 2.5.29.32 +pub const OID_X509_EXT_CERTIFICATE_POLICIES: Oid<'static> = oid!(2.5.29.32); +/// 2.5.29.33 +pub const OID_X509_EXT_POLICY_MAPPINGS: Oid<'static> = oid!(2.5.29.33); +/// 2.5.29.35 +pub const OID_X509_EXT_AUTHORITY_KEY_IDENTIFIER: Oid<'static> = oid!(2.5.29.35); +/// 2.5.29.36 +pub const OID_X509_EXT_POLICY_CONSTRAINTS: Oid<'static> = oid!(2.5.29.36); +/// 2.5.29.37 +pub const OID_X509_EXT_EXTENDED_KEY_USAGE: Oid<'static> = oid!(2.5.29.37); +/// 2.5.29.46 +pub const OID_X509_EXT_FRESHEST_CRL: Oid<'static> = oid!(2.5.29.46); +/// 2.5.29.54 +pub const OID_X509_EXT_INHIBITANT_ANY_POLICY: Oid<'static> = oid!(2.5.29.54); +/// 2.16.840.1.113730.1.1 +pub const OID_X509_EXT_CERT_TYPE: Oid<'static> = oid!(2.16.840.1.113730.1.1); +/// 1.2.840.10045.2.1 +pub const OID_KEY_TYPE_EC_PUBLIC_KEY: Oid<'static> = oid!(1.2.840.10045.2.1); +/// 1.2.840.10045.4.3.1 +pub const OID_SIG_ECDSA_WITH_SHA224: Oid<'static> = oid!(1.2.840.10045.4.3.1); +/// 1.2.840.10045.4.3.2 +pub const OID_SIG_ECDSA_WITH_SHA256: Oid<'static> = oid!(1.2.840.10045.4.3.2); +/// 1.2.840.10045.4.3.3 +pub const OID_SIG_ECDSA_WITH_SHA384: Oid<'static> = oid!(1.2.840.10045.4.3.3); +/// 1.2.840.10045.4.3.4 +pub const OID_SIG_ECDSA_WITH_SHA512: Oid<'static> = oid!(1.2.840.10045.4.3.4); +/// 1.2.840.10045.3.1.7 +pub const OID_EC_P256: Oid<'static> = oid!(1.2.840.10045.3.1.7); + +impl<'a> OidRegistry<'a> { + #[cfg(feature = "kdf")] + #[cfg_attr(docsrs, doc(cfg(feature = "kdf")))] + #[doc = "Load all known OIDs for feature `kdf` in the registry."] + pub fn with_kdf(mut self) -> Self { + self.insert(oid!(1.3.133.16.840.63.0.2), OidEntry::new("dhSinglePass-stdDH-sha1kdf-scheme", "Single pass Secure Hash Algorithm 1 (SHA1) key derivation")); + self + } + + #[cfg(feature = "ms_spc")] + #[cfg_attr(docsrs, doc(cfg(feature = "ms_spc")))] + #[doc = "Load all known OIDs for feature `ms_spc` in the registry."] + pub fn with_ms_spc(mut self) -> Self { + self.insert(oid!(1.3.6.1.4.1.311.2.1.4), OidEntry::new("spcIndirectData", "The SPC_INDIRECT_DATA_CONTENT structure is used in Authenticode signatures to store the digest and other attributes of the signed file")); + self.insert(oid!(1.3.6.1.4.1.311.2.1.11), OidEntry::new("spcStatementType", "spcStatementType")); + self.insert(oid!(1.3.6.1.4.1.311.2.1.12), OidEntry::new("spcSpOpusInfo", "SpcSpOpusInfo")); + self.insert(oid!(1.3.6.1.4.1.311.2.1.15), OidEntry::new("spcPEImageData", "spcPEImageData")); + self.insert(oid!(1.3.6.1.4.1.311.2.1.21), OidEntry::new("msCodeInd", "MsCodeInd (SPC_INDIVIDUAL_SP_KEY_PURPOSE_OBJID) is a ExtendedKeyUsage for Certificate Extensions which indicates Microsoft Individual Code Signing (authenticode)")); + self.insert(oid!(1.3.6.1.4.1.311.10.1), OidEntry::new("szOID_CTL", "MS_CTL")); + self + } + + #[cfg(feature = "nist_algs")] + #[cfg_attr(docsrs, doc(cfg(feature = "nist_algs")))] + #[doc = "Load all known OIDs for feature `nist_algs` in the registry."] + pub fn with_nist_algs(mut self) -> Self { + self.insert(oid!(1.3.132.0.34), OidEntry::new("secp384r1", "P-384 elliptic curve parameter")); + self.insert(oid!(1.3.132.0.35), OidEntry::new("secp521r1", "P-521 elliptic curve parameter")); + self.insert(oid!(1.3.14.3.2.26), OidEntry::new("id-SHA1", "SHA-1 hash algorithm")); + self.insert(oid!(2.16.840.1.101.3.4.1.42), OidEntry::new("aes-256-cbc", "256-bit Advanced Encryption Standard (AES) algorithm with Cipher-Block Chaining (CBC) mode of operation")); + self.insert(oid!(2.16.840.1.101.3.4.2.1), OidEntry::new("sha256", "Secure Hash Algorithm that uses a 256 bit key (SHA256)")); + self.insert(oid!(2.16.840.1.101.3.4.2.2), OidEntry::new("sha384", "Secure Hash Algorithm that uses a 384 bit key (SHA384)")); + self.insert(oid!(2.16.840.1.101.3.4.2.3), OidEntry::new("sha512", "Secure Hash Algorithm that uses a 512 bit key (SHA512)")); + self + } + + #[cfg(feature = "pkcs1")] + #[cfg_attr(docsrs, doc(cfg(feature = "pkcs1")))] + #[doc = "Load all known OIDs for feature `pkcs1` in the registry."] + pub fn with_pkcs1(mut self) -> Self { + self.insert(oid!(1.2.840.113549.1.1.1), OidEntry::new("rsaEncryption", "RSAES-PKCS1-v1_5 encryption scheme")); + self.insert(oid!(1.2.840.113549.1.1.2), OidEntry::new("md2WithRSAEncryption", "MD2 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.3), OidEntry::new("md4WithRSAEncryption", "MD4 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.4), OidEntry::new("md5WithRSAEncryption", "MD5 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.5), OidEntry::new("sha1WithRSAEncryption", "SHA1 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.10), OidEntry::new("rsassa-pss", "RSA Signature Scheme with Probabilistic Signature Scheme (RSASSA-PSS)")); + self.insert(oid!(1.2.840.113549.1.1.11), OidEntry::new("sha256WithRSAEncryption", "SHA256 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.12), OidEntry::new("sha384WithRSAEncryption", "SHA384 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.13), OidEntry::new("sha512WithRSAEncryption", "SHA512 with RSA encryption")); + self.insert(oid!(1.2.840.113549.1.1.14), OidEntry::new("sha224WithRSAEncryption", "SHA224 with RSA encryption")); + self + } + + #[cfg(feature = "pkcs12")] + #[cfg_attr(docsrs, doc(cfg(feature = "pkcs12")))] + #[doc = "Load all known OIDs for feature `pkcs12` in the registry."] + pub fn with_pkcs12(mut self) -> Self { + self.insert(oid!(1.2.840.113549.1.12), OidEntry::new("pkcs-12", "Public-Key Cryptography Standard (PKCS) #12")); + self.insert(oid!(1.2.840.113549.1.12.1), OidEntry::new("pkcs-12PbeIds", "PKCS #12 Password Based Encryption IDs")); + self.insert(oid!(1.2.840.113549.1.12.1.1), OidEntry::new("pbeWithSHAAnd128BitRC4", "PKCS #12 Password Based Encryption With SHA-1 and 128-bit RC4")); + self.insert(oid!(1.2.840.113549.1.12.1.2), OidEntry::new("pbeWithSHAAnd40BitRC4", "PKCS #12 Password Based Encryption With SHA-1 and 40-bit RC4")); + self.insert(oid!(1.2.840.113549.1.12.1.3), OidEntry::new("pbeWithSHAAnd3-KeyTripleDES-CBC", "PKCS #12 Password Based Encryption With SHA-1 and 3-key Triple DES in CBC mode")); + self.insert(oid!(1.2.840.113549.1.12.1.4), OidEntry::new("pbeWithSHAAnd2-KeyTripleDES-CBC", "PKCS #12 Password Based Encryption With SHA-1 and 2-key Triple DES in CBC mode")); + self.insert(oid!(1.2.840.113549.1.12.1.5), OidEntry::new("pbeWithSHAAnd128BitRC2-CBC", "PKCS #12 Password Based Encryption With SHA-1 and 128-bit RC2-CBC")); + self.insert(oid!(1.2.840.113549.1.12.1.6), OidEntry::new("pbeWithSHAAnd40BitRC2-CBC", "PKCS #12 Password Based Encryption With SHA-1 and 40-bit RC2-CBC")); + self + } + + #[cfg(feature = "pkcs7")] + #[cfg_attr(docsrs, doc(cfg(feature = "pkcs7")))] + #[doc = "Load all known OIDs for feature `pkcs7` in the registry."] + pub fn with_pkcs7(mut self) -> Self { + self.insert(oid!(1.2.840.113549.1.7.1), OidEntry::new("pkcs7-data", "pkcs7-data")); + self.insert(oid!(1.2.840.113549.1.7.2), OidEntry::new("pkcs7-signedData", "PKCS#7 Signed Data")); + self.insert(oid!(1.2.840.113549.1.7.3), OidEntry::new("pkcs7-envelopedData", "PKCS#7 Enveloped Data")); + self.insert(oid!(1.2.840.113549.1.7.4), OidEntry::new("pkcs7-signedAndEnvelopedData", "PKCS#7 Signed and Enveloped Data")); + self.insert(oid!(1.2.840.113549.1.7.5), OidEntry::new("pkcs7-digestedData", "PKCS#7 Digested Data")); + self.insert(oid!(1.2.840.113549.1.7.6), OidEntry::new("pkcs7-encryptedData", "PKCS#7 Encrypted Data")); + self + } + + #[cfg(feature = "pkcs9")] + #[cfg_attr(docsrs, doc(cfg(feature = "pkcs9")))] + #[doc = "Load all known OIDs for feature `pkcs9` in the registry."] + pub fn with_pkcs9(mut self) -> Self { + self.insert(oid!(1.2.840.113549.1.9.1), OidEntry::new("emailAddress", "Email Address attribute for use in signatures")); + self.insert(oid!(1.2.840.113549.1.9.2), OidEntry::new("unstructuredName", "PKCS#9 unstructuredName")); + self.insert(oid!(1.2.840.113549.1.9.3), OidEntry::new("contentType", "id-contentType")); + self.insert(oid!(1.2.840.113549.1.9.4), OidEntry::new("id-messageDigest", "id-messageDigest")); + self.insert(oid!(1.2.840.113549.1.9.5), OidEntry::new("signing-time", "id-signingTime")); + self.insert(oid!(1.2.840.113549.1.9.14), OidEntry::new("extensionRequest", "Extension list for Certification Requests")); + self.insert(oid!(1.2.840.113549.1.9.15), OidEntry::new("smimeCapabilities", "aa-smimeCapabilities")); + self + } + + #[cfg(feature = "x500")] + #[cfg_attr(docsrs, doc(cfg(feature = "x500")))] + #[doc = "Load all known OIDs for feature `x500` in the registry."] + pub fn with_x500(mut self) -> Self { + self.insert(oid!(2.5), OidEntry::new("x500", "X.500")); + self + } + + #[cfg(feature = "x509")] + #[cfg_attr(docsrs, doc(cfg(feature = "x509")))] + #[doc = "Load all known OIDs for feature `x509` in the registry."] + pub fn with_x509(mut self) -> Self { + self.insert(oid!(0.9.2342.19200300.100.1.25), OidEntry::new("domainComponent", "Domain component")); + self.insert(oid!(1.3.101.112), OidEntry::new("ed25519", "Edwards-curve Digital Signature Algorithm (EdDSA) Ed25519")); + self.insert(oid!(1.3.101.113), OidEntry::new("ed448", "Edwards-curve Digital Signature Algorithm (EdDSA) Ed448")); + self.insert(oid!(1.3.6.1.4.1.11129.2.4.2), OidEntry::new("ctSCTList", "Certificate Transparency Signed Certificate Timestamp List")); + self.insert(oid!(1.3.6.1.5.5.7.1.1), OidEntry::new("authorityInfoAccess", "Certificate Authority Information Access")); + self.insert(oid!(1.3.6.1.5.5.7.48.1), OidEntry::new("id-ad-ocsp", "PKIX Access Descriptor OCSP")); + self.insert(oid!(1.3.6.1.5.5.7.48.2), OidEntry::new("id-ad-caIssuers", "PKIX Access Descriptor CA Issuers")); + self.insert(oid!(1.3.6.1.5.5.7.48.3), OidEntry::new("id-ad-timestamping", "PKIX Access Descriptor Timestamping")); + self.insert(oid!(1.3.6.1.5.5.7.48.4), OidEntry::new("id-ad-dvcs", "PKIX Access Descriptor DVCS")); + self.insert(oid!(1.3.6.1.5.5.7.48.5), OidEntry::new("id-ad-caRepository", "PKIX Access Descriptor CA Repository")); + self.insert(oid!(1.3.6.1.5.5.7.48.6), OidEntry::new("id-ad-http-certs", "PKIX Access Descriptor HTTP Certificates")); + self.insert(oid!(1.3.6.1.5.5.7.48.7), OidEntry::new("id-ad-http-crls", "PKIX Access Descriptor HTTP Certificate Revocation Lists")); + self.insert(oid!(1.3.6.1.5.5.7.48.10), OidEntry::new("id-ad-rpki-manifest", "PKIX Access Descriptor RPKI Manifest")); + self.insert(oid!(1.3.6.1.5.5.7.48.11), OidEntry::new("id-ad-signed-object", "PKIX Access Descriptor Signed Object")); + self.insert(oid!(1.3.6.1.5.5.7.48.12), OidEntry::new("id-ad-cmc", "PKIX Access Descriptor CMC")); + self.insert(oid!(1.3.6.1.5.5.7.48.13), OidEntry::new("id-ad-rpki-notify", "PKIX Access Descriptor RPKI Notify")); + self.insert(oid!(1.3.6.1.5.5.7.48.14), OidEntry::new("id-ad-stirTNList", "PKIX Access Descriptor STIRTNLIST")); + self.insert(oid!(2.5.4), OidEntry::new("x509", "X.509")); + self.insert(oid!(2.5.4.0), OidEntry::new("objectClass", "Object classes")); + self.insert(oid!(2.5.4.1), OidEntry::new("aliasedEntryName", "Aliased entry/object name")); + self.insert(oid!(2.5.4.2), OidEntry::new("knowledgeInformation", "'knowledgeInformation' attribute type")); + self.insert(oid!(2.5.4.3), OidEntry::new("commonName", "Common Name")); + self.insert(oid!(2.5.4.4), OidEntry::new("surname", "Surname")); + self.insert(oid!(2.5.4.5), OidEntry::new("serialNumber", "Serial Number")); + self.insert(oid!(2.5.4.6), OidEntry::new("countryName", "Country Name")); + self.insert(oid!(2.5.4.7), OidEntry::new("localityName", "Locality Name")); + self.insert(oid!(2.5.4.8), OidEntry::new("stateOrProvinceName", "State or Province name")); + self.insert(oid!(2.5.4.9), OidEntry::new("streetAddress", "Street Address")); + self.insert(oid!(2.5.4.10), OidEntry::new("organizationName", "Organization Name")); + self.insert(oid!(2.5.4.11), OidEntry::new("organizationalUnit", "Organizational Unit")); + self.insert(oid!(2.5.4.12), OidEntry::new("title", "Title")); + self.insert(oid!(2.5.4.13), OidEntry::new("description", "Description")); + self.insert(oid!(2.5.4.14), OidEntry::new("searchGuide", "Search Guide")); + self.insert(oid!(2.5.4.15), OidEntry::new("businessCategory", "Business Category")); + self.insert(oid!(2.5.4.16), OidEntry::new("postalAddress", "Postal Address")); + self.insert(oid!(2.5.4.17), OidEntry::new("postalCode", "Postal Code")); + self.insert(oid!(2.5.4.41), OidEntry::new("name", "Name")); + self.insert(oid!(2.5.4.42), OidEntry::new("givenName", "Given Name")); + self.insert(oid!(2.5.4.45), OidEntry::new("uniqueIdentifier", "Bit String Unique Identifier")); + self.insert(oid!(2.5.29.14), OidEntry::new("subjectKeyIdentifier", "X509v3 Subject Key Identifier")); + self.insert(oid!(2.5.29.15), OidEntry::new("keyUsage", "X509v3 Key Usage")); + self.insert(oid!(2.5.29.16), OidEntry::new("privateKeyUsagePeriod", "X509v3 Private Key Usage Period")); + self.insert(oid!(2.5.29.17), OidEntry::new("subjectAltName", "X509v3 Subject Alternative Name")); + self.insert(oid!(2.5.29.18), OidEntry::new("issuerAltName", "X509v3 Issuer Alternative Name")); + self.insert(oid!(2.5.29.19), OidEntry::new("basicConstraints", "X509v3 Basic Constraints")); + self.insert(oid!(2.5.29.20), OidEntry::new("crlNumber", "X509v3 CRL Number")); + self.insert(oid!(2.5.29.21), OidEntry::new("reasonCode", "X509v3 Reason Code")); + self.insert(oid!(2.5.29.23), OidEntry::new("holdInstructionCode", "X509v3 Hold Instruction Code")); + self.insert(oid!(2.5.29.24), OidEntry::new("invalidityDate", "X509v3 Invalidity Date")); + self.insert(oid!(2.5.29.27), OidEntry::new("deltaCRLIndicator", "X509v3 Delta CRL Indicator")); + self.insert(oid!(2.5.29.28), OidEntry::new("issuerDistributionPoint", "X509v3 Issuer Distribution Point")); + self.insert(oid!(2.5.29.29), OidEntry::new("issuer", "X509v3 Issuer")); + self.insert(oid!(2.5.29.30), OidEntry::new("nameConstraints", "X509v3 Name Constraints")); + self.insert(oid!(2.5.29.31), OidEntry::new("crlDistributionPoints", "X509v3 CRL Distribution Points")); + self.insert(oid!(2.5.29.32), OidEntry::new("certificatePolicies", "X509v3 Certificate Policies")); + self.insert(oid!(2.5.29.33), OidEntry::new("policyMappings", "X509v3 Policy Mappings")); + self.insert(oid!(2.5.29.35), OidEntry::new("authorityKeyIdentifier", "X509v3 Authority Key Identifier")); + self.insert(oid!(2.5.29.36), OidEntry::new("policyConstraints", "X509v3 Policy Constraints")); + self.insert(oid!(2.5.29.37), OidEntry::new("extendedKeyUsage", "X509v3 Extended Key Usage")); + self.insert(oid!(2.5.29.46), OidEntry::new("freshestCRL", "X509v3 Freshest CRL")); + self.insert(oid!(2.5.29.54), OidEntry::new("inhibitantAnyPolicy", "X509v3 Inhibit Any-policy")); + self.insert(oid!(2.16.840.1.113730.1.1), OidEntry::new("nsCertType", "X.509 v3 Certificate Type")); + self + } + + #[cfg(feature = "x962")] + #[cfg_attr(docsrs, doc(cfg(feature = "x962")))] + #[doc = "Load all known OIDs for feature `x962` in the registry."] + pub fn with_x962(mut self) -> Self { + self.insert(oid!(1.2.840.10045.2.1), OidEntry::new("id-ecPublicKey", "Elliptic curve public key cryptography")); + self.insert(oid!(1.2.840.10045.4.3.1), OidEntry::new("ecdsa-with-SHA224", "Elliptic curve Digital Signature Algorithm (DSA) coupled with the Secure Hash Algorithm 224 (SHA224) algorithm")); + self.insert(oid!(1.2.840.10045.4.3.2), OidEntry::new("ecdsa-with-SHA256", "Elliptic curve Digital Signature Algorithm (DSA) coupled with the Secure Hash Algorithm 256 (SHA256) algorithm")); + self.insert(oid!(1.2.840.10045.4.3.3), OidEntry::new("ecdsa-with-SHA384", "Elliptic curve Digital Signature Algorithm (DSA) coupled with the Secure Hash Algorithm 384 (SHA384) algorithm")); + self.insert(oid!(1.2.840.10045.4.3.4), OidEntry::new("ecdsa-with-SHA512", "Elliptic curve Digital Signature Algorithm (DSA) coupled with the Secure Hash Algorithm 512 (SHA512) algorithm")); + self.insert(oid!(1.2.840.10045.3.1.7), OidEntry::new("prime256v1", "P-256 elliptic curve parameter")); + self + } + +} diff --git a/external/rust/crates/proc-macro-nested/out/count.rs b/external/rust/crates/proc-macro-nested/out/count.rs new file mode 100644 index 0000000000..4485b0c7e7 --- /dev/null +++ b/external/rust/crates/proc-macro-nested/out/count.rs @@ -0,0 +1,74 @@ +#[doc(hidden)] +#[macro_export] +macro_rules! count { + () => { proc_macro_call_0!() }; + (!) => { proc_macro_call_1!() }; + (!!) => { proc_macro_call_2!() }; + (!!!) => { proc_macro_call_3!() }; + (!!!!) => { proc_macro_call_4!() }; + (!!!!!) => { proc_macro_call_5!() }; + (!!!!!!) => { proc_macro_call_6!() }; + (!!!!!!!) => { proc_macro_call_7!() }; + (!!!!!!!!) => { proc_macro_call_8!() }; + (!!!!!!!!!) => { proc_macro_call_9!() }; + (!!!!!!!!!!) => { proc_macro_call_10!() }; + (!!!!!!!!!!!) => { proc_macro_call_11!() }; + (!!!!!!!!!!!!) => { proc_macro_call_12!() }; + (!!!!!!!!!!!!!) => { proc_macro_call_13!() }; + (!!!!!!!!!!!!!!) => { proc_macro_call_14!() }; + (!!!!!!!!!!!!!!!) => { proc_macro_call_15!() }; + (!!!!!!!!!!!!!!!!) => { proc_macro_call_16!() }; + (!!!!!!!!!!!!!!!!!) => { proc_macro_call_17!() }; + (!!!!!!!!!!!!!!!!!!) => { proc_macro_call_18!() }; + (!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_19!() }; + (!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_20!() }; + (!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_21!() }; + (!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_22!() }; + (!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_23!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_24!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_25!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_26!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_27!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_28!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_29!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_30!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_31!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_32!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_33!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_34!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_35!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_36!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_37!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_38!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_39!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_40!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_41!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_42!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_43!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_44!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_45!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_46!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_47!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_48!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_49!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_50!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_51!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_52!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_53!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_54!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_55!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_56!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_57!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_58!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_59!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_60!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_61!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_62!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_63!() }; + (!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) => { proc_macro_call_64!() }; + ($(!)+) => { + compile_error! { + "this macro does not support >64 nested macro invocations" + } + }; +} diff --git a/external/rust/crates/protobuf/out/version.rs b/external/rust/crates/protobuf/out/version.rs new file mode 100644 index 0000000000..18bbac5022 --- /dev/null +++ b/external/rust/crates/protobuf/out/version.rs @@ -0,0 +1,7 @@ +/// protobuf crate version +pub const VERSION: &'static str = "2.27.1"; +/// This symbol is used by codegen +#[doc(hidden)] +pub const VERSION_IDENT: &'static str = "VERSION_2_27_1"; +/// This symbol can be referenced to assert that proper version of crate is used +pub const VERSION_2_27_1: () = (); diff --git a/external/rust/crates/vulkano/out/autogen.rs b/external/rust/crates/vulkano/out/autogen.rs new file mode 100644 index 0000000000..4158e48ae9 --- /dev/null +++ b/external/rust/crates/vulkano/out/autogen.rs @@ -0,0 +1,9611 @@ +// This file is auto-generated by vulkano-gen from vk.xml header version 186. +// It should not be edited manually. Changes should be made by editing vulkano-gen. + +crate::device::extensions::device_extensions! { + khr_16bit_storage => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_16bit_storage.html) + - Requires device extension: [`khr_storage_buffer_storage_class`](crate::device::DeviceExtensions::khr_storage_buffer_storage_class) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_16bit_storage", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_storage_buffer_storage_class], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_8bit_storage => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_8bit_storage.html) + - Requires device extension: [`khr_storage_buffer_storage_class`](crate::device::DeviceExtensions::khr_storage_buffer_storage_class) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_8bit_storage", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_storage_buffer_storage_class], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_acceleration_structure => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_acceleration_structure.html) + - Requires Vulkan 1.1 + - Requires device extensions: [`ext_descriptor_indexing`](crate::device::DeviceExtensions::ext_descriptor_indexing), [`khr_buffer_device_address`](crate::device::DeviceExtensions::khr_buffer_device_address), [`khr_deferred_host_operations`](crate::device::DeviceExtensions::khr_deferred_host_operations) + ", + raw: b"VK_KHR_acceleration_structure", + requires_core: crate::Version::V1_1, + requires_device_extensions: [ext_descriptor_indexing, khr_buffer_device_address, khr_deferred_host_operations], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_bind_memory2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_bind_memory2.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_bind_memory2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_buffer_device_address => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_buffer_device_address.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Conflicts with device extension: [`ext_buffer_device_address`](crate::device::DeviceExtensions::ext_buffer_device_address) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_buffer_device_address", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [ext_buffer_device_address], + }, + khr_copy_commands2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_copy_commands2.html) + ", + raw: b"VK_KHR_copy_commands2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_create_renderpass2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_create_renderpass2.html) + - Requires device extensions: [`khr_multiview`](crate::device::DeviceExtensions::khr_multiview), [`khr_maintenance2`](crate::device::DeviceExtensions::khr_maintenance2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_create_renderpass2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_multiview, khr_maintenance2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_dedicated_allocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_dedicated_allocation.html) + - Requires device extension: [`khr_get_memory_requirements2`](crate::device::DeviceExtensions::khr_get_memory_requirements2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_dedicated_allocation", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_get_memory_requirements2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_deferred_host_operations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_deferred_host_operations.html) + ", + raw: b"VK_KHR_deferred_host_operations", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_depth_stencil_resolve => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_depth_stencil_resolve.html) + - Requires device extension: [`khr_create_renderpass2`](crate::device::DeviceExtensions::khr_create_renderpass2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_depth_stencil_resolve", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_create_renderpass2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_descriptor_update_template => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_descriptor_update_template.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_descriptor_update_template", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_device_group => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_device_group.html) + - Requires instance extension: [`khr_device_group_creation`](crate::instance::InstanceExtensions::khr_device_group_creation) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_device_group", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_device_group_creation], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_display_swapchain => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_display_swapchain.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extension: [`khr_display`](crate::instance::InstanceExtensions::khr_display) + ", + raw: b"VK_KHR_display_swapchain", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [khr_display], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_draw_indirect_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_draw_indirect_count.html) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_draw_indirect_count", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_driver_properties => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_driver_properties.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_driver_properties", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_fence => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_fence.html) + - Requires instance extension: [`khr_external_fence_capabilities`](crate::instance::InstanceExtensions::khr_external_fence_capabilities) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_external_fence", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_external_fence_capabilities], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_fence_fd => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_fence_fd.html) + - Requires device extension: [`khr_external_fence`](crate::device::DeviceExtensions::khr_external_fence) + ", + raw: b"VK_KHR_external_fence_fd", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_fence], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_fence_win32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_fence_win32.html) + - Requires device extension: [`khr_external_fence`](crate::device::DeviceExtensions::khr_external_fence) + ", + raw: b"VK_KHR_external_fence_win32", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_fence], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_memory.html) + - Requires instance extension: [`khr_external_memory_capabilities`](crate::instance::InstanceExtensions::khr_external_memory_capabilities) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_external_memory", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_external_memory_capabilities], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_memory_fd => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_memory_fd.html) + - Requires device extension: [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + ", + raw: b"VK_KHR_external_memory_fd", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_memory_win32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_memory_win32.html) + - Requires device extension: [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + ", + raw: b"VK_KHR_external_memory_win32", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_semaphore => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_semaphore.html) + - Requires instance extension: [`khr_external_semaphore_capabilities`](crate::instance::InstanceExtensions::khr_external_semaphore_capabilities) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_external_semaphore", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_external_semaphore_capabilities], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_semaphore_fd => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_semaphore_fd.html) + - Requires device extension: [`khr_external_semaphore`](crate::device::DeviceExtensions::khr_external_semaphore) + ", + raw: b"VK_KHR_external_semaphore_fd", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_semaphore], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_external_semaphore_win32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_semaphore_win32.html) + - Requires device extension: [`khr_external_semaphore`](crate::device::DeviceExtensions::khr_external_semaphore) + ", + raw: b"VK_KHR_external_semaphore_win32", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_semaphore], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_fragment_shading_rate => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_fragment_shading_rate.html) + - Requires device extension: [`khr_create_renderpass2`](crate::device::DeviceExtensions::khr_create_renderpass2) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_fragment_shading_rate", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_create_renderpass2], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_get_memory_requirements2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_get_memory_requirements2.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_get_memory_requirements2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_image_format_list => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_image_format_list.html) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_image_format_list", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_imageless_framebuffer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_imageless_framebuffer.html) + - Requires device extensions: [`khr_maintenance2`](crate::device::DeviceExtensions::khr_maintenance2), [`khr_image_format_list`](crate::device::DeviceExtensions::khr_image_format_list) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_imageless_framebuffer", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_maintenance2, khr_image_format_list], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_incremental_present => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_incremental_present.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + ", + raw: b"VK_KHR_incremental_present", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_maintenance1 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_maintenance1.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_maintenance1", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_maintenance2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_maintenance2.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_maintenance2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_maintenance3 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_maintenance3.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_maintenance3", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_multiview => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_multiview.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_multiview", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_performance_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_performance_query.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_performance_query", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_pipeline_executable_properties => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_pipeline_executable_properties.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_pipeline_executable_properties", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_pipeline_library => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_pipeline_library.html) + ", + raw: b"VK_KHR_pipeline_library", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_portability_subset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_portability_subset.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Must be enabled if it is supported by the physical device + ", + raw: b"VK_KHR_portability_subset", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: true, + conflicts_device_extensions: [], + }, + khr_present_id => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_present_id.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + ", + raw: b"VK_KHR_present_id", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_present_wait => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_present_wait.html) + - Requires device extensions: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain), [`khr_present_id`](crate::device::DeviceExtensions::khr_present_id) + ", + raw: b"VK_KHR_present_wait", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain, khr_present_id], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_push_descriptor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_push_descriptor.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_push_descriptor", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_ray_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_ray_query.html) + - Requires Vulkan 1.1 + - Requires device extensions: [`khr_spirv_1_4`](crate::device::DeviceExtensions::khr_spirv_1_4), [`khr_acceleration_structure`](crate::device::DeviceExtensions::khr_acceleration_structure) + ", + raw: b"VK_KHR_ray_query", + requires_core: crate::Version::V1_1, + requires_device_extensions: [khr_spirv_1_4, khr_acceleration_structure], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_ray_tracing_pipeline => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_ray_tracing_pipeline.html) + - Requires Vulkan 1.1 + - Requires device extensions: [`khr_spirv_1_4`](crate::device::DeviceExtensions::khr_spirv_1_4), [`khr_acceleration_structure`](crate::device::DeviceExtensions::khr_acceleration_structure) + ", + raw: b"VK_KHR_ray_tracing_pipeline", + requires_core: crate::Version::V1_1, + requires_device_extensions: [khr_spirv_1_4, khr_acceleration_structure], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_relaxed_block_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_relaxed_block_layout.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_relaxed_block_layout", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_sampler_mirror_clamp_to_edge => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_sampler_mirror_clamp_to_edge.html) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_sampler_mirror_clamp_to_edge", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_sampler_ycbcr_conversion => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_sampler_ycbcr_conversion.html) + - Requires device extensions: [`khr_maintenance1`](crate::device::DeviceExtensions::khr_maintenance1), [`khr_bind_memory2`](crate::device::DeviceExtensions::khr_bind_memory2), [`khr_get_memory_requirements2`](crate::device::DeviceExtensions::khr_get_memory_requirements2) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_sampler_ycbcr_conversion", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_maintenance1, khr_bind_memory2, khr_get_memory_requirements2], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_separate_depth_stencil_layouts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_separate_depth_stencil_layouts.html) + - Requires device extension: [`khr_create_renderpass2`](crate::device::DeviceExtensions::khr_create_renderpass2) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_separate_depth_stencil_layouts", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_create_renderpass2], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_atomic_int64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_atomic_int64.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_shader_atomic_int64", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_clock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_clock.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_shader_clock", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_draw_parameters => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_draw_parameters.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_shader_draw_parameters", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_float16_int8 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_float16_int8.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_shader_float16_int8", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_float_controls => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_float_controls.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_shader_float_controls", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_non_semantic_info => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_non_semantic_info.html) + ", + raw: b"VK_KHR_shader_non_semantic_info", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_subgroup_extended_types => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_subgroup_extended_types.html) + - Requires Vulkan 1.1 + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_shader_subgroup_extended_types", + requires_core: crate::Version::V1_1, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_subgroup_uniform_control_flow => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_subgroup_uniform_control_flow.html) + - Requires Vulkan 1.1 + ", + raw: b"VK_KHR_shader_subgroup_uniform_control_flow", + requires_core: crate::Version::V1_1, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shader_terminate_invocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shader_terminate_invocation.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_shader_terminate_invocation", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_shared_presentable_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_shared_presentable_image.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extensions: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2), [`khr_get_surface_capabilities2`](crate::instance::InstanceExtensions::khr_get_surface_capabilities2) + ", + raw: b"VK_KHR_shared_presentable_image", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [khr_get_physical_device_properties2, khr_get_surface_capabilities2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_spirv_1_4 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_spirv_1_4.html) + - Requires Vulkan 1.1 + - Requires device extension: [`khr_shader_float_controls`](crate::device::DeviceExtensions::khr_shader_float_controls) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_spirv_1_4", + requires_core: crate::Version::V1_1, + requires_device_extensions: [khr_shader_float_controls], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_storage_buffer_storage_class => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_storage_buffer_storage_class.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_storage_buffer_storage_class", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_swapchain => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_swapchain.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_swapchain", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_surface], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_swapchain_mutable_format => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_swapchain_mutable_format.html) + - Requires device extensions: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain), [`khr_maintenance2`](crate::device::DeviceExtensions::khr_maintenance2), [`khr_image_format_list`](crate::device::DeviceExtensions::khr_image_format_list) + ", + raw: b"VK_KHR_swapchain_mutable_format", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain, khr_maintenance2, khr_image_format_list], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_synchronization2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_synchronization2.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_synchronization2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_timeline_semaphore => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_timeline_semaphore.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_timeline_semaphore", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_uniform_buffer_standard_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_uniform_buffer_standard_layout.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_uniform_buffer_standard_layout", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_variable_pointers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_variable_pointers.html) + - Requires device extension: [`khr_storage_buffer_storage_class`](crate::device::DeviceExtensions::khr_storage_buffer_storage_class) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_variable_pointers", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_storage_buffer_storage_class], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_video_decode_queue => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_video_decode_queue.html) + - Requires device extensions: [`khr_video_queue`](crate::device::DeviceExtensions::khr_video_queue), [`khr_synchronization2`](crate::device::DeviceExtensions::khr_synchronization2) + ", + raw: b"VK_KHR_video_decode_queue", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_video_queue, khr_synchronization2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_video_encode_queue => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_video_encode_queue.html) + - Requires device extensions: [`khr_video_queue`](crate::device::DeviceExtensions::khr_video_queue), [`khr_synchronization2`](crate::device::DeviceExtensions::khr_synchronization2) + ", + raw: b"VK_KHR_video_encode_queue", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_video_queue, khr_synchronization2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_video_queue => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_video_queue.html) + - Requires device extension: [`khr_sampler_ycbcr_conversion`](crate::device::DeviceExtensions::khr_sampler_ycbcr_conversion) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_video_queue", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_sampler_ycbcr_conversion], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_vulkan_memory_model => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_vulkan_memory_model.html) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_KHR_vulkan_memory_model", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_win32_keyed_mutex => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_win32_keyed_mutex.html) + - Requires device extension: [`khr_external_memory_win32`](crate::device::DeviceExtensions::khr_external_memory_win32) + ", + raw: b"VK_KHR_win32_keyed_mutex", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory_win32], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_workgroup_memory_explicit_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_workgroup_memory_explicit_layout.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_workgroup_memory_explicit_layout", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + khr_zero_initialize_workgroup_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_zero_initialize_workgroup_memory.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_KHR_zero_initialize_workgroup_memory", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_4444_formats => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_4444_formats.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_4444_formats", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_astc_decode_mode => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_astc_decode_mode.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_astc_decode_mode", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_blend_operation_advanced => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_blend_operation_advanced.html) + ", + raw: b"VK_EXT_blend_operation_advanced", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_buffer_device_address => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_buffer_device_address.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Conflicts with device extension: [`khr_buffer_device_address`](crate::device::DeviceExtensions::khr_buffer_device_address) + - Deprecated by [`khr_buffer_device_address`](crate::device::DeviceExtensions::khr_buffer_device_address) + ", + raw: b"VK_EXT_buffer_device_address", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [khr_buffer_device_address], + }, + ext_calibrated_timestamps => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_calibrated_timestamps.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_calibrated_timestamps", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_color_write_enable => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_color_write_enable.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_color_write_enable", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_conditional_rendering => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_conditional_rendering.html) + ", + raw: b"VK_EXT_conditional_rendering", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_conservative_rasterization => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_conservative_rasterization.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_conservative_rasterization", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_custom_border_color => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_custom_border_color.html) + ", + raw: b"VK_EXT_custom_border_color", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_debug_marker => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_debug_marker.html) + - Requires instance extension: [`ext_debug_report`](crate::instance::InstanceExtensions::ext_debug_report) + - Promoted to [`ext_debug_utils`](crate::instance::InstanceExtensions::ext_debug_utils) + ", + raw: b"VK_EXT_debug_marker", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [ext_debug_report], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_depth_clip_enable => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_depth_clip_enable.html) + ", + raw: b"VK_EXT_depth_clip_enable", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_depth_range_unrestricted => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_depth_range_unrestricted.html) + ", + raw: b"VK_EXT_depth_range_unrestricted", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_descriptor_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_descriptor_indexing.html) + - Requires device extension: [`khr_maintenance3`](crate::device::DeviceExtensions::khr_maintenance3) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_EXT_descriptor_indexing", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_maintenance3], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_device_memory_report => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_device_memory_report.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_device_memory_report", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_discard_rectangles => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_discard_rectangles.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_discard_rectangles", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_display_control => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_display_control.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extension: [`ext_display_surface_counter`](crate::instance::InstanceExtensions::ext_display_surface_counter) + ", + raw: b"VK_EXT_display_control", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [ext_display_surface_counter], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_extended_dynamic_state => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_extended_dynamic_state.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_extended_dynamic_state", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_extended_dynamic_state2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_extended_dynamic_state2.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_extended_dynamic_state2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_external_memory_dma_buf => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_external_memory_dma_buf.html) + - Requires device extension: [`khr_external_memory_fd`](crate::device::DeviceExtensions::khr_external_memory_fd) + ", + raw: b"VK_EXT_external_memory_dma_buf", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory_fd], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_external_memory_host => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_external_memory_host.html) + - Requires device extension: [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + ", + raw: b"VK_EXT_external_memory_host", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_filter_cubic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_filter_cubic.html) + ", + raw: b"VK_EXT_filter_cubic", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_fragment_density_map => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_fragment_density_map.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_fragment_density_map", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_fragment_density_map2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_fragment_density_map2.html) + - Requires device extension: [`ext_fragment_density_map`](crate::device::DeviceExtensions::ext_fragment_density_map) + ", + raw: b"VK_EXT_fragment_density_map2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [ext_fragment_density_map], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_fragment_shader_interlock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_fragment_shader_interlock.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_fragment_shader_interlock", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_full_screen_exclusive => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_full_screen_exclusive.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extensions: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2), [`khr_surface`](crate::instance::InstanceExtensions::khr_surface), [`khr_get_surface_capabilities2`](crate::instance::InstanceExtensions::khr_get_surface_capabilities2) + ", + raw: b"VK_EXT_full_screen_exclusive", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [khr_get_physical_device_properties2, khr_surface, khr_get_surface_capabilities2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_global_priority => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_global_priority.html) + ", + raw: b"VK_EXT_global_priority", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_global_priority_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_global_priority_query.html) + - Requires device extension: [`ext_global_priority`](crate::device::DeviceExtensions::ext_global_priority) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_global_priority_query", + requires_core: crate::Version::V1_0, + requires_device_extensions: [ext_global_priority], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_hdr_metadata => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_hdr_metadata.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + ", + raw: b"VK_EXT_hdr_metadata", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_host_query_reset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_host_query_reset.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_EXT_host_query_reset", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_image_drm_format_modifier => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_image_drm_format_modifier.html) + - Requires device extensions: [`khr_bind_memory2`](crate::device::DeviceExtensions::khr_bind_memory2), [`khr_image_format_list`](crate::device::DeviceExtensions::khr_image_format_list), [`khr_sampler_ycbcr_conversion`](crate::device::DeviceExtensions::khr_sampler_ycbcr_conversion) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_image_drm_format_modifier", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_bind_memory2, khr_image_format_list, khr_sampler_ycbcr_conversion], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_image_robustness => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_image_robustness.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_image_robustness", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_index_type_uint8 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_index_type_uint8.html) + ", + raw: b"VK_EXT_index_type_uint8", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_inline_uniform_block => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_inline_uniform_block.html) + - Requires device extension: [`khr_maintenance1`](crate::device::DeviceExtensions::khr_maintenance1) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_inline_uniform_block", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_maintenance1], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_line_rasterization => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_line_rasterization.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_line_rasterization", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_memory_budget => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_memory_budget.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_memory_budget", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_memory_priority => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_memory_priority.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_memory_priority", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_multi_draw => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_multi_draw.html) + ", + raw: b"VK_EXT_multi_draw", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_pci_bus_info => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_pci_bus_info.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_pci_bus_info", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_physical_device_drm => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_physical_device_drm.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_physical_device_drm", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_pipeline_creation_cache_control => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_pipeline_creation_cache_control.html) + ", + raw: b"VK_EXT_pipeline_creation_cache_control", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_pipeline_creation_feedback => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_pipeline_creation_feedback.html) + ", + raw: b"VK_EXT_pipeline_creation_feedback", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_post_depth_coverage => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_post_depth_coverage.html) + ", + raw: b"VK_EXT_post_depth_coverage", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_private_data => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_private_data.html) + ", + raw: b"VK_EXT_private_data", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_provoking_vertex => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_provoking_vertex.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_provoking_vertex", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_queue_family_foreign => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_queue_family_foreign.html) + - Requires device extension: [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + ", + raw: b"VK_EXT_queue_family_foreign", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_robustness2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_robustness2.html) + ", + raw: b"VK_EXT_robustness2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_sample_locations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_sample_locations.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_sample_locations", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_sampler_filter_minmax => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_sampler_filter_minmax.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_EXT_sampler_filter_minmax", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_scalar_block_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_scalar_block_layout.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_EXT_scalar_block_layout", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_separate_stencil_usage => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_separate_stencil_usage.html) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_EXT_separate_stencil_usage", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_atomic_float => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_atomic_float.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_shader_atomic_float", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_atomic_float2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_atomic_float2.html) + - Requires device extension: [`ext_shader_atomic_float`](crate::device::DeviceExtensions::ext_shader_atomic_float) + ", + raw: b"VK_EXT_shader_atomic_float2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [ext_shader_atomic_float], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_demote_to_helper_invocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_demote_to_helper_invocation.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_shader_demote_to_helper_invocation", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_image_atomic_int64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_image_atomic_int64.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_shader_image_atomic_int64", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_stencil_export => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_stencil_export.html) + ", + raw: b"VK_EXT_shader_stencil_export", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_subgroup_ballot => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_subgroup_ballot.html) + - Deprecated by Vulkan 1.2 + ", + raw: b"VK_EXT_shader_subgroup_ballot", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_subgroup_vote => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_subgroup_vote.html) + - Deprecated by Vulkan 1.1 + ", + raw: b"VK_EXT_shader_subgroup_vote", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_shader_viewport_index_layer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_shader_viewport_index_layer.html) + - Promoted to Vulkan 1.2 + ", + raw: b"VK_EXT_shader_viewport_index_layer", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_subgroup_size_control => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_subgroup_size_control.html) + - Requires Vulkan 1.1 + ", + raw: b"VK_EXT_subgroup_size_control", + requires_core: crate::Version::V1_1, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_texel_buffer_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_texel_buffer_alignment.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_texel_buffer_alignment", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_texture_compression_astc_hdr => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_texture_compression_astc_hdr.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_texture_compression_astc_hdr", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_tooling_info => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_tooling_info.html) + ", + raw: b"VK_EXT_tooling_info", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_transform_feedback => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_transform_feedback.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_transform_feedback", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_validation_cache => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_validation_cache.html) + ", + raw: b"VK_EXT_validation_cache", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_vertex_attribute_divisor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_vertex_attribute_divisor.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_vertex_attribute_divisor", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_vertex_input_dynamic_state => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_vertex_input_dynamic_state.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_EXT_vertex_input_dynamic_state", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_video_decode_h264 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_video_decode_h264.html) + - Requires device extension: [`khr_video_decode_queue`](crate::device::DeviceExtensions::khr_video_decode_queue) + ", + raw: b"VK_EXT_video_decode_h264", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_video_decode_queue], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_video_decode_h265 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_video_decode_h265.html) + - Requires device extension: [`khr_video_decode_queue`](crate::device::DeviceExtensions::khr_video_decode_queue) + ", + raw: b"VK_EXT_video_decode_h265", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_video_decode_queue], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_video_encode_h264 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_video_encode_h264.html) + - Requires device extension: [`khr_video_encode_queue`](crate::device::DeviceExtensions::khr_video_encode_queue) + ", + raw: b"VK_EXT_video_encode_h264", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_video_encode_queue], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_ycbcr_2plane_444_formats => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_ycbcr_2plane_444_formats.html) + - Requires device extension: [`khr_sampler_ycbcr_conversion`](crate::device::DeviceExtensions::khr_sampler_ycbcr_conversion) + ", + raw: b"VK_EXT_ycbcr_2plane_444_formats", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_sampler_ycbcr_conversion], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ext_ycbcr_image_arrays => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_ycbcr_image_arrays.html) + - Requires device extension: [`khr_sampler_ycbcr_conversion`](crate::device::DeviceExtensions::khr_sampler_ycbcr_conversion) + ", + raw: b"VK_EXT_ycbcr_image_arrays", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_sampler_ycbcr_conversion], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_buffer_marker => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_buffer_marker.html) + ", + raw: b"VK_AMD_buffer_marker", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_device_coherent_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_device_coherent_memory.html) + ", + raw: b"VK_AMD_device_coherent_memory", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_display_native_hdr => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_display_native_hdr.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extensions: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2), [`khr_get_surface_capabilities2`](crate::instance::InstanceExtensions::khr_get_surface_capabilities2) + ", + raw: b"VK_AMD_display_native_hdr", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [khr_get_physical_device_properties2, khr_get_surface_capabilities2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_draw_indirect_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_draw_indirect_count.html) + - Promoted to [`khr_draw_indirect_count`](crate::device::DeviceExtensions::khr_draw_indirect_count) + ", + raw: b"VK_AMD_draw_indirect_count", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_gcn_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_gcn_shader.html) + ", + raw: b"VK_AMD_gcn_shader", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_gpu_shader_half_float => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_gpu_shader_half_float.html) + - Deprecated by [`khr_shader_float16_int8`](crate::device::DeviceExtensions::khr_shader_float16_int8) + ", + raw: b"VK_AMD_gpu_shader_half_float", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_gpu_shader_int16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_gpu_shader_int16.html) + - Deprecated by [`khr_shader_float16_int8`](crate::device::DeviceExtensions::khr_shader_float16_int8) + ", + raw: b"VK_AMD_gpu_shader_int16", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_memory_overallocation_behavior => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_memory_overallocation_behavior.html) + ", + raw: b"VK_AMD_memory_overallocation_behavior", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_mixed_attachment_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_mixed_attachment_samples.html) + ", + raw: b"VK_AMD_mixed_attachment_samples", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_pipeline_compiler_control => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_pipeline_compiler_control.html) + ", + raw: b"VK_AMD_pipeline_compiler_control", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_rasterization_order => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_rasterization_order.html) + ", + raw: b"VK_AMD_rasterization_order", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_ballot => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_ballot.html) + ", + raw: b"VK_AMD_shader_ballot", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_core_properties => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_core_properties.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_AMD_shader_core_properties", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_core_properties2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_core_properties2.html) + - Requires device extension: [`amd_shader_core_properties`](crate::device::DeviceExtensions::amd_shader_core_properties) + ", + raw: b"VK_AMD_shader_core_properties2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [amd_shader_core_properties], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_explicit_vertex_parameter => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_explicit_vertex_parameter.html) + ", + raw: b"VK_AMD_shader_explicit_vertex_parameter", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_fragment_mask => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_fragment_mask.html) + ", + raw: b"VK_AMD_shader_fragment_mask", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_image_load_store_lod => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_image_load_store_lod.html) + ", + raw: b"VK_AMD_shader_image_load_store_lod", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_info => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_info.html) + ", + raw: b"VK_AMD_shader_info", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_shader_trinary_minmax => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_shader_trinary_minmax.html) + ", + raw: b"VK_AMD_shader_trinary_minmax", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + amd_texture_gather_bias_lod => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_AMD_texture_gather_bias_lod.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_AMD_texture_gather_bias_lod", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + android_external_memory_android_hardware_buffer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_ANDROID_external_memory_android_hardware_buffer.html) + - Requires device extensions: [`khr_sampler_ycbcr_conversion`](crate::device::DeviceExtensions::khr_sampler_ycbcr_conversion), [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory), [`ext_queue_family_foreign`](crate::device::DeviceExtensions::ext_queue_family_foreign), [`khr_dedicated_allocation`](crate::device::DeviceExtensions::khr_dedicated_allocation) + ", + raw: b"VK_ANDROID_external_memory_android_hardware_buffer", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_sampler_ycbcr_conversion, khr_external_memory, ext_queue_family_foreign, khr_dedicated_allocation], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + fuchsia_external_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_FUCHSIA_external_memory.html) + - Requires device extension: [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + - Requires instance extension: [`khr_external_memory_capabilities`](crate::instance::InstanceExtensions::khr_external_memory_capabilities) + ", + raw: b"VK_FUCHSIA_external_memory", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory], + requires_instance_extensions: [khr_external_memory_capabilities], + required_if_supported: false, + conflicts_device_extensions: [], + }, + fuchsia_external_semaphore => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_FUCHSIA_external_semaphore.html) + - Requires device extension: [`khr_external_semaphore`](crate::device::DeviceExtensions::khr_external_semaphore) + - Requires instance extension: [`khr_external_semaphore_capabilities`](crate::instance::InstanceExtensions::khr_external_semaphore_capabilities) + ", + raw: b"VK_FUCHSIA_external_semaphore", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_semaphore], + requires_instance_extensions: [khr_external_semaphore_capabilities], + required_if_supported: false, + conflicts_device_extensions: [], + }, + ggp_frame_token => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_GGP_frame_token.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extension: [`ggp_stream_descriptor_surface`](crate::instance::InstanceExtensions::ggp_stream_descriptor_surface) + ", + raw: b"VK_GGP_frame_token", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [ggp_stream_descriptor_surface], + required_if_supported: false, + conflicts_device_extensions: [], + }, + google_decorate_string => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_GOOGLE_decorate_string.html) + ", + raw: b"VK_GOOGLE_decorate_string", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + google_display_timing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_GOOGLE_display_timing.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + ", + raw: b"VK_GOOGLE_display_timing", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + google_hlsl_functionality1 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_GOOGLE_hlsl_functionality1.html) + ", + raw: b"VK_GOOGLE_hlsl_functionality1", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + google_user_type => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_GOOGLE_user_type.html) + ", + raw: b"VK_GOOGLE_user_type", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + huawei_invocation_mask => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_HUAWEI_invocation_mask.html) + - Requires device extensions: [`khr_ray_tracing_pipeline`](crate::device::DeviceExtensions::khr_ray_tracing_pipeline), [`khr_synchronization2`](crate::device::DeviceExtensions::khr_synchronization2) + ", + raw: b"VK_HUAWEI_invocation_mask", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_ray_tracing_pipeline, khr_synchronization2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + huawei_subpass_shading => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_HUAWEI_subpass_shading.html) + - Requires device extensions: [`khr_create_renderpass2`](crate::device::DeviceExtensions::khr_create_renderpass2), [`khr_synchronization2`](crate::device::DeviceExtensions::khr_synchronization2) + ", + raw: b"VK_HUAWEI_subpass_shading", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_create_renderpass2, khr_synchronization2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + img_filter_cubic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_IMG_filter_cubic.html) + ", + raw: b"VK_IMG_filter_cubic", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + img_format_pvrtc => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_IMG_format_pvrtc.html) + ", + raw: b"VK_IMG_format_pvrtc", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + intel_performance_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_INTEL_performance_query.html) + ", + raw: b"VK_INTEL_performance_query", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + intel_shader_integer_functions2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_INTEL_shader_integer_functions2.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_INTEL_shader_integer_functions2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nvx_binary_import => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NVX_binary_import.html) + ", + raw: b"VK_NVX_binary_import", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nvx_image_view_handle => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NVX_image_view_handle.html) + ", + raw: b"VK_NVX_image_view_handle", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nvx_multiview_per_view_attributes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NVX_multiview_per_view_attributes.html) + - Requires device extension: [`khr_multiview`](crate::device::DeviceExtensions::khr_multiview) + ", + raw: b"VK_NVX_multiview_per_view_attributes", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_multiview], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_acquire_winrt_display => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_acquire_winrt_display.html) + - Requires instance extension: [`ext_direct_mode_display`](crate::instance::InstanceExtensions::ext_direct_mode_display) + ", + raw: b"VK_NV_acquire_winrt_display", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [ext_direct_mode_display], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_clip_space_w_scaling => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_clip_space_w_scaling.html) + ", + raw: b"VK_NV_clip_space_w_scaling", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_compute_shader_derivatives => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_compute_shader_derivatives.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_compute_shader_derivatives", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_cooperative_matrix => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_cooperative_matrix.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_cooperative_matrix", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_corner_sampled_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_corner_sampled_image.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_corner_sampled_image", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_coverage_reduction_mode => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_coverage_reduction_mode.html) + - Requires device extension: [`nv_framebuffer_mixed_samples`](crate::device::DeviceExtensions::nv_framebuffer_mixed_samples) + ", + raw: b"VK_NV_coverage_reduction_mode", + requires_core: crate::Version::V1_0, + requires_device_extensions: [nv_framebuffer_mixed_samples], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_dedicated_allocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_dedicated_allocation.html) + - Deprecated by [`khr_dedicated_allocation`](crate::device::DeviceExtensions::khr_dedicated_allocation) + ", + raw: b"VK_NV_dedicated_allocation", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_dedicated_allocation_image_aliasing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_dedicated_allocation_image_aliasing.html) + - Requires device extension: [`khr_dedicated_allocation`](crate::device::DeviceExtensions::khr_dedicated_allocation) + ", + raw: b"VK_NV_dedicated_allocation_image_aliasing", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_dedicated_allocation], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_device_diagnostic_checkpoints => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_device_diagnostic_checkpoints.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_device_diagnostic_checkpoints", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_device_diagnostics_config => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_device_diagnostics_config.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_device_diagnostics_config", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_device_generated_commands => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_device_generated_commands.html) + - Requires Vulkan 1.1 + ", + raw: b"VK_NV_device_generated_commands", + requires_core: crate::Version::V1_1, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_external_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_external_memory.html) + - Requires instance extension: [`nv_external_memory_capabilities`](crate::instance::InstanceExtensions::nv_external_memory_capabilities) + - Deprecated by [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + ", + raw: b"VK_NV_external_memory", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [nv_external_memory_capabilities], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_external_memory_rdma => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_external_memory_rdma.html) + - Requires device extension: [`khr_external_memory`](crate::device::DeviceExtensions::khr_external_memory) + ", + raw: b"VK_NV_external_memory_rdma", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_external_memory], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_external_memory_win32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_external_memory_win32.html) + - Requires device extension: [`nv_external_memory`](crate::device::DeviceExtensions::nv_external_memory) + - Deprecated by [`khr_external_memory_win32`](crate::device::DeviceExtensions::khr_external_memory_win32) + ", + raw: b"VK_NV_external_memory_win32", + requires_core: crate::Version::V1_0, + requires_device_extensions: [nv_external_memory], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_fill_rectangle => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_fill_rectangle.html) + ", + raw: b"VK_NV_fill_rectangle", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_fragment_coverage_to_color => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_fragment_coverage_to_color.html) + ", + raw: b"VK_NV_fragment_coverage_to_color", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_fragment_shader_barycentric => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_fragment_shader_barycentric.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_fragment_shader_barycentric", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_fragment_shading_rate_enums => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_fragment_shading_rate_enums.html) + - Requires device extension: [`khr_fragment_shading_rate`](crate::device::DeviceExtensions::khr_fragment_shading_rate) + ", + raw: b"VK_NV_fragment_shading_rate_enums", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_fragment_shading_rate], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_framebuffer_mixed_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_framebuffer_mixed_samples.html) + ", + raw: b"VK_NV_framebuffer_mixed_samples", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_geometry_shader_passthrough => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_geometry_shader_passthrough.html) + ", + raw: b"VK_NV_geometry_shader_passthrough", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_glsl_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_glsl_shader.html) + - Deprecated without a replacement + ", + raw: b"VK_NV_glsl_shader", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_inherited_viewport_scissor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_inherited_viewport_scissor.html) + ", + raw: b"VK_NV_inherited_viewport_scissor", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_mesh_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_mesh_shader.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_mesh_shader", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_ray_tracing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_ray_tracing.html) + - Requires device extension: [`khr_get_memory_requirements2`](crate::device::DeviceExtensions::khr_get_memory_requirements2) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_ray_tracing", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_get_memory_requirements2], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_ray_tracing_motion_blur => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_ray_tracing_motion_blur.html) + - Requires device extension: [`khr_ray_tracing_pipeline`](crate::device::DeviceExtensions::khr_ray_tracing_pipeline) + ", + raw: b"VK_NV_ray_tracing_motion_blur", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_ray_tracing_pipeline], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_representative_fragment_test => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_representative_fragment_test.html) + ", + raw: b"VK_NV_representative_fragment_test", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_sample_mask_override_coverage => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_sample_mask_override_coverage.html) + ", + raw: b"VK_NV_sample_mask_override_coverage", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_scissor_exclusive => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_scissor_exclusive.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_scissor_exclusive", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_shader_image_footprint => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_shader_image_footprint.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_shader_image_footprint", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_shader_sm_builtins => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_shader_sm_builtins.html) + - Requires Vulkan 1.1 + ", + raw: b"VK_NV_shader_sm_builtins", + requires_core: crate::Version::V1_1, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_shader_subgroup_partitioned => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_shader_subgroup_partitioned.html) + - Requires Vulkan 1.1 + ", + raw: b"VK_NV_shader_subgroup_partitioned", + requires_core: crate::Version::V1_1, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_shading_rate_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_shading_rate_image.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + ", + raw: b"VK_NV_shading_rate_image", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [khr_get_physical_device_properties2], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_viewport_array2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_viewport_array2.html) + ", + raw: b"VK_NV_viewport_array2", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_viewport_swizzle => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_viewport_swizzle.html) + ", + raw: b"VK_NV_viewport_swizzle", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + nv_win32_keyed_mutex => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_win32_keyed_mutex.html) + - Requires device extension: [`nv_external_memory_win32`](crate::device::DeviceExtensions::nv_external_memory_win32) + - Promoted to [`khr_win32_keyed_mutex`](crate::device::DeviceExtensions::khr_win32_keyed_mutex) + ", + raw: b"VK_NV_win32_keyed_mutex", + requires_core: crate::Version::V1_0, + requires_device_extensions: [nv_external_memory_win32], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + qcom_render_pass_shader_resolve => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_QCOM_render_pass_shader_resolve.html) + ", + raw: b"VK_QCOM_render_pass_shader_resolve", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + qcom_render_pass_store_ops => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_QCOM_render_pass_store_ops.html) + ", + raw: b"VK_QCOM_render_pass_store_ops", + requires_core: crate::Version::V1_0, + requires_device_extensions: [], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + qcom_render_pass_transform => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_QCOM_render_pass_transform.html) + - Requires device extension: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_QCOM_render_pass_transform", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain], + requires_instance_extensions: [khr_surface], + required_if_supported: false, + conflicts_device_extensions: [], + }, + qcom_rotated_copy_commands => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_QCOM_rotated_copy_commands.html) + - Requires device extensions: [`khr_swapchain`](crate::device::DeviceExtensions::khr_swapchain), [`khr_copy_commands2`](crate::device::DeviceExtensions::khr_copy_commands2) + ", + raw: b"VK_QCOM_rotated_copy_commands", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_swapchain, khr_copy_commands2], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, + valve_mutable_descriptor_type => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VALVE_mutable_descriptor_type.html) + - Requires device extension: [`khr_maintenance3`](crate::device::DeviceExtensions::khr_maintenance3) + ", + raw: b"VK_VALVE_mutable_descriptor_type", + requires_core: crate::Version::V1_0, + requires_device_extensions: [khr_maintenance3], + requires_instance_extensions: [], + required_if_supported: false, + conflicts_device_extensions: [], + }, +} + +crate::instance::extensions::instance_extensions! { + khr_android_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_android_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_android_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + khr_device_group_creation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_device_group_creation.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_device_group_creation", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + khr_display => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_display.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_display", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + khr_external_fence_capabilities => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_fence_capabilities.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_external_fence_capabilities", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_get_physical_device_properties2], + }, + khr_external_memory_capabilities => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_memory_capabilities.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_external_memory_capabilities", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_get_physical_device_properties2], + }, + khr_external_semaphore_capabilities => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_external_semaphore_capabilities.html) + - Requires instance extension: [`khr_get_physical_device_properties2`](crate::instance::InstanceExtensions::khr_get_physical_device_properties2) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_external_semaphore_capabilities", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_get_physical_device_properties2], + }, + khr_get_display_properties2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_get_display_properties2.html) + - Requires instance extension: [`khr_display`](crate::instance::InstanceExtensions::khr_display) + ", + raw: b"VK_KHR_get_display_properties2", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_display], + }, + khr_get_physical_device_properties2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_get_physical_device_properties2.html) + - Promoted to Vulkan 1.1 + ", + raw: b"VK_KHR_get_physical_device_properties2", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + khr_get_surface_capabilities2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_get_surface_capabilities2.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_get_surface_capabilities2", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + khr_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_surface.html) + ", + raw: b"VK_KHR_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + khr_surface_protected_capabilities => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_surface_protected_capabilities.html) + - Requires Vulkan 1.1 + - Requires instance extension: [`khr_get_surface_capabilities2`](crate::instance::InstanceExtensions::khr_get_surface_capabilities2) + ", + raw: b"VK_KHR_surface_protected_capabilities", + requires_core: crate::Version::V1_1, + requires_instance_extensions: [khr_get_surface_capabilities2], + }, + khr_wayland_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_wayland_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_wayland_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + khr_win32_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_win32_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_win32_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + khr_xcb_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_xcb_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_xcb_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + khr_xlib_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_KHR_xlib_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_KHR_xlib_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + ext_acquire_drm_display => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_acquire_drm_display.html) + - Requires instance extension: [`ext_direct_mode_display`](crate::instance::InstanceExtensions::ext_direct_mode_display) + ", + raw: b"VK_EXT_acquire_drm_display", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [ext_direct_mode_display], + }, + ext_acquire_xlib_display => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_acquire_xlib_display.html) + - Requires instance extension: [`ext_direct_mode_display`](crate::instance::InstanceExtensions::ext_direct_mode_display) + ", + raw: b"VK_EXT_acquire_xlib_display", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [ext_direct_mode_display], + }, + ext_debug_report => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_debug_report.html) + - Deprecated by [`ext_debug_utils`](crate::instance::InstanceExtensions::ext_debug_utils) + ", + raw: b"VK_EXT_debug_report", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + ext_debug_utils => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_debug_utils.html) + ", + raw: b"VK_EXT_debug_utils", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + ext_direct_mode_display => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_direct_mode_display.html) + - Requires instance extension: [`khr_display`](crate::instance::InstanceExtensions::khr_display) + ", + raw: b"VK_EXT_direct_mode_display", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_display], + }, + ext_directfb_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_directfb_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_EXT_directfb_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + ext_display_surface_counter => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_display_surface_counter.html) + - Requires instance extension: [`khr_display`](crate::instance::InstanceExtensions::khr_display) + ", + raw: b"VK_EXT_display_surface_counter", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_display], + }, + ext_headless_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_headless_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_EXT_headless_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + ext_metal_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_metal_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_EXT_metal_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + ext_swapchain_colorspace => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_swapchain_colorspace.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_EXT_swapchain_colorspace", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + ext_validation_features => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_validation_features.html) + ", + raw: b"VK_EXT_validation_features", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + ext_validation_flags => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_EXT_validation_flags.html) + - Deprecated by [`ext_validation_features`](crate::instance::InstanceExtensions::ext_validation_features) + ", + raw: b"VK_EXT_validation_flags", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + fuchsia_imagepipe_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_FUCHSIA_imagepipe_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_FUCHSIA_imagepipe_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + ggp_stream_descriptor_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_GGP_stream_descriptor_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_GGP_stream_descriptor_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + mvk_ios_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_MVK_ios_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + - Deprecated by [`ext_metal_surface`](crate::instance::InstanceExtensions::ext_metal_surface) + ", + raw: b"VK_MVK_ios_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + mvk_macos_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_MVK_macos_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + - Deprecated by [`ext_metal_surface`](crate::instance::InstanceExtensions::ext_metal_surface) + ", + raw: b"VK_MVK_macos_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + nn_vi_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NN_vi_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_NN_vi_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, + nv_external_memory_capabilities => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_NV_external_memory_capabilities.html) + - Deprecated by [`khr_external_memory_capabilities`](crate::instance::InstanceExtensions::khr_external_memory_capabilities) + ", + raw: b"VK_NV_external_memory_capabilities", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [], + }, + qnx_screen_surface => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_QNX_screen_surface.html) + - Requires instance extension: [`khr_surface`](crate::instance::InstanceExtensions::khr_surface) + ", + raw: b"VK_QNX_screen_surface", + requires_core: crate::Version::V1_0, + requires_instance_extensions: [khr_surface], + }, +} + +crate::fns::fns!(EntryFunctions, { + v1_0 => EntryFnV1_0, + v1_1 => EntryFnV1_1, + v1_2 => EntryFnV1_2, +}); + +crate::fns::fns!(InstanceFunctions, { + v1_0 => InstanceFnV1_0, + v1_1 => InstanceFnV1_1, + v1_2 => InstanceFnV1_2, + khr_android_surface => KhrAndroidSurfaceFn, + khr_device_group_creation => KhrDeviceGroupCreationFn, + khr_display => KhrDisplayFn, + khr_external_fence_capabilities => KhrExternalFenceCapabilitiesFn, + khr_external_memory_capabilities => KhrExternalMemoryCapabilitiesFn, + khr_external_semaphore_capabilities => KhrExternalSemaphoreCapabilitiesFn, + khr_get_display_properties2 => KhrGetDisplayProperties2Fn, + khr_get_physical_device_properties2 => KhrGetPhysicalDeviceProperties2Fn, + khr_get_surface_capabilities2 => KhrGetSurfaceCapabilities2Fn, + khr_surface => KhrSurfaceFn, + khr_wayland_surface => KhrWaylandSurfaceFn, + khr_win32_surface => KhrWin32SurfaceFn, + khr_xcb_surface => KhrXcbSurfaceFn, + khr_xlib_surface => KhrXlibSurfaceFn, + ext_acquire_drm_display => ExtAcquireDrmDisplayFn, + ext_acquire_xlib_display => ExtAcquireXlibDisplayFn, + ext_debug_report => ExtDebugReportFn, + ext_debug_utils => ExtDebugUtilsFn, + ext_direct_mode_display => ExtDirectModeDisplayFn, + ext_directfb_surface => ExtDirectfbSurfaceFn, + ext_display_surface_counter => ExtDisplaySurfaceCounterFn, + ext_headless_surface => ExtHeadlessSurfaceFn, + ext_metal_surface => ExtMetalSurfaceFn, + fuchsia_imagepipe_surface => FuchsiaImagepipeSurfaceFn, + ggp_stream_descriptor_surface => GgpStreamDescriptorSurfaceFn, + mvk_ios_surface => MvkIosSurfaceFn, + mvk_macos_surface => MvkMacosSurfaceFn, + nn_vi_surface => NnViSurfaceFn, + nv_external_memory_capabilities => NvExternalMemoryCapabilitiesFn, + qnx_screen_surface => QnxScreenSurfaceFn, +}); + +crate::fns::fns!(DeviceFunctions, { + v1_0 => DeviceFnV1_0, + v1_1 => DeviceFnV1_1, + v1_2 => DeviceFnV1_2, + khr_acceleration_structure => KhrAccelerationStructureFn, + khr_bind_memory2 => KhrBindMemory2Fn, + khr_buffer_device_address => KhrBufferDeviceAddressFn, + khr_copy_commands2 => KhrCopyCommands2Fn, + khr_create_renderpass2 => KhrCreateRenderpass2Fn, + khr_deferred_host_operations => KhrDeferredHostOperationsFn, + khr_descriptor_update_template => KhrDescriptorUpdateTemplateFn, + khr_device_group => KhrDeviceGroupFn, + khr_display_swapchain => KhrDisplaySwapchainFn, + khr_draw_indirect_count => KhrDrawIndirectCountFn, + khr_external_fence_fd => KhrExternalFenceFdFn, + khr_external_fence_win32 => KhrExternalFenceWin32Fn, + khr_external_memory_fd => KhrExternalMemoryFdFn, + khr_external_memory_win32 => KhrExternalMemoryWin32Fn, + khr_external_semaphore_fd => KhrExternalSemaphoreFdFn, + khr_external_semaphore_win32 => KhrExternalSemaphoreWin32Fn, + khr_fragment_shading_rate => KhrFragmentShadingRateFn, + khr_get_memory_requirements2 => KhrGetMemoryRequirements2Fn, + khr_maintenance1 => KhrMaintenance1Fn, + khr_maintenance3 => KhrMaintenance3Fn, + khr_performance_query => KhrPerformanceQueryFn, + khr_pipeline_executable_properties => KhrPipelineExecutablePropertiesFn, + khr_present_wait => KhrPresentWaitFn, + khr_push_descriptor => KhrPushDescriptorFn, + khr_ray_tracing_pipeline => KhrRayTracingPipelineFn, + khr_sampler_ycbcr_conversion => KhrSamplerYcbcrConversionFn, + khr_shared_presentable_image => KhrSharedPresentableImageFn, + khr_swapchain => KhrSwapchainFn, + khr_synchronization2 => KhrSynchronization2Fn, + khr_timeline_semaphore => KhrTimelineSemaphoreFn, + khr_video_decode_queue => KhrVideoDecodeQueueFn, + khr_video_encode_queue => KhrVideoEncodeQueueFn, + khr_video_queue => KhrVideoQueueFn, + ext_buffer_device_address => ExtBufferDeviceAddressFn, + ext_calibrated_timestamps => ExtCalibratedTimestampsFn, + ext_color_write_enable => ExtColorWriteEnableFn, + ext_conditional_rendering => ExtConditionalRenderingFn, + ext_debug_marker => ExtDebugMarkerFn, + ext_discard_rectangles => ExtDiscardRectanglesFn, + ext_display_control => ExtDisplayControlFn, + ext_extended_dynamic_state => ExtExtendedDynamicStateFn, + ext_extended_dynamic_state2 => ExtExtendedDynamicState2Fn, + ext_external_memory_host => ExtExternalMemoryHostFn, + ext_full_screen_exclusive => ExtFullScreenExclusiveFn, + ext_hdr_metadata => ExtHdrMetadataFn, + ext_host_query_reset => ExtHostQueryResetFn, + ext_image_drm_format_modifier => ExtImageDrmFormatModifierFn, + ext_line_rasterization => ExtLineRasterizationFn, + ext_multi_draw => ExtMultiDrawFn, + ext_private_data => ExtPrivateDataFn, + ext_sample_locations => ExtSampleLocationsFn, + ext_tooling_info => ExtToolingInfoFn, + ext_transform_feedback => ExtTransformFeedbackFn, + ext_validation_cache => ExtValidationCacheFn, + ext_vertex_input_dynamic_state => ExtVertexInputDynamicStateFn, + amd_buffer_marker => AmdBufferMarkerFn, + amd_display_native_hdr => AmdDisplayNativeHdrFn, + amd_draw_indirect_count => AmdDrawIndirectCountFn, + amd_shader_info => AmdShaderInfoFn, + android_external_memory_android_hardware_buffer => AndroidExternalMemoryAndroidHardwareBufferFn, + fuchsia_external_memory => FuchsiaExternalMemoryFn, + fuchsia_external_semaphore => FuchsiaExternalSemaphoreFn, + google_display_timing => GoogleDisplayTimingFn, + huawei_invocation_mask => HuaweiInvocationMaskFn, + huawei_subpass_shading => HuaweiSubpassShadingFn, + intel_performance_query => IntelPerformanceQueryFn, + nvx_binary_import => NvxBinaryImportFn, + nvx_image_view_handle => NvxImageViewHandleFn, + nv_acquire_winrt_display => NvAcquireWinrtDisplayFn, + nv_clip_space_w_scaling => NvClipSpaceWScalingFn, + nv_cooperative_matrix => NvCooperativeMatrixFn, + nv_coverage_reduction_mode => NvCoverageReductionModeFn, + nv_device_diagnostic_checkpoints => NvDeviceDiagnosticCheckpointsFn, + nv_device_generated_commands => NvDeviceGeneratedCommandsFn, + nv_external_memory_rdma => NvExternalMemoryRdmaFn, + nv_external_memory_win32 => NvExternalMemoryWin32Fn, + nv_fragment_shading_rate_enums => NvFragmentShadingRateEnumsFn, + nv_mesh_shader => NvMeshShaderFn, + nv_ray_tracing => NvRayTracingFn, + nv_scissor_exclusive => NvScissorExclusiveFn, + nv_shading_rate_image => NvShadingRateImageFn, +}); + +crate::device::features::features! { + acceleration_structure => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html#features-accelerationStructure) + ", + ffi_name: acceleration_structure, + ffi_members: [features_acceleration_structure_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + acceleration_structure_capture_replay => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html#features-accelerationStructureCaptureReplay) + ", + ffi_name: acceleration_structure_capture_replay, + ffi_members: [features_acceleration_structure_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + acceleration_structure_host_commands => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html#features-accelerationStructureHostCommands) + ", + ffi_name: acceleration_structure_host_commands, + ffi_members: [features_acceleration_structure_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + acceleration_structure_indirect_build => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html#features-accelerationStructureIndirectBuild) + ", + ffi_name: acceleration_structure_indirect_build, + ffi_members: [features_acceleration_structure_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + advanced_blend_coherent_operations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html#features-advancedBlendCoherentOperations) + ", + ffi_name: advanced_blend_coherent_operations, + ffi_members: [features_blend_operation_advanced_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + alpha_to_one => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-alphaToOne) + ", + ffi_name: alpha_to_one, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + attachment_fragment_shading_rate => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html#features-attachmentFragmentShadingRate) + - Conflicts with features: [`shading_rate_image`](crate::device::Features::shading_rate_image), [`fragment_density_map`](crate::device::Features::fragment_density_map) + ", + ffi_name: attachment_fragment_shading_rate, + ffi_members: [features_fragment_shading_rate_khr], + requires_features: [], + conflicts_features: [shading_rate_image, fragment_density_map], + required_by_extensions: [], + }, + bresenham_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html#features-bresenhamLines) + ", + ffi_name: bresenham_lines, + ffi_members: [features_line_rasterization_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + buffer_device_address => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-bufferDeviceAddress) + ", + ffi_name: buffer_device_address, + ffi_members: [features_vulkan12, features_buffer_device_address, features_buffer_device_address_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + buffer_device_address_capture_replay => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-bufferDeviceAddressCaptureReplay) + ", + ffi_name: buffer_device_address_capture_replay, + ffi_members: [features_vulkan12, features_buffer_device_address, features_buffer_device_address_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + buffer_device_address_multi_device => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-bufferDeviceAddressMultiDevice) + ", + ffi_name: buffer_device_address_multi_device, + ffi_members: [features_vulkan12, features_buffer_device_address, features_buffer_device_address_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + color_write_enable => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html#features-colorWriteEnable) + ", + ffi_name: color_write_enable, + ffi_members: [features_color_write_enable_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + compute_derivative_group_linear => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html#features-computeDerivativeGroupLinear) + ", + ffi_name: compute_derivative_group_linear, + ffi_members: [features_compute_shader_derivatives_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + compute_derivative_group_quads => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html#features-computeDerivativeGroupQuads) + ", + ffi_name: compute_derivative_group_quads, + ffi_members: [features_compute_shader_derivatives_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + compute_full_subgroups => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html#features-computeFullSubgroups) + ", + ffi_name: compute_full_subgroups, + ffi_members: [features_subgroup_size_control_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + conditional_rendering => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html#features-conditionalRendering) + ", + ffi_name: conditional_rendering, + ffi_members: [features_conditional_rendering_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + constant_alpha_color_blend_factors => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-constantAlphaColorBlendFactors) + ", + ffi_name: constant_alpha_color_blend_factors, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + cooperative_matrix => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html#features-cooperativeMatrix) + ", + ffi_name: cooperative_matrix, + ffi_members: [features_cooperative_matrix_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + cooperative_matrix_robust_buffer_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html#features-cooperativeMatrixRobustBufferAccess) + ", + ffi_name: cooperative_matrix_robust_buffer_access, + ffi_members: [features_cooperative_matrix_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + corner_sampled_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html#features-cornerSampledImage) + ", + ffi_name: corner_sampled_image, + ffi_members: [features_corner_sampled_image_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + coverage_reduction_mode => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html#features-coverageReductionMode) + ", + ffi_name: coverage_reduction_mode, + ffi_members: [features_coverage_reduction_mode_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + custom_border_color_without_format => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html#features-customBorderColorWithoutFormat) + ", + ffi_name: custom_border_color_without_format, + ffi_members: [features_custom_border_color_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + custom_border_colors => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html#features-customBorderColors) + ", + ffi_name: custom_border_colors, + ffi_members: [features_custom_border_color_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + decode_mode_shared_exponent => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html#features-decodeModeSharedExponent) + ", + ffi_name: decode_mode_shared_exponent, + ffi_members: [features_astc_decode_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + dedicated_allocation_image_aliasing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html#features-dedicatedAllocationImageAliasing) + ", + ffi_name: dedicated_allocation_image_aliasing, + ffi_members: [features_dedicated_allocation_image_aliasing_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + depth_bias_clamp => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-depthBiasClamp) + ", + ffi_name: depth_bias_clamp, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + depth_bounds => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-depthBounds) + ", + ffi_name: depth_bounds, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + depth_clamp => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-depthClamp) + ", + ffi_name: depth_clamp, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + depth_clip_enable => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html#features-depthClipEnable) + ", + ffi_name: depth_clip_enable, + ffi_members: [features_depth_clip_enable_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_acceleration_structure_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html#features-descriptorBindingAccelerationStructureUpdateAfterBind) + ", + ffi_name: descriptor_binding_acceleration_structure_update_after_bind, + ffi_members: [features_acceleration_structure_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_inline_uniform_block_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html#features-descriptorBindingInlineUniformBlockUpdateAfterBind) + ", + ffi_name: descriptor_binding_inline_uniform_block_update_after_bind, + ffi_members: [features_inline_uniform_block_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_partially_bound => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingPartiallyBound) + ", + ffi_name: descriptor_binding_partially_bound, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_sampled_image_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingSampledImageUpdateAfterBind) + ", + ffi_name: descriptor_binding_sampled_image_update_after_bind, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_storage_buffer_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingStorageBufferUpdateAfterBind) + ", + ffi_name: descriptor_binding_storage_buffer_update_after_bind, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_storage_image_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingStorageImageUpdateAfterBind) + ", + ffi_name: descriptor_binding_storage_image_update_after_bind, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_storage_texel_buffer_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingStorageTexelBufferUpdateAfterBind) + ", + ffi_name: descriptor_binding_storage_texel_buffer_update_after_bind, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_uniform_buffer_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingUniformBufferUpdateAfterBind) + ", + ffi_name: descriptor_binding_uniform_buffer_update_after_bind, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_uniform_texel_buffer_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingUniformTexelBufferUpdateAfterBind) + ", + ffi_name: descriptor_binding_uniform_texel_buffer_update_after_bind, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_update_unused_while_pending => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingUpdateUnusedWhilePending) + ", + ffi_name: descriptor_binding_update_unused_while_pending, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_binding_variable_descriptor_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorBindingVariableDescriptorCount) + ", + ffi_name: descriptor_binding_variable_descriptor_count, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + descriptor_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-descriptorIndexing) + - Required by device extension: [`ext_descriptor_indexing`](crate::device::DeviceExtensions::ext_descriptor_indexing) + ", + ffi_name: descriptor_indexing, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [ext_descriptor_indexing], + }, + device_coherent_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html#features-deviceCoherentMemory) + ", + ffi_name: device_coherent_memory, + ffi_members: [features_coherent_memory_amd], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + device_generated_commands => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html#features-deviceGeneratedCommands) + ", + ffi_name: device_generated_commands, + ffi_members: [features_device_generated_commands_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + device_memory_report => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html#features-deviceMemoryReport) + ", + ffi_name: device_memory_report, + ffi_members: [features_device_memory_report_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + diagnostics_config => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html#features-diagnosticsConfig) + ", + ffi_name: diagnostics_config, + ffi_members: [features_diagnostics_config_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + draw_indirect_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-drawIndirectCount) + - Required by device extension: [`khr_draw_indirect_count`](crate::device::DeviceExtensions::khr_draw_indirect_count) + ", + ffi_name: draw_indirect_count, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [khr_draw_indirect_count], + }, + draw_indirect_first_instance => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-drawIndirectFirstInstance) + ", + ffi_name: draw_indirect_first_instance, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + dual_src_blend => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-dualSrcBlend) + ", + ffi_name: dual_src_blend, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + events => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-events) + ", + ffi_name: events, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + exclusive_scissor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html#features-exclusiveScissor) + ", + ffi_name: exclusive_scissor, + ffi_members: [features_exclusive_scissor_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + extended_dynamic_state => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html#features-extendedDynamicState) + ", + ffi_name: extended_dynamic_state, + ffi_members: [features_extended_dynamic_state_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + extended_dynamic_state2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html#features-extendedDynamicState2) + ", + ffi_name: extended_dynamic_state2, + ffi_members: [features_extended_dynamic_state2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + extended_dynamic_state2_logic_op => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html#features-extendedDynamicState2LogicOp) + ", + ffi_name: extended_dynamic_state2_logic_op, + ffi_members: [features_extended_dynamic_state2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + extended_dynamic_state2_patch_control_points => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html#features-extendedDynamicState2PatchControlPoints) + ", + ffi_name: extended_dynamic_state2_patch_control_points, + ffi_members: [features_extended_dynamic_state2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + external_memory_rdma => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html#features-externalMemoryRDMA) + ", + ffi_name: external_memory_rdma, + ffi_members: [features_external_memory_rdma_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fill_mode_non_solid => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-fillModeNonSolid) + ", + ffi_name: fill_mode_non_solid, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + format_a4b4g4r4 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html#features-formatA4B4G4R4) + ", + ffi_name: format_a4b4g4r4, + ffi_members: [features_4444formats_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + format_a4r4g4b4 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html#features-formatA4R4G4B4) + ", + ffi_name: format_a4r4g4b4, + ffi_members: [features_4444formats_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_density_map => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html#features-fragmentDensityMap) + - Conflicts with features: [`pipeline_fragment_shading_rate`](crate::device::Features::pipeline_fragment_shading_rate), [`primitive_fragment_shading_rate`](crate::device::Features::primitive_fragment_shading_rate), [`attachment_fragment_shading_rate`](crate::device::Features::attachment_fragment_shading_rate) + ", + ffi_name: fragment_density_map, + ffi_members: [features_fragment_density_map_ext], + requires_features: [], + conflicts_features: [pipeline_fragment_shading_rate, primitive_fragment_shading_rate, attachment_fragment_shading_rate], + required_by_extensions: [], + }, + fragment_density_map_deferred => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html#features-fragmentDensityMapDeferred) + ", + ffi_name: fragment_density_map_deferred, + ffi_members: [features_fragment_density_map2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_density_map_dynamic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html#features-fragmentDensityMapDynamic) + ", + ffi_name: fragment_density_map_dynamic, + ffi_members: [features_fragment_density_map_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_density_map_non_subsampled_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html#features-fragmentDensityMapNonSubsampledImages) + ", + ffi_name: fragment_density_map_non_subsampled_images, + ffi_members: [features_fragment_density_map_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_shader_barycentric => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html#features-fragmentShaderBarycentric) + ", + ffi_name: fragment_shader_barycentric, + ffi_members: [features_fragment_shader_barycentric_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_shader_pixel_interlock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html#features-fragmentShaderPixelInterlock) + ", + ffi_name: fragment_shader_pixel_interlock, + ffi_members: [features_fragment_shader_interlock_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_shader_sample_interlock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html#features-fragmentShaderSampleInterlock) + ", + ffi_name: fragment_shader_sample_interlock, + ffi_members: [features_fragment_shader_interlock_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_shader_shading_rate_interlock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html#features-fragmentShaderShadingRateInterlock) + ", + ffi_name: fragment_shader_shading_rate_interlock, + ffi_members: [features_fragment_shader_interlock_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_shading_rate_enums => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html#features-fragmentShadingRateEnums) + ", + ffi_name: fragment_shading_rate_enums, + ffi_members: [features_fragment_shading_rate_enums_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + fragment_stores_and_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-fragmentStoresAndAtomics) + ", + ffi_name: fragment_stores_and_atomics, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + full_draw_index_uint32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-fullDrawIndexUint32) + ", + ffi_name: full_draw_index_uint32, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + geometry_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-geometryShader) + ", + ffi_name: geometry_shader, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + geometry_streams => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html#features-geometryStreams) + ", + ffi_name: geometry_streams, + ffi_members: [features_transform_feedback_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + global_priority_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.html#features-globalPriorityQuery) + ", + ffi_name: global_priority_query, + ffi_members: [features_global_priority_query_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + host_query_reset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-hostQueryReset) + ", + ffi_name: host_query_reset, + ffi_members: [features_vulkan12, features_host_query_reset], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + image_cube_array => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-imageCubeArray) + ", + ffi_name: image_cube_array, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + image_footprint => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html#features-imageFootprint) + ", + ffi_name: image_footprint, + ffi_members: [features_shader_image_footprint_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + image_view2_d_on3_d_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-imageView2DOn3DImage) + ", + ffi_name: image_view2_d_on3_d_image, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + image_view_format_reinterpretation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-imageViewFormatReinterpretation) + ", + ffi_name: image_view_format_reinterpretation, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + image_view_format_swizzle => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-imageViewFormatSwizzle) + ", + ffi_name: image_view_format_swizzle, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + imageless_framebuffer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-imagelessFramebuffer) + ", + ffi_name: imageless_framebuffer, + ffi_members: [features_vulkan12, features_imageless_framebuffer], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + independent_blend => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-independentBlend) + ", + ffi_name: independent_blend, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + index_type_uint8 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html#features-indexTypeUint8) + ", + ffi_name: index_type_uint8, + ffi_members: [features_index_type_uint8_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + inherited_conditional_rendering => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html#features-inheritedConditionalRendering) + ", + ffi_name: inherited_conditional_rendering, + ffi_members: [features_conditional_rendering_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + inherited_queries => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-inheritedQueries) + ", + ffi_name: inherited_queries, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + inherited_viewport_scissor2_d => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html#features-inheritedViewportScissor2D) + ", + ffi_name: inherited_viewport_scissor2_d, + ffi_members: [features_inherited_viewport_scissor_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + inline_uniform_block => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html#features-inlineUniformBlock) + ", + ffi_name: inline_uniform_block, + ffi_members: [features_inline_uniform_block_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + invocation_mask => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html#features-invocationMask) + ", + ffi_name: invocation_mask, + ffi_members: [features_invocation_mask_huawei], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + large_points => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-largePoints) + ", + ffi_name: large_points, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + logic_op => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-logicOp) + ", + ffi_name: logic_op, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + memory_priority => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html#features-memoryPriority) + ", + ffi_name: memory_priority, + ffi_members: [features_memory_priority_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + mesh_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html#features-meshShader) + ", + ffi_name: mesh_shader, + ffi_members: [features_mesh_shader_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multi_draw => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html#features-multiDraw) + ", + ffi_name: multi_draw, + ffi_members: [features_multi_draw_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multi_draw_indirect => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-multiDrawIndirect) + ", + ffi_name: multi_draw_indirect, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multi_viewport => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-multiViewport) + ", + ffi_name: multi_viewport, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multisample_array_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-multisampleArrayImage) + ", + ffi_name: multisample_array_image, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multiview => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-multiview) + ", + ffi_name: multiview, + ffi_members: [features_vulkan11, features_multiview], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multiview_geometry_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-multiviewGeometryShader) + ", + ffi_name: multiview_geometry_shader, + ffi_members: [features_vulkan11, features_multiview], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + multiview_tessellation_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-multiviewTessellationShader) + ", + ffi_name: multiview_tessellation_shader, + ffi_members: [features_vulkan11, features_multiview], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + mutable_comparison_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-mutableComparisonSamplers) + ", + ffi_name: mutable_comparison_samplers, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + mutable_descriptor_type => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html#features-mutableDescriptorType) + ", + ffi_name: mutable_descriptor_type, + ffi_members: [features_mutable_descriptor_type_valve], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + no_invocation_fragment_shading_rates => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html#features-noInvocationFragmentShadingRates) + ", + ffi_name: no_invocation_fragment_shading_rates, + ffi_members: [features_fragment_shading_rate_enums_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + null_descriptor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html#features-nullDescriptor) + ", + ffi_name: null_descriptor, + ffi_members: [features_robustness2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + occlusion_query_precise => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-occlusionQueryPrecise) + ", + ffi_name: occlusion_query_precise, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + performance_counter_multiple_query_pools => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html#features-performanceCounterMultipleQueryPools) + ", + ffi_name: performance_counter_multiple_query_pools, + ffi_members: [features_performance_query_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + performance_counter_query_pools => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html#features-performanceCounterQueryPools) + ", + ffi_name: performance_counter_query_pools, + ffi_members: [features_performance_query_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + pipeline_creation_cache_control => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.html#features-pipelineCreationCacheControl) + ", + ffi_name: pipeline_creation_cache_control, + ffi_members: [features_pipeline_creation_cache_control_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + pipeline_executable_info => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html#features-pipelineExecutableInfo) + ", + ffi_name: pipeline_executable_info, + ffi_members: [features_pipeline_executable_properties_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + pipeline_fragment_shading_rate => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html#features-pipelineFragmentShadingRate) + - Conflicts with features: [`shading_rate_image`](crate::device::Features::shading_rate_image), [`fragment_density_map`](crate::device::Features::fragment_density_map) + ", + ffi_name: pipeline_fragment_shading_rate, + ffi_members: [features_fragment_shading_rate_khr], + requires_features: [], + conflicts_features: [shading_rate_image, fragment_density_map], + required_by_extensions: [], + }, + pipeline_statistics_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-pipelineStatisticsQuery) + ", + ffi_name: pipeline_statistics_query, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + point_polygons => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-pointPolygons) + ", + ffi_name: point_polygons, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + present_id => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html#features-presentId) + ", + ffi_name: present_id, + ffi_members: [features_present_id_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + present_wait => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html#features-presentWait) + ", + ffi_name: present_wait, + ffi_members: [features_present_wait_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + primitive_fragment_shading_rate => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html#features-primitiveFragmentShadingRate) + - Conflicts with features: [`shading_rate_image`](crate::device::Features::shading_rate_image), [`fragment_density_map`](crate::device::Features::fragment_density_map) + ", + ffi_name: primitive_fragment_shading_rate, + ffi_members: [features_fragment_shading_rate_khr], + requires_features: [], + conflicts_features: [shading_rate_image, fragment_density_map], + required_by_extensions: [], + }, + private_data => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePrivateDataFeaturesEXT.html#features-privateData) + ", + ffi_name: private_data, + ffi_members: [features_private_data_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + protected_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-protectedMemory) + ", + ffi_name: protected_memory, + ffi_members: [features_vulkan11, features_protected_memory], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + provoking_vertex_last => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html#features-provokingVertexLast) + ", + ffi_name: provoking_vertex_last, + ffi_members: [features_provoking_vertex_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_query => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html#features-rayQuery) + ", + ffi_name: ray_query, + ffi_members: [features_ray_query_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_tracing_motion_blur => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html#features-rayTracingMotionBlur) + ", + ffi_name: ray_tracing_motion_blur, + ffi_members: [features_ray_tracing_motion_blur_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_tracing_motion_blur_pipeline_trace_rays_indirect => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html#features-rayTracingMotionBlurPipelineTraceRaysIndirect) + ", + ffi_name: ray_tracing_motion_blur_pipeline_trace_rays_indirect, + ffi_members: [features_ray_tracing_motion_blur_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_tracing_pipeline => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html#features-rayTracingPipeline) + ", + ffi_name: ray_tracing_pipeline, + ffi_members: [features_ray_tracing_pipeline_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_tracing_pipeline_shader_group_handle_capture_replay => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html#features-rayTracingPipelineShaderGroupHandleCaptureReplay) + ", + ffi_name: ray_tracing_pipeline_shader_group_handle_capture_replay, + ffi_members: [features_ray_tracing_pipeline_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html#features-rayTracingPipelineShaderGroupHandleCaptureReplayMixed) + ", + ffi_name: ray_tracing_pipeline_shader_group_handle_capture_replay_mixed, + ffi_members: [features_ray_tracing_pipeline_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_tracing_pipeline_trace_rays_indirect => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html#features-rayTracingPipelineTraceRaysIndirect) + ", + ffi_name: ray_tracing_pipeline_trace_rays_indirect, + ffi_members: [features_ray_tracing_pipeline_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ray_traversal_primitive_culling => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html#features-rayTraversalPrimitiveCulling) + ", + ffi_name: ray_traversal_primitive_culling, + ffi_members: [features_ray_tracing_pipeline_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + rectangular_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html#features-rectangularLines) + ", + ffi_name: rectangular_lines, + ffi_members: [features_line_rasterization_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + representative_fragment_test => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html#features-representativeFragmentTest) + ", + ffi_name: representative_fragment_test, + ffi_members: [features_representative_fragment_test_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + robust_buffer_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-robustBufferAccess) + ", + ffi_name: robust_buffer_access, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + robust_buffer_access2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html#features-robustBufferAccess2) + ", + ffi_name: robust_buffer_access2, + ffi_members: [features_robustness2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + robust_image_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageRobustnessFeaturesEXT.html#features-robustImageAccess) + ", + ffi_name: robust_image_access, + ffi_members: [features_image_robustness_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + robust_image_access2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html#features-robustImageAccess2) + ", + ffi_name: robust_image_access2, + ffi_members: [features_robustness2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + runtime_descriptor_array => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-runtimeDescriptorArray) + ", + ffi_name: runtime_descriptor_array, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sample_rate_shading => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sampleRateShading) + ", + ffi_name: sample_rate_shading, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sampler_anisotropy => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-samplerAnisotropy) + ", + ffi_name: sampler_anisotropy, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sampler_filter_minmax => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-samplerFilterMinmax) + - Required by device extension: [`ext_sampler_filter_minmax`](crate::device::DeviceExtensions::ext_sampler_filter_minmax) + ", + ffi_name: sampler_filter_minmax, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [ext_sampler_filter_minmax], + }, + sampler_mip_lod_bias => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-samplerMipLodBias) + ", + ffi_name: sampler_mip_lod_bias, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sampler_mirror_clamp_to_edge => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-samplerMirrorClampToEdge) + - Required by device extension: [`khr_sampler_mirror_clamp_to_edge`](crate::device::DeviceExtensions::khr_sampler_mirror_clamp_to_edge) + ", + ffi_name: sampler_mirror_clamp_to_edge, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [khr_sampler_mirror_clamp_to_edge], + }, + sampler_ycbcr_conversion => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-samplerYcbcrConversion) + ", + ffi_name: sampler_ycbcr_conversion, + ffi_members: [features_vulkan11, features_sampler_ycbcr_conversion], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + scalar_block_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-scalarBlockLayout) + ", + ffi_name: scalar_block_layout, + ffi_members: [features_vulkan12, features_scalar_block_layout], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + separate_depth_stencil_layouts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-separateDepthStencilLayouts) + ", + ffi_name: separate_depth_stencil_layouts, + ffi_members: [features_vulkan12, features_separate_depth_stencil_layouts], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + separate_stencil_mask_ref => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-separateStencilMaskRef) + ", + ffi_name: separate_stencil_mask_ref, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float16_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderBufferFloat16AtomicAdd) + ", + ffi_name: shader_buffer_float16_atomic_add, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float16_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderBufferFloat16AtomicMinMax) + ", + ffi_name: shader_buffer_float16_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float16_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderBufferFloat16Atomics) + ", + ffi_name: shader_buffer_float16_atomics, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float32_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderBufferFloat32AtomicAdd) + ", + ffi_name: shader_buffer_float32_atomic_add, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float32_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderBufferFloat32AtomicMinMax) + ", + ffi_name: shader_buffer_float32_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float32_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderBufferFloat32Atomics) + ", + ffi_name: shader_buffer_float32_atomics, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float64_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderBufferFloat64AtomicAdd) + ", + ffi_name: shader_buffer_float64_atomic_add, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float64_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderBufferFloat64AtomicMinMax) + ", + ffi_name: shader_buffer_float64_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_float64_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderBufferFloat64Atomics) + ", + ffi_name: shader_buffer_float64_atomics, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_buffer_int64_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderBufferInt64Atomics) + ", + ffi_name: shader_buffer_int64_atomics, + ffi_members: [features_vulkan12, features_shader_atomic_int64], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_clip_distance => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderClipDistance) + ", + ffi_name: shader_clip_distance, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_cull_distance => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderCullDistance) + ", + ffi_name: shader_cull_distance, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_demote_to_helper_invocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.html#features-shaderDemoteToHelperInvocation) + ", + ffi_name: shader_demote_to_helper_invocation, + ffi_members: [features_shader_demote_to_helper_invocation_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_device_clock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html#features-shaderDeviceClock) + ", + ffi_name: shader_device_clock, + ffi_members: [features_shader_clock_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_draw_parameters => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-shaderDrawParameters) + - Required by device extension: [`khr_shader_draw_parameters`](crate::device::DeviceExtensions::khr_shader_draw_parameters) + ", + ffi_name: shader_draw_parameters, + ffi_members: [features_vulkan11, features_shader_draw_parameters], + requires_features: [], + conflicts_features: [], + required_by_extensions: [khr_shader_draw_parameters], + }, + shader_float16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderFloat16) + ", + ffi_name: shader_float16, + ffi_members: [features_vulkan12, features_shader_float16_int8], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_float64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderFloat64) + ", + ffi_name: shader_float64, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_image_float32_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderImageFloat32AtomicAdd) + ", + ffi_name: shader_image_float32_atomic_add, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_image_float32_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderImageFloat32AtomicMinMax) + ", + ffi_name: shader_image_float32_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_image_float32_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderImageFloat32Atomics) + ", + ffi_name: shader_image_float32_atomics, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_image_gather_extended => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderImageGatherExtended) + ", + ffi_name: shader_image_gather_extended, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_image_int64_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html#features-shaderImageInt64Atomics) + ", + ffi_name: shader_image_int64_atomics, + ffi_members: [features_shader_image_atomic_int64_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_input_attachment_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderInputAttachmentArrayDynamicIndexing) + ", + ffi_name: shader_input_attachment_array_dynamic_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_input_attachment_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderInputAttachmentArrayNonUniformIndexing) + ", + ffi_name: shader_input_attachment_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_int16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderInt16) + ", + ffi_name: shader_int16, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_int64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderInt64) + ", + ffi_name: shader_int64, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_int8 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderInt8) + ", + ffi_name: shader_int8, + ffi_members: [features_vulkan12, features_shader_float16_int8], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_integer_functions2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html#features-shaderIntegerFunctions2) + ", + ffi_name: shader_integer_functions2, + ffi_members: [features_shader_integer_functions2_intel], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_output_layer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderOutputLayer) + - Required by device extension: [`ext_shader_viewport_index_layer`](crate::device::DeviceExtensions::ext_shader_viewport_index_layer) + ", + ffi_name: shader_output_layer, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [ext_shader_viewport_index_layer], + }, + shader_output_viewport_index => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderOutputViewportIndex) + - Required by device extension: [`ext_shader_viewport_index_layer`](crate::device::DeviceExtensions::ext_shader_viewport_index_layer) + ", + ffi_name: shader_output_viewport_index, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [ext_shader_viewport_index_layer], + }, + shader_resource_min_lod => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderResourceMinLod) + ", + ffi_name: shader_resource_min_lod, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_resource_residency => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderResourceResidency) + ", + ffi_name: shader_resource_residency, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_sample_rate_interpolation_functions => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-shaderSampleRateInterpolationFunctions) + ", + ffi_name: shader_sample_rate_interpolation_functions, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_sampled_image_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderSampledImageArrayDynamicIndexing) + ", + ffi_name: shader_sampled_image_array_dynamic_indexing, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_sampled_image_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderSampledImageArrayNonUniformIndexing) + ", + ffi_name: shader_sampled_image_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float16_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderSharedFloat16AtomicAdd) + ", + ffi_name: shader_shared_float16_atomic_add, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float16_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderSharedFloat16AtomicMinMax) + ", + ffi_name: shader_shared_float16_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float16_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderSharedFloat16Atomics) + ", + ffi_name: shader_shared_float16_atomics, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float32_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderSharedFloat32AtomicAdd) + ", + ffi_name: shader_shared_float32_atomic_add, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float32_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderSharedFloat32AtomicMinMax) + ", + ffi_name: shader_shared_float32_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float32_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderSharedFloat32Atomics) + ", + ffi_name: shader_shared_float32_atomics, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float64_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderSharedFloat64AtomicAdd) + ", + ffi_name: shader_shared_float64_atomic_add, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float64_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-shaderSharedFloat64AtomicMinMax) + ", + ffi_name: shader_shared_float64_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_float64_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-shaderSharedFloat64Atomics) + ", + ffi_name: shader_shared_float64_atomics, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_shared_int64_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderSharedInt64Atomics) + ", + ffi_name: shader_shared_int64_atomics, + ffi_members: [features_vulkan12, features_shader_atomic_int64], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_sm_builtins => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html#features-shaderSMBuiltins) + ", + ffi_name: shader_sm_builtins, + ffi_members: [features_shader_sm_builtins_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_buffer_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderStorageBufferArrayDynamicIndexing) + ", + ffi_name: shader_storage_buffer_array_dynamic_indexing, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_buffer_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderStorageBufferArrayNonUniformIndexing) + ", + ffi_name: shader_storage_buffer_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_image_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderStorageImageArrayDynamicIndexing) + ", + ffi_name: shader_storage_image_array_dynamic_indexing, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_image_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderStorageImageArrayNonUniformIndexing) + ", + ffi_name: shader_storage_image_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_image_extended_formats => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderStorageImageExtendedFormats) + ", + ffi_name: shader_storage_image_extended_formats, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_image_multisample => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderStorageImageMultisample) + ", + ffi_name: shader_storage_image_multisample, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_image_read_without_format => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderStorageImageReadWithoutFormat) + ", + ffi_name: shader_storage_image_read_without_format, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_image_write_without_format => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderStorageImageWriteWithoutFormat) + ", + ffi_name: shader_storage_image_write_without_format, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_texel_buffer_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderStorageTexelBufferArrayDynamicIndexing) + ", + ffi_name: shader_storage_texel_buffer_array_dynamic_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_storage_texel_buffer_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderStorageTexelBufferArrayNonUniformIndexing) + ", + ffi_name: shader_storage_texel_buffer_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_subgroup_clock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html#features-shaderSubgroupClock) + ", + ffi_name: shader_subgroup_clock, + ffi_members: [features_shader_clock_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_subgroup_extended_types => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderSubgroupExtendedTypes) + ", + ffi_name: shader_subgroup_extended_types, + ffi_members: [features_vulkan12, features_shader_subgroup_extended_types], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_subgroup_uniform_control_flow => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html#features-shaderSubgroupUniformControlFlow) + ", + ffi_name: shader_subgroup_uniform_control_flow, + ffi_members: [features_shader_subgroup_uniform_control_flow_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_terminate_invocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.html#features-shaderTerminateInvocation) + ", + ffi_name: shader_terminate_invocation, + ffi_members: [features_shader_terminate_invocation_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_tessellation_and_geometry_point_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderTessellationAndGeometryPointSize) + ", + ffi_name: shader_tessellation_and_geometry_point_size, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_uniform_buffer_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-shaderUniformBufferArrayDynamicIndexing) + ", + ffi_name: shader_uniform_buffer_array_dynamic_indexing, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_uniform_buffer_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderUniformBufferArrayNonUniformIndexing) + ", + ffi_name: shader_uniform_buffer_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_uniform_texel_buffer_array_dynamic_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderUniformTexelBufferArrayDynamicIndexing) + ", + ffi_name: shader_uniform_texel_buffer_array_dynamic_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_uniform_texel_buffer_array_non_uniform_indexing => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-shaderUniformTexelBufferArrayNonUniformIndexing) + ", + ffi_name: shader_uniform_texel_buffer_array_non_uniform_indexing, + ffi_members: [features_vulkan12, features_descriptor_indexing], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shader_zero_initialize_workgroup_memory => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.html#features-shaderZeroInitializeWorkgroupMemory) + ", + ffi_name: shader_zero_initialize_workgroup_memory, + ffi_members: [features_zero_initialize_workgroup_memory_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shading_rate_coarse_sample_order => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html#features-shadingRateCoarseSampleOrder) + ", + ffi_name: shading_rate_coarse_sample_order, + ffi_members: [features_shading_rate_image_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + shading_rate_image => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html#features-shadingRateImage) + - Conflicts with features: [`pipeline_fragment_shading_rate`](crate::device::Features::pipeline_fragment_shading_rate), [`primitive_fragment_shading_rate`](crate::device::Features::primitive_fragment_shading_rate), [`attachment_fragment_shading_rate`](crate::device::Features::attachment_fragment_shading_rate) + ", + ffi_name: shading_rate_image, + ffi_members: [features_shading_rate_image_nv], + requires_features: [], + conflicts_features: [pipeline_fragment_shading_rate, primitive_fragment_shading_rate, attachment_fragment_shading_rate], + required_by_extensions: [], + }, + smooth_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html#features-smoothLines) + ", + ffi_name: smooth_lines, + ffi_members: [features_line_rasterization_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_binding => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseBinding) + ", + ffi_name: sparse_binding, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_image_float32_atomic_add => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-sparseImageFloat32AtomicAdd) + - Requires feature: [`shader_image_float32_atomic_add`](crate::device::Features::shader_image_float32_atomic_add) + ", + ffi_name: sparse_image_float32_atomic_add, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [shader_image_float32_atomic_add], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_image_float32_atomic_min_max => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html#features-sparseImageFloat32AtomicMinMax) + ", + ffi_name: sparse_image_float32_atomic_min_max, + ffi_members: [features_shader_atomic_float2_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_image_float32_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html#features-sparseImageFloat32Atomics) + - Requires feature: [`shader_image_float32_atomics`](crate::device::Features::shader_image_float32_atomics) + ", + ffi_name: sparse_image_float32_atomics, + ffi_members: [features_shader_atomic_float_ext], + requires_features: [shader_image_float32_atomics], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_image_int64_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html#features-sparseImageInt64Atomics) + - Requires feature: [`shader_image_int64_atomics`](crate::device::Features::shader_image_int64_atomics) + ", + ffi_name: sparse_image_int64_atomics, + ffi_members: [features_shader_image_atomic_int64_ext], + requires_features: [shader_image_int64_atomics], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency16_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidency16Samples) + ", + ffi_name: sparse_residency16_samples, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency2_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidency2Samples) + ", + ffi_name: sparse_residency2_samples, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency4_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidency4Samples) + ", + ffi_name: sparse_residency4_samples, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency8_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidency8Samples) + ", + ffi_name: sparse_residency8_samples, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency_aliased => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidencyAliased) + ", + ffi_name: sparse_residency_aliased, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency_buffer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidencyBuffer) + ", + ffi_name: sparse_residency_buffer, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency_image2_d => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidencyImage2D) + ", + ffi_name: sparse_residency_image2_d, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + sparse_residency_image3_d => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-sparseResidencyImage3D) + ", + ffi_name: sparse_residency_image3_d, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + stippled_bresenham_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html#features-stippledBresenhamLines) + ", + ffi_name: stippled_bresenham_lines, + ffi_members: [features_line_rasterization_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + stippled_rectangular_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html#features-stippledRectangularLines) + ", + ffi_name: stippled_rectangular_lines, + ffi_members: [features_line_rasterization_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + stippled_smooth_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html#features-stippledSmoothLines) + ", + ffi_name: stippled_smooth_lines, + ffi_members: [features_line_rasterization_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + storage_buffer16_bit_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-storageBuffer16BitAccess) + ", + ffi_name: storage_buffer16_bit_access, + ffi_members: [features_vulkan11, features_16bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + storage_buffer8_bit_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-storageBuffer8BitAccess) + ", + ffi_name: storage_buffer8_bit_access, + ffi_members: [features_vulkan12, features_8bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + storage_input_output16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-storageInputOutput16) + ", + ffi_name: storage_input_output16, + ffi_members: [features_vulkan11, features_16bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + storage_push_constant16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-storagePushConstant16) + ", + ffi_name: storage_push_constant16, + ffi_members: [features_vulkan11, features_16bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + storage_push_constant8 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-storagePushConstant8) + ", + ffi_name: storage_push_constant8, + ffi_members: [features_vulkan12, features_8bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + subgroup_broadcast_dynamic_id => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-subgroupBroadcastDynamicId) + ", + ffi_name: subgroup_broadcast_dynamic_id, + ffi_members: [features_vulkan12], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + subgroup_size_control => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html#features-subgroupSizeControl) + ", + ffi_name: subgroup_size_control, + ffi_members: [features_subgroup_size_control_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + subpass_shading => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html#features-subpassShading) + ", + ffi_name: subpass_shading, + ffi_members: [features_subpass_shading_huawei], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + supersample_fragment_shading_rates => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html#features-supersampleFragmentShadingRates) + ", + ffi_name: supersample_fragment_shading_rates, + ffi_members: [features_fragment_shading_rate_enums_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + synchronization2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSynchronization2FeaturesKHR.html#features-synchronization2) + ", + ffi_name: synchronization2, + ffi_members: [features_synchronization2_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + task_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html#features-taskShader) + ", + ffi_name: task_shader, + ffi_members: [features_mesh_shader_nv], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + tessellation_isolines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-tessellationIsolines) + ", + ffi_name: tessellation_isolines, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + tessellation_point_mode => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-tessellationPointMode) + ", + ffi_name: tessellation_point_mode, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + tessellation_shader => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-tessellationShader) + ", + ffi_name: tessellation_shader, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + texel_buffer_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html#features-texelBufferAlignment) + ", + ffi_name: texel_buffer_alignment, + ffi_members: [features_texel_buffer_alignment_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + texture_compression_astc_hdr => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.html#features-textureCompressionASTC_HDR) + ", + ffi_name: texture_compression_astc_hdr, + ffi_members: [features_texture_compression_astchdr_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + texture_compression_astc_ldr => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-textureCompressionASTC_LDR) + ", + ffi_name: texture_compression_astc_ldr, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + texture_compression_bc => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-textureCompressionBC) + ", + ffi_name: texture_compression_bc, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + texture_compression_etc2 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-textureCompressionETC2) + ", + ffi_name: texture_compression_etc2, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + timeline_semaphore => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-timelineSemaphore) + ", + ffi_name: timeline_semaphore, + ffi_members: [features_vulkan12, features_timeline_semaphore], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + transform_feedback => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html#features-transformFeedback) + ", + ffi_name: transform_feedback, + ffi_members: [features_transform_feedback_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + transform_feedback_preserves_provoking_vertex => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html#features-transformFeedbackPreservesProvokingVertex) + ", + ffi_name: transform_feedback_preserves_provoking_vertex, + ffi_members: [features_provoking_vertex_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + triangle_fans => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-triangleFans) + ", + ffi_name: triangle_fans, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + uniform_and_storage_buffer16_bit_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-uniformAndStorageBuffer16BitAccess) + ", + ffi_name: uniform_and_storage_buffer16_bit_access, + ffi_members: [features_vulkan11, features_16bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + uniform_and_storage_buffer8_bit_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-uniformAndStorageBuffer8BitAccess) + ", + ffi_name: uniform_and_storage_buffer8_bit_access, + ffi_members: [features_vulkan12, features_8bit_storage], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + uniform_buffer_standard_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-uniformBufferStandardLayout) + ", + ffi_name: uniform_buffer_standard_layout, + ffi_members: [features_vulkan12, features_uniform_buffer_standard_layout], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + variable_multisample_rate => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-variableMultisampleRate) + ", + ffi_name: variable_multisample_rate, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + variable_pointers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-variablePointers) + ", + ffi_name: variable_pointers, + ffi_members: [features_vulkan11, features_variable_pointers], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + variable_pointers_storage_buffer => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html#features-variablePointersStorageBuffer) + ", + ffi_name: variable_pointers_storage_buffer, + ffi_members: [features_vulkan11, features_variable_pointers], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vertex_attribute_access_beyond_stride => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html#features-vertexAttributeAccessBeyondStride) + ", + ffi_name: vertex_attribute_access_beyond_stride, + ffi_members: [features_portability_subset_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vertex_attribute_instance_rate_divisor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html#features-vertexAttributeInstanceRateDivisor) + ", + ffi_name: vertex_attribute_instance_rate_divisor, + ffi_members: [features_vertex_attribute_divisor_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vertex_attribute_instance_rate_zero_divisor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html#features-vertexAttributeInstanceRateZeroDivisor) + ", + ffi_name: vertex_attribute_instance_rate_zero_divisor, + ffi_members: [features_vertex_attribute_divisor_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vertex_input_dynamic_state => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html#features-vertexInputDynamicState) + ", + ffi_name: vertex_input_dynamic_state, + ffi_members: [features_vertex_input_dynamic_state_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vertex_pipeline_stores_and_atomics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-vertexPipelineStoresAndAtomics) + ", + ffi_name: vertex_pipeline_stores_and_atomics, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vulkan_memory_model => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-vulkanMemoryModel) + ", + ffi_name: vulkan_memory_model, + ffi_members: [features_vulkan12, features_vulkan_memory_model], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vulkan_memory_model_availability_visibility_chains => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-vulkanMemoryModelAvailabilityVisibilityChains) + ", + ffi_name: vulkan_memory_model_availability_visibility_chains, + ffi_members: [features_vulkan12, features_vulkan_memory_model], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + vulkan_memory_model_device_scope => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html#features-vulkanMemoryModelDeviceScope) + ", + ffi_name: vulkan_memory_model_device_scope, + ffi_members: [features_vulkan12, features_vulkan_memory_model], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + wide_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html#features-wideLines) + ", + ffi_name: wide_lines, + ffi_members: [features_vulkan10.features], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + workgroup_memory_explicit_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html#features-workgroupMemoryExplicitLayout) + ", + ffi_name: workgroup_memory_explicit_layout, + ffi_members: [features_workgroup_memory_explicit_layout_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + workgroup_memory_explicit_layout16_bit_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html#features-workgroupMemoryExplicitLayout16BitAccess) + ", + ffi_name: workgroup_memory_explicit_layout16_bit_access, + ffi_members: [features_workgroup_memory_explicit_layout_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + workgroup_memory_explicit_layout8_bit_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html#features-workgroupMemoryExplicitLayout8BitAccess) + ", + ffi_name: workgroup_memory_explicit_layout8_bit_access, + ffi_members: [features_workgroup_memory_explicit_layout_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + workgroup_memory_explicit_layout_scalar_block_layout => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html#features-workgroupMemoryExplicitLayoutScalarBlockLayout) + ", + ffi_name: workgroup_memory_explicit_layout_scalar_block_layout, + ffi_members: [features_workgroup_memory_explicit_layout_khr], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ycbcr2plane444_formats => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html#features-ycbcr2plane444Formats) + ", + ffi_name: ycbcr2plane444_formats, + ffi_members: [features_ycbcr2_plane444_formats_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, + ycbcr_image_arrays => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html#features-ycbcrImageArrays) + ", + ffi_name: ycbcr_image_arrays, + ffi_members: [features_ycbcr_image_arrays_ext], + requires_features: [], + conflicts_features: [], + required_by_extensions: [], + }, +} + +crate::device::features::features_ffi! { + api_version, + device_extensions, + instance_extensions, + features_vulkan11 => { + ty: PhysicalDeviceVulkan11Features, + provided_by: [api_version >= crate::Version::V1_2], + conflicts: [], + }, + features_vulkan12 => { + ty: PhysicalDeviceVulkan12Features, + provided_by: [api_version >= crate::Version::V1_2], + conflicts: [], + }, + features_16bit_storage => { + ty: PhysicalDevice16BitStorageFeatures, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_16bit_storage], + conflicts: [features_vulkan11], + }, + features_multiview => { + ty: PhysicalDeviceMultiviewFeatures, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_multiview], + conflicts: [features_vulkan11], + }, + features_protected_memory => { + ty: PhysicalDeviceProtectedMemoryFeatures, + provided_by: [api_version >= crate::Version::V1_1], + conflicts: [features_vulkan11], + }, + features_sampler_ycbcr_conversion => { + ty: PhysicalDeviceSamplerYcbcrConversionFeatures, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_sampler_ycbcr_conversion], + conflicts: [features_vulkan11], + }, + features_shader_draw_parameters => { + ty: PhysicalDeviceShaderDrawParametersFeatures, + provided_by: [api_version >= crate::Version::V1_1], + conflicts: [features_vulkan11], + }, + features_variable_pointers => { + ty: PhysicalDeviceVariablePointersFeatures, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_variable_pointers], + conflicts: [features_vulkan11], + }, + features_8bit_storage => { + ty: PhysicalDevice8BitStorageFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_8bit_storage], + conflicts: [features_vulkan12], + }, + features_buffer_device_address => { + ty: PhysicalDeviceBufferDeviceAddressFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_buffer_device_address], + conflicts: [features_vulkan12], + }, + features_descriptor_indexing => { + ty: PhysicalDeviceDescriptorIndexingFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.ext_descriptor_indexing], + conflicts: [features_vulkan12], + }, + features_host_query_reset => { + ty: PhysicalDeviceHostQueryResetFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.ext_host_query_reset], + conflicts: [features_vulkan12], + }, + features_imageless_framebuffer => { + ty: PhysicalDeviceImagelessFramebufferFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_imageless_framebuffer], + conflicts: [features_vulkan12], + }, + features_scalar_block_layout => { + ty: PhysicalDeviceScalarBlockLayoutFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.ext_scalar_block_layout], + conflicts: [features_vulkan12], + }, + features_separate_depth_stencil_layouts => { + ty: PhysicalDeviceSeparateDepthStencilLayoutsFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_separate_depth_stencil_layouts], + conflicts: [features_vulkan12], + }, + features_shader_atomic_int64 => { + ty: PhysicalDeviceShaderAtomicInt64Features, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_shader_atomic_int64], + conflicts: [features_vulkan12], + }, + features_shader_float16_int8 => { + ty: PhysicalDeviceShaderFloat16Int8Features, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_shader_float16_int8], + conflicts: [features_vulkan12], + }, + features_shader_subgroup_extended_types => { + ty: PhysicalDeviceShaderSubgroupExtendedTypesFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_shader_subgroup_extended_types], + conflicts: [features_vulkan12], + }, + features_timeline_semaphore => { + ty: PhysicalDeviceTimelineSemaphoreFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_timeline_semaphore], + conflicts: [features_vulkan12], + }, + features_uniform_buffer_standard_layout => { + ty: PhysicalDeviceUniformBufferStandardLayoutFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_uniform_buffer_standard_layout], + conflicts: [features_vulkan12], + }, + features_vulkan_memory_model => { + ty: PhysicalDeviceVulkanMemoryModelFeatures, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_vulkan_memory_model], + conflicts: [features_vulkan12], + }, + features_acceleration_structure_khr => { + ty: PhysicalDeviceAccelerationStructureFeaturesKHR, + provided_by: [device_extensions.khr_acceleration_structure], + conflicts: [], + }, + features_fragment_shading_rate_khr => { + ty: PhysicalDeviceFragmentShadingRateFeaturesKHR, + provided_by: [device_extensions.khr_fragment_shading_rate], + conflicts: [], + }, + features_performance_query_khr => { + ty: PhysicalDevicePerformanceQueryFeaturesKHR, + provided_by: [device_extensions.khr_performance_query], + conflicts: [], + }, + features_pipeline_executable_properties_khr => { + ty: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, + provided_by: [device_extensions.khr_pipeline_executable_properties], + conflicts: [], + }, + features_portability_subset_khr => { + ty: PhysicalDevicePortabilitySubsetFeaturesKHR, + provided_by: [device_extensions.khr_portability_subset], + conflicts: [], + }, + features_present_id_khr => { + ty: PhysicalDevicePresentIdFeaturesKHR, + provided_by: [device_extensions.khr_present_id], + conflicts: [], + }, + features_present_wait_khr => { + ty: PhysicalDevicePresentWaitFeaturesKHR, + provided_by: [device_extensions.khr_present_wait], + conflicts: [], + }, + features_ray_query_khr => { + ty: PhysicalDeviceRayQueryFeaturesKHR, + provided_by: [device_extensions.khr_ray_query], + conflicts: [], + }, + features_ray_tracing_pipeline_khr => { + ty: PhysicalDeviceRayTracingPipelineFeaturesKHR, + provided_by: [device_extensions.khr_ray_tracing_pipeline], + conflicts: [], + }, + features_shader_clock_khr => { + ty: PhysicalDeviceShaderClockFeaturesKHR, + provided_by: [device_extensions.khr_shader_clock], + conflicts: [], + }, + features_shader_subgroup_uniform_control_flow_khr => { + ty: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, + provided_by: [device_extensions.khr_shader_subgroup_uniform_control_flow], + conflicts: [], + }, + features_shader_terminate_invocation_khr => { + ty: PhysicalDeviceShaderTerminateInvocationFeaturesKHR, + provided_by: [device_extensions.khr_shader_terminate_invocation], + conflicts: [], + }, + features_synchronization2_khr => { + ty: PhysicalDeviceSynchronization2FeaturesKHR, + provided_by: [device_extensions.khr_synchronization2], + conflicts: [], + }, + features_workgroup_memory_explicit_layout_khr => { + ty: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, + provided_by: [device_extensions.khr_workgroup_memory_explicit_layout], + conflicts: [], + }, + features_zero_initialize_workgroup_memory_khr => { + ty: PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR, + provided_by: [device_extensions.khr_zero_initialize_workgroup_memory], + conflicts: [], + }, + features_4444formats_ext => { + ty: PhysicalDevice4444FormatsFeaturesEXT, + provided_by: [device_extensions.ext_4444_formats], + conflicts: [], + }, + features_astc_decode_ext => { + ty: PhysicalDeviceASTCDecodeFeaturesEXT, + provided_by: [device_extensions.ext_astc_decode_mode], + conflicts: [], + }, + features_blend_operation_advanced_ext => { + ty: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, + provided_by: [device_extensions.ext_blend_operation_advanced], + conflicts: [], + }, + features_buffer_device_address_ext => { + ty: PhysicalDeviceBufferDeviceAddressFeaturesEXT, + provided_by: [device_extensions.ext_buffer_device_address], + conflicts: [features_vulkan12, features_buffer_device_address], + }, + features_color_write_enable_ext => { + ty: PhysicalDeviceColorWriteEnableFeaturesEXT, + provided_by: [device_extensions.ext_color_write_enable], + conflicts: [], + }, + features_conditional_rendering_ext => { + ty: PhysicalDeviceConditionalRenderingFeaturesEXT, + provided_by: [device_extensions.ext_conditional_rendering], + conflicts: [], + }, + features_custom_border_color_ext => { + ty: PhysicalDeviceCustomBorderColorFeaturesEXT, + provided_by: [device_extensions.ext_custom_border_color], + conflicts: [], + }, + features_depth_clip_enable_ext => { + ty: PhysicalDeviceDepthClipEnableFeaturesEXT, + provided_by: [device_extensions.ext_depth_clip_enable], + conflicts: [], + }, + features_device_memory_report_ext => { + ty: PhysicalDeviceDeviceMemoryReportFeaturesEXT, + provided_by: [device_extensions.ext_device_memory_report], + conflicts: [], + }, + features_extended_dynamic_state2_ext => { + ty: PhysicalDeviceExtendedDynamicState2FeaturesEXT, + provided_by: [device_extensions.ext_extended_dynamic_state2], + conflicts: [], + }, + features_extended_dynamic_state_ext => { + ty: PhysicalDeviceExtendedDynamicStateFeaturesEXT, + provided_by: [device_extensions.ext_extended_dynamic_state], + conflicts: [], + }, + features_fragment_density_map2_ext => { + ty: PhysicalDeviceFragmentDensityMap2FeaturesEXT, + provided_by: [device_extensions.ext_fragment_density_map2], + conflicts: [], + }, + features_fragment_density_map_ext => { + ty: PhysicalDeviceFragmentDensityMapFeaturesEXT, + provided_by: [device_extensions.ext_fragment_density_map], + conflicts: [], + }, + features_fragment_shader_interlock_ext => { + ty: PhysicalDeviceFragmentShaderInterlockFeaturesEXT, + provided_by: [device_extensions.ext_fragment_shader_interlock], + conflicts: [], + }, + features_global_priority_query_ext => { + ty: PhysicalDeviceGlobalPriorityQueryFeaturesEXT, + provided_by: [device_extensions.ext_global_priority_query], + conflicts: [], + }, + features_image_robustness_ext => { + ty: PhysicalDeviceImageRobustnessFeaturesEXT, + provided_by: [device_extensions.ext_image_robustness], + conflicts: [], + }, + features_index_type_uint8_ext => { + ty: PhysicalDeviceIndexTypeUint8FeaturesEXT, + provided_by: [device_extensions.ext_index_type_uint8], + conflicts: [], + }, + features_inline_uniform_block_ext => { + ty: PhysicalDeviceInlineUniformBlockFeaturesEXT, + provided_by: [device_extensions.ext_inline_uniform_block], + conflicts: [], + }, + features_line_rasterization_ext => { + ty: PhysicalDeviceLineRasterizationFeaturesEXT, + provided_by: [device_extensions.ext_line_rasterization], + conflicts: [], + }, + features_memory_priority_ext => { + ty: PhysicalDeviceMemoryPriorityFeaturesEXT, + provided_by: [device_extensions.ext_memory_priority], + conflicts: [], + }, + features_multi_draw_ext => { + ty: PhysicalDeviceMultiDrawFeaturesEXT, + provided_by: [device_extensions.ext_multi_draw], + conflicts: [], + }, + features_pipeline_creation_cache_control_ext => { + ty: PhysicalDevicePipelineCreationCacheControlFeaturesEXT, + provided_by: [device_extensions.ext_pipeline_creation_cache_control], + conflicts: [], + }, + features_private_data_ext => { + ty: PhysicalDevicePrivateDataFeaturesEXT, + provided_by: [device_extensions.ext_private_data], + conflicts: [], + }, + features_provoking_vertex_ext => { + ty: PhysicalDeviceProvokingVertexFeaturesEXT, + provided_by: [device_extensions.ext_provoking_vertex], + conflicts: [], + }, + features_robustness2_ext => { + ty: PhysicalDeviceRobustness2FeaturesEXT, + provided_by: [device_extensions.ext_robustness2], + conflicts: [], + }, + features_shader_atomic_float2_ext => { + ty: PhysicalDeviceShaderAtomicFloat2FeaturesEXT, + provided_by: [device_extensions.ext_shader_atomic_float2], + conflicts: [], + }, + features_shader_atomic_float_ext => { + ty: PhysicalDeviceShaderAtomicFloatFeaturesEXT, + provided_by: [device_extensions.ext_shader_atomic_float], + conflicts: [], + }, + features_shader_demote_to_helper_invocation_ext => { + ty: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, + provided_by: [device_extensions.ext_shader_demote_to_helper_invocation], + conflicts: [], + }, + features_shader_image_atomic_int64_ext => { + ty: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, + provided_by: [device_extensions.ext_shader_image_atomic_int64], + conflicts: [], + }, + features_subgroup_size_control_ext => { + ty: PhysicalDeviceSubgroupSizeControlFeaturesEXT, + provided_by: [device_extensions.ext_subgroup_size_control], + conflicts: [], + }, + features_texel_buffer_alignment_ext => { + ty: PhysicalDeviceTexelBufferAlignmentFeaturesEXT, + provided_by: [device_extensions.ext_texel_buffer_alignment], + conflicts: [], + }, + features_texture_compression_astchdr_ext => { + ty: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, + provided_by: [device_extensions.ext_texture_compression_astc_hdr], + conflicts: [], + }, + features_transform_feedback_ext => { + ty: PhysicalDeviceTransformFeedbackFeaturesEXT, + provided_by: [device_extensions.ext_transform_feedback], + conflicts: [], + }, + features_vertex_attribute_divisor_ext => { + ty: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, + provided_by: [device_extensions.ext_vertex_attribute_divisor], + conflicts: [], + }, + features_vertex_input_dynamic_state_ext => { + ty: PhysicalDeviceVertexInputDynamicStateFeaturesEXT, + provided_by: [device_extensions.ext_vertex_input_dynamic_state], + conflicts: [], + }, + features_ycbcr2_plane444_formats_ext => { + ty: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, + provided_by: [device_extensions.ext_ycbcr_2plane_444_formats], + conflicts: [], + }, + features_ycbcr_image_arrays_ext => { + ty: PhysicalDeviceYcbcrImageArraysFeaturesEXT, + provided_by: [device_extensions.ext_ycbcr_image_arrays], + conflicts: [], + }, + features_coherent_memory_amd => { + ty: PhysicalDeviceCoherentMemoryFeaturesAMD, + provided_by: [device_extensions.amd_device_coherent_memory], + conflicts: [], + }, + features_compute_shader_derivatives_nv => { + ty: PhysicalDeviceComputeShaderDerivativesFeaturesNV, + provided_by: [device_extensions.nv_compute_shader_derivatives], + conflicts: [], + }, + features_cooperative_matrix_nv => { + ty: PhysicalDeviceCooperativeMatrixFeaturesNV, + provided_by: [device_extensions.nv_cooperative_matrix], + conflicts: [], + }, + features_corner_sampled_image_nv => { + ty: PhysicalDeviceCornerSampledImageFeaturesNV, + provided_by: [device_extensions.nv_corner_sampled_image], + conflicts: [], + }, + features_coverage_reduction_mode_nv => { + ty: PhysicalDeviceCoverageReductionModeFeaturesNV, + provided_by: [device_extensions.nv_coverage_reduction_mode], + conflicts: [], + }, + features_dedicated_allocation_image_aliasing_nv => { + ty: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, + provided_by: [device_extensions.nv_dedicated_allocation_image_aliasing], + conflicts: [], + }, + features_device_generated_commands_nv => { + ty: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, + provided_by: [device_extensions.nv_device_generated_commands], + conflicts: [], + }, + features_diagnostics_config_nv => { + ty: PhysicalDeviceDiagnosticsConfigFeaturesNV, + provided_by: [device_extensions.nv_device_diagnostics_config], + conflicts: [], + }, + features_exclusive_scissor_nv => { + ty: PhysicalDeviceExclusiveScissorFeaturesNV, + provided_by: [device_extensions.nv_scissor_exclusive], + conflicts: [], + }, + features_external_memory_rdma_nv => { + ty: PhysicalDeviceExternalMemoryRDMAFeaturesNV, + provided_by: [device_extensions.nv_external_memory_rdma], + conflicts: [], + }, + features_fragment_shader_barycentric_nv => { + ty: PhysicalDeviceFragmentShaderBarycentricFeaturesNV, + provided_by: [device_extensions.nv_fragment_shader_barycentric], + conflicts: [], + }, + features_fragment_shading_rate_enums_nv => { + ty: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, + provided_by: [device_extensions.nv_fragment_shading_rate_enums], + conflicts: [], + }, + features_inherited_viewport_scissor_nv => { + ty: PhysicalDeviceInheritedViewportScissorFeaturesNV, + provided_by: [device_extensions.nv_inherited_viewport_scissor], + conflicts: [], + }, + features_invocation_mask_huawei => { + ty: PhysicalDeviceInvocationMaskFeaturesHUAWEI, + provided_by: [device_extensions.huawei_invocation_mask], + conflicts: [], + }, + features_mesh_shader_nv => { + ty: PhysicalDeviceMeshShaderFeaturesNV, + provided_by: [device_extensions.nv_mesh_shader], + conflicts: [], + }, + features_mutable_descriptor_type_valve => { + ty: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, + provided_by: [device_extensions.valve_mutable_descriptor_type], + conflicts: [], + }, + features_ray_tracing_motion_blur_nv => { + ty: PhysicalDeviceRayTracingMotionBlurFeaturesNV, + provided_by: [device_extensions.nv_ray_tracing_motion_blur], + conflicts: [], + }, + features_representative_fragment_test_nv => { + ty: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, + provided_by: [device_extensions.nv_representative_fragment_test], + conflicts: [], + }, + features_shader_image_footprint_nv => { + ty: PhysicalDeviceShaderImageFootprintFeaturesNV, + provided_by: [device_extensions.nv_shader_image_footprint], + conflicts: [], + }, + features_shader_integer_functions2_intel => { + ty: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, + provided_by: [device_extensions.intel_shader_integer_functions2], + conflicts: [], + }, + features_shader_sm_builtins_nv => { + ty: PhysicalDeviceShaderSMBuiltinsFeaturesNV, + provided_by: [device_extensions.nv_shader_sm_builtins], + conflicts: [], + }, + features_shading_rate_image_nv => { + ty: PhysicalDeviceShadingRateImageFeaturesNV, + provided_by: [device_extensions.nv_shading_rate_image], + conflicts: [], + }, + features_subpass_shading_huawei => { + ty: PhysicalDeviceSubpassShadingFeaturesHUAWEI, + provided_by: [device_extensions.huawei_subpass_shading], + conflicts: [], + }, +} + +crate::device::properties::properties! { + active_compute_unit_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html#limits-activeComputeUnitCount) + ", + ty: u32, + ffi_name: active_compute_unit_count, + ffi_members: [properties_shader_core2_amd], + required: false, + }, + advanced_blend_all_operations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html#limits-advancedBlendAllOperations) + ", + ty: bool, + ffi_name: advanced_blend_all_operations, + ffi_members: [properties_blend_operation_advanced_ext], + required: false, + }, + advanced_blend_correlated_overlap => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html#limits-advancedBlendCorrelatedOverlap) + ", + ty: bool, + ffi_name: advanced_blend_correlated_overlap, + ffi_members: [properties_blend_operation_advanced_ext], + required: false, + }, + advanced_blend_independent_blend => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html#limits-advancedBlendIndependentBlend) + ", + ty: bool, + ffi_name: advanced_blend_independent_blend, + ffi_members: [properties_blend_operation_advanced_ext], + required: false, + }, + advanced_blend_max_color_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html#limits-advancedBlendMaxColorAttachments) + ", + ty: u32, + ffi_name: advanced_blend_max_color_attachments, + ffi_members: [properties_blend_operation_advanced_ext], + required: false, + }, + advanced_blend_non_premultiplied_dst_color => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html#limits-advancedBlendNonPremultipliedDstColor) + ", + ty: bool, + ffi_name: advanced_blend_non_premultiplied_dst_color, + ffi_members: [properties_blend_operation_advanced_ext], + required: false, + }, + advanced_blend_non_premultiplied_src_color => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html#limits-advancedBlendNonPremultipliedSrcColor) + ", + ty: bool, + ffi_name: advanced_blend_non_premultiplied_src_color, + ffi_members: [properties_blend_operation_advanced_ext], + required: false, + }, + allow_command_buffer_query_copies => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html#limits-allowCommandBufferQueryCopies) + ", + ty: bool, + ffi_name: allow_command_buffer_query_copies, + ffi_members: [properties_performance_query_khr], + required: false, + }, + api_version => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-apiVersion) + ", + ty: crate::Version, + ffi_name: api_version, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + buffer_image_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-bufferImageGranularity) + ", + ty: crate::DeviceSize, + ffi_name: buffer_image_granularity, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + compute_units_per_shader_array => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-computeUnitsPerShaderArray) + ", + ty: u32, + ffi_name: compute_units_per_shader_array, + ffi_members: [properties_shader_core_amd], + required: false, + }, + conformance_version => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-conformanceVersion) + ", + ty: crate::device::physical::ConformanceVersion, + ffi_name: conformance_version, + ffi_members: [properties_vulkan12, properties_driver], + required: false, + }, + conservative_point_and_line_rasterization => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-conservativePointAndLineRasterization) + ", + ty: bool, + ffi_name: conservative_point_and_line_rasterization, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + conservative_rasterization_post_depth_coverage => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-conservativeRasterizationPostDepthCoverage) + ", + ty: bool, + ffi_name: conservative_rasterization_post_depth_coverage, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + cooperative_matrix_supported_stages => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html#limits-cooperativeMatrixSupportedStages) + ", + ty: crate::pipeline::shader::ShaderStages, + ffi_name: cooperative_matrix_supported_stages, + ffi_members: [properties_cooperative_matrix_nv], + required: false, + }, + degenerate_lines_rasterized => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-degenerateLinesRasterized) + ", + ty: bool, + ffi_name: degenerate_lines_rasterized, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + degenerate_triangles_rasterized => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-degenerateTrianglesRasterized) + ", + ty: bool, + ffi_name: degenerate_triangles_rasterized, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + denorm_behavior_independence => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-denormBehaviorIndependence) + ", + ty: crate::device::physical::ShaderFloatControlsIndependence, + ffi_name: denorm_behavior_independence, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + device_id => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-deviceID) + ", + ty: u32, + ffi_name: device_id, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + device_luid => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-deviceLUID) + ", + ty: [u8; 8], + ffi_name: device_luid, + ffi_members: [properties_vulkan11, properties_id], + required: false, + }, + device_luid_valid => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-deviceLUIDValid) + ", + ty: bool, + ffi_name: device_luid_valid, + ffi_members: [properties_vulkan11, properties_id], + required: false, + }, + device_name => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-deviceName) + ", + ty: String, + ffi_name: device_name, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + device_node_mask => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-deviceNodeMask) + ", + ty: u32, + ffi_name: device_node_mask, + ffi_members: [properties_vulkan11, properties_id], + required: false, + }, + device_type => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-deviceType) + ", + ty: crate::device::physical::PhysicalDeviceType, + ffi_name: device_type, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + device_uuid => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-deviceUUID) + ", + ty: [u8; 16], + ffi_name: device_uuid, + ffi_members: [properties_vulkan11, properties_id], + required: false, + }, + discrete_queue_priorities => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-discreteQueuePriorities) + ", + ty: u32, + ffi_name: discrete_queue_priorities, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + driver_id => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-driverID) + ", + ty: crate::device::physical::DriverId, + ffi_name: driver_id, + ffi_members: [properties_vulkan12, properties_driver], + required: false, + }, + driver_info => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-driverInfo) + ", + ty: String, + ffi_name: driver_info, + ffi_members: [properties_vulkan12, properties_driver], + required: false, + }, + driver_name => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-driverName) + ", + ty: String, + ffi_name: driver_name, + ffi_members: [properties_vulkan12, properties_driver], + required: false, + }, + driver_uuid => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-driverUUID) + ", + ty: [u8; 16], + ffi_name: driver_uuid, + ffi_members: [properties_vulkan11, properties_id], + required: false, + }, + driver_version => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-driverVersion) + ", + ty: u32, + ffi_name: driver_version, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + extra_primitive_overestimation_size_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-extraPrimitiveOverestimationSizeGranularity) + ", + ty: f32, + ffi_name: extra_primitive_overestimation_size_granularity, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + filter_minmax_image_component_mapping => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-filterMinmaxImageComponentMapping) + ", + ty: bool, + ffi_name: filter_minmax_image_component_mapping, + ffi_members: [properties_vulkan12, properties_sampler_filter_minmax], + required: false, + }, + filter_minmax_single_component_formats => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-filterMinmaxSingleComponentFormats) + ", + ty: bool, + ffi_name: filter_minmax_single_component_formats, + ffi_members: [properties_vulkan12, properties_sampler_filter_minmax], + required: false, + }, + fragment_density_invocations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html#limits-fragmentDensityInvocations) + ", + ty: bool, + ffi_name: fragment_density_invocations, + ffi_members: [properties_fragment_density_map_ext], + required: false, + }, + fragment_shading_rate_non_trivial_combiner_ops => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateNonTrivialCombinerOps) + ", + ty: bool, + ffi_name: fragment_shading_rate_non_trivial_combiner_ops, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_strict_multiply_combiner => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateStrictMultiplyCombiner) + ", + ty: bool, + ffi_name: fragment_shading_rate_strict_multiply_combiner, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_with_conservative_rasterization => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateWithConservativeRasterization) + ", + ty: bool, + ffi_name: fragment_shading_rate_with_conservative_rasterization, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_with_custom_sample_locations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateWithCustomSampleLocations) + ", + ty: bool, + ffi_name: fragment_shading_rate_with_custom_sample_locations, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_with_fragment_shader_interlock => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateWithFragmentShaderInterlock) + ", + ty: bool, + ffi_name: fragment_shading_rate_with_fragment_shader_interlock, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_with_sample_mask => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateWithSampleMask) + ", + ty: bool, + ffi_name: fragment_shading_rate_with_sample_mask, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_with_shader_depth_stencil_writes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateWithShaderDepthStencilWrites) + ", + ty: bool, + ffi_name: fragment_shading_rate_with_shader_depth_stencil_writes, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + fragment_shading_rate_with_shader_sample_mask => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-fragmentShadingRateWithShaderSampleMask) + ", + ty: bool, + ffi_name: fragment_shading_rate_with_shader_sample_mask, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + framebuffer_color_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-framebufferColorSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: framebuffer_color_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + framebuffer_depth_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-framebufferDepthSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: framebuffer_depth_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + framebuffer_integer_color_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-framebufferIntegerColorSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: framebuffer_integer_color_sample_counts, + ffi_members: [properties_vulkan12], + required: false, + }, + framebuffer_no_attachments_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-framebufferNoAttachmentsSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: framebuffer_no_attachments_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + framebuffer_stencil_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-framebufferStencilSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: framebuffer_stencil_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + fully_covered_fragment_shader_input_variable => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-fullyCoveredFragmentShaderInputVariable) + ", + ty: bool, + ffi_name: fully_covered_fragment_shader_input_variable, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + has_primary => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html#limits-hasPrimary) + ", + ty: bool, + ffi_name: has_primary, + ffi_members: [properties_drm_ext], + required: false, + }, + has_render => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html#limits-hasRender) + ", + ty: bool, + ffi_name: has_render, + ffi_members: [properties_drm_ext], + required: false, + }, + independent_resolve => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-independentResolve) + ", + ty: bool, + ffi_name: independent_resolve, + ffi_members: [properties_vulkan12, properties_depth_stencil_resolve], + required: false, + }, + independent_resolve_none => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-independentResolveNone) + ", + ty: bool, + ffi_name: independent_resolve_none, + ffi_members: [properties_vulkan12, properties_depth_stencil_resolve], + required: false, + }, + layered_shading_rate_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-layeredShadingRateAttachments) + ", + ty: bool, + ffi_name: layered_shading_rate_attachments, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + line_sub_pixel_precision_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html#limits-lineSubPixelPrecisionBits) + ", + ty: u32, + ffi_name: line_sub_pixel_precision_bits, + ffi_members: [properties_line_rasterization_ext], + required: false, + }, + line_width_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-lineWidthGranularity) + ", + ty: f32, + ffi_name: line_width_granularity, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + line_width_range => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-lineWidthRange) + ", + ty: [f32; 2], + ffi_name: line_width_range, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_bound_descriptor_sets => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxBoundDescriptorSets) + ", + ty: u32, + ffi_name: max_bound_descriptor_sets, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_clip_distances => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxClipDistances) + ", + ty: u32, + ffi_name: max_clip_distances, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_color_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxColorAttachments) + ", + ty: u32, + ffi_name: max_color_attachments, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_combined_clip_and_cull_distances => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxCombinedClipAndCullDistances) + ", + ty: u32, + ffi_name: max_combined_clip_and_cull_distances, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_compute_shared_memory_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxComputeSharedMemorySize) + ", + ty: u32, + ffi_name: max_compute_shared_memory_size, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_compute_work_group_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxComputeWorkGroupCount) + ", + ty: [u32; 3], + ffi_name: max_compute_work_group_count, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_compute_work_group_invocations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxComputeWorkGroupInvocations) + ", + ty: u32, + ffi_name: max_compute_work_group_invocations, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_compute_work_group_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxComputeWorkGroupSize) + ", + ty: [u32; 3], + ffi_name: max_compute_work_group_size, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_compute_workgroup_subgroups => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html#limits-maxComputeWorkgroupSubgroups) + ", + ty: u32, + ffi_name: max_compute_workgroup_subgroups, + ffi_members: [properties_subgroup_size_control_ext], + required: false, + }, + max_cull_distances => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxCullDistances) + ", + ty: u32, + ffi_name: max_cull_distances, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_custom_border_color_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html#limits-maxCustomBorderColorSamplers) + ", + ty: u32, + ffi_name: max_custom_border_color_samplers, + ffi_members: [properties_custom_border_color_ext], + required: false, + }, + max_descriptor_set_acceleration_structures => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxDescriptorSetAccelerationStructures) + ", + ty: u32, + ffi_name: max_descriptor_set_acceleration_structures, + ffi_members: [properties_acceleration_structure_khr, properties_ray_tracing_nv], + required: false, + }, + max_descriptor_set_inline_uniform_blocks => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html#limits-maxDescriptorSetInlineUniformBlocks) + ", + ty: u32, + ffi_name: max_descriptor_set_inline_uniform_blocks, + ffi_members: [properties_inline_uniform_block_ext], + required: false, + }, + max_descriptor_set_input_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetInputAttachments) + ", + ty: u32, + ffi_name: max_descriptor_set_input_attachments, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_sampled_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetSampledImages) + ", + ty: u32, + ffi_name: max_descriptor_set_sampled_images, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetSamplers) + ", + ty: u32, + ffi_name: max_descriptor_set_samplers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_storage_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetStorageBuffers) + ", + ty: u32, + ffi_name: max_descriptor_set_storage_buffers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_storage_buffers_dynamic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetStorageBuffersDynamic) + ", + ty: u32, + ffi_name: max_descriptor_set_storage_buffers_dynamic, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_storage_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetStorageImages) + ", + ty: u32, + ffi_name: max_descriptor_set_storage_images, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_subsampled_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html#limits-maxDescriptorSetSubsampledSamplers) + ", + ty: u32, + ffi_name: max_descriptor_set_subsampled_samplers, + ffi_members: [properties_fragment_density_map2_ext], + required: false, + }, + max_descriptor_set_uniform_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetUniformBuffers) + ", + ty: u32, + ffi_name: max_descriptor_set_uniform_buffers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_uniform_buffers_dynamic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDescriptorSetUniformBuffersDynamic) + ", + ty: u32, + ffi_name: max_descriptor_set_uniform_buffers_dynamic, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_descriptor_set_update_after_bind_acceleration_structures => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxDescriptorSetUpdateAfterBindAccelerationStructures) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_acceleration_structures, + ffi_members: [properties_acceleration_structure_khr], + required: false, + }, + max_descriptor_set_update_after_bind_inline_uniform_blocks => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html#limits-maxDescriptorSetUpdateAfterBindInlineUniformBlocks) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_inline_uniform_blocks, + ffi_members: [properties_inline_uniform_block_ext], + required: false, + }, + max_descriptor_set_update_after_bind_input_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindInputAttachments) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_input_attachments, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_sampled_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindSampledImages) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_sampled_images, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindSamplers) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_samplers, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_storage_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindStorageBuffers) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_storage_buffers, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_storage_buffers_dynamic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindStorageBuffersDynamic) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_storage_buffers_dynamic, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_storage_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindStorageImages) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_storage_images, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_uniform_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindUniformBuffers) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_uniform_buffers, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxDescriptorSetUpdateAfterBindUniformBuffersDynamic) + ", + ty: u32, + ffi_name: max_descriptor_set_update_after_bind_uniform_buffers_dynamic, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_discard_rectangles => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html#limits-maxDiscardRectangles) + ", + ty: u32, + ffi_name: max_discard_rectangles, + ffi_members: [properties_discard_rectangle_ext], + required: false, + }, + max_draw_indexed_index_value => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDrawIndexedIndexValue) + ", + ty: u32, + ffi_name: max_draw_indexed_index_value, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_draw_indirect_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxDrawIndirectCount) + ", + ty: u32, + ffi_name: max_draw_indirect_count, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_draw_mesh_tasks_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxDrawMeshTasksCount) + ", + ty: u32, + ffi_name: max_draw_mesh_tasks_count, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_extra_primitive_overestimation_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-maxExtraPrimitiveOverestimationSize) + ", + ty: f32, + ffi_name: max_extra_primitive_overestimation_size, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + max_fragment_combined_output_resources => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFragmentCombinedOutputResources) + ", + ty: u32, + ffi_name: max_fragment_combined_output_resources, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_fragment_density_texel_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html#limits-maxFragmentDensityTexelSize) + ", + ty: [u32; 2], + ffi_name: max_fragment_density_texel_size, + ffi_members: [properties_fragment_density_map_ext], + required: false, + }, + max_fragment_dual_src_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFragmentDualSrcAttachments) + ", + ty: u32, + ffi_name: max_fragment_dual_src_attachments, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_fragment_input_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFragmentInputComponents) + ", + ty: u32, + ffi_name: max_fragment_input_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_fragment_output_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFragmentOutputAttachments) + ", + ty: u32, + ffi_name: max_fragment_output_attachments, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_fragment_shading_rate_attachment_texel_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-maxFragmentShadingRateAttachmentTexelSize) + ", + ty: [u32; 2], + ffi_name: max_fragment_shading_rate_attachment_texel_size, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + max_fragment_shading_rate_attachment_texel_size_aspect_ratio => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-maxFragmentShadingRateAttachmentTexelSizeAspectRatio) + ", + ty: u32, + ffi_name: max_fragment_shading_rate_attachment_texel_size_aspect_ratio, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + max_fragment_shading_rate_coverage_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-maxFragmentShadingRateCoverageSamples) + ", + ty: u32, + ffi_name: max_fragment_shading_rate_coverage_samples, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + max_fragment_shading_rate_invocation_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html#limits-maxFragmentShadingRateInvocationCount) + ", + ty: crate::image::SampleCount, + ffi_name: max_fragment_shading_rate_invocation_count, + ffi_members: [properties_fragment_shading_rate_enums_nv], + required: false, + }, + max_fragment_shading_rate_rasterization_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-maxFragmentShadingRateRasterizationSamples) + ", + ty: crate::image::SampleCount, + ffi_name: max_fragment_shading_rate_rasterization_samples, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + max_fragment_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-maxFragmentSize) + ", + ty: [u32; 2], + ffi_name: max_fragment_size, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + max_fragment_size_aspect_ratio => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-maxFragmentSizeAspectRatio) + ", + ty: u32, + ffi_name: max_fragment_size_aspect_ratio, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + max_framebuffer_height => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFramebufferHeight) + ", + ty: u32, + ffi_name: max_framebuffer_height, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_framebuffer_layers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFramebufferLayers) + ", + ty: u32, + ffi_name: max_framebuffer_layers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_framebuffer_width => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxFramebufferWidth) + ", + ty: u32, + ffi_name: max_framebuffer_width, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_geometry_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxGeometryCount) + ", + ty: u64, + ffi_name: max_geometry_count, + ffi_members: [properties_acceleration_structure_khr, properties_ray_tracing_nv], + required: false, + }, + max_geometry_input_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxGeometryInputComponents) + ", + ty: u32, + ffi_name: max_geometry_input_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_geometry_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxGeometryOutputComponents) + ", + ty: u32, + ffi_name: max_geometry_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_geometry_output_vertices => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxGeometryOutputVertices) + ", + ty: u32, + ffi_name: max_geometry_output_vertices, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_geometry_shader_invocations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxGeometryShaderInvocations) + ", + ty: u32, + ffi_name: max_geometry_shader_invocations, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_geometry_total_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxGeometryTotalOutputComponents) + ", + ty: u32, + ffi_name: max_geometry_total_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_graphics_shader_group_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-maxGraphicsShaderGroupCount) + ", + ty: u32, + ffi_name: max_graphics_shader_group_count, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + max_image_array_layers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxImageArrayLayers) + ", + ty: u32, + ffi_name: max_image_array_layers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_image_dimension1_d => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxImageDimension1D) + ", + ty: u32, + ffi_name: max_image_dimension1_d, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_image_dimension2_d => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxImageDimension2D) + ", + ty: u32, + ffi_name: max_image_dimension2_d, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_image_dimension3_d => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxImageDimension3D) + ", + ty: u32, + ffi_name: max_image_dimension3_d, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_image_dimension_cube => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxImageDimensionCube) + ", + ty: u32, + ffi_name: max_image_dimension_cube, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_indirect_commands_stream_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-maxIndirectCommandsStreamCount) + ", + ty: u32, + ffi_name: max_indirect_commands_stream_count, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + max_indirect_commands_stream_stride => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-maxIndirectCommandsStreamStride) + ", + ty: u32, + ffi_name: max_indirect_commands_stream_stride, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + max_indirect_commands_token_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-maxIndirectCommandsTokenCount) + ", + ty: u32, + ffi_name: max_indirect_commands_token_count, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + max_indirect_commands_token_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-maxIndirectCommandsTokenOffset) + ", + ty: u32, + ffi_name: max_indirect_commands_token_offset, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + max_indirect_sequence_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-maxIndirectSequenceCount) + ", + ty: u32, + ffi_name: max_indirect_sequence_count, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + max_inline_uniform_block_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html#limits-maxInlineUniformBlockSize) + ", + ty: u32, + ffi_name: max_inline_uniform_block_size, + ffi_members: [properties_inline_uniform_block_ext], + required: false, + }, + max_instance_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxInstanceCount) + ", + ty: u64, + ffi_name: max_instance_count, + ffi_members: [properties_acceleration_structure_khr, properties_ray_tracing_nv], + required: false, + }, + max_interpolation_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxInterpolationOffset) + ", + ty: f32, + ffi_name: max_interpolation_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_memory_allocation_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxMemoryAllocationCount) + ", + ty: u32, + ffi_name: max_memory_allocation_count, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_memory_allocation_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-maxMemoryAllocationSize) + ", + ty: crate::DeviceSize, + ffi_name: max_memory_allocation_size, + ffi_members: [properties_vulkan11, properties_maintenance3], + required: false, + }, + max_mesh_multiview_view_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxMeshMultiviewViewCount) + ", + ty: u32, + ffi_name: max_mesh_multiview_view_count, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_mesh_output_primitives => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxMeshOutputPrimitives) + ", + ty: u32, + ffi_name: max_mesh_output_primitives, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_mesh_output_vertices => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxMeshOutputVertices) + ", + ty: u32, + ffi_name: max_mesh_output_vertices, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_mesh_total_memory_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxMeshTotalMemorySize) + ", + ty: u32, + ffi_name: max_mesh_total_memory_size, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_mesh_work_group_invocations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxMeshWorkGroupInvocations) + ", + ty: u32, + ffi_name: max_mesh_work_group_invocations, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_mesh_work_group_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxMeshWorkGroupSize) + ", + ty: [u32; 3], + ffi_name: max_mesh_work_group_size, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_multi_draw_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html#limits-maxMultiDrawCount) + ", + ty: u32, + ffi_name: max_multi_draw_count, + ffi_members: [properties_multi_draw_ext], + required: false, + }, + max_multiview_instance_index => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-maxMultiviewInstanceIndex) + ", + ty: u32, + ffi_name: max_multiview_instance_index, + ffi_members: [properties_vulkan11, properties_multiview], + required: false, + }, + max_multiview_view_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-maxMultiviewViewCount) + ", + ty: u32, + ffi_name: max_multiview_view_count, + ffi_members: [properties_vulkan11, properties_multiview], + required: false, + }, + max_per_set_descriptors => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-maxPerSetDescriptors) + ", + ty: u32, + ffi_name: max_per_set_descriptors, + ffi_members: [properties_vulkan11, properties_maintenance3], + required: false, + }, + max_per_stage_descriptor_acceleration_structures => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxPerStageDescriptorAccelerationStructures) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_acceleration_structures, + ffi_members: [properties_acceleration_structure_khr], + required: false, + }, + max_per_stage_descriptor_inline_uniform_blocks => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html#limits-maxPerStageDescriptorInlineUniformBlocks) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_inline_uniform_blocks, + ffi_members: [properties_inline_uniform_block_ext], + required: false, + }, + max_per_stage_descriptor_input_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageDescriptorInputAttachments) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_input_attachments, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_descriptor_sampled_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageDescriptorSampledImages) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_sampled_images, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_descriptor_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageDescriptorSamplers) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_samplers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_descriptor_storage_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageDescriptorStorageBuffers) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_storage_buffers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_descriptor_storage_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageDescriptorStorageImages) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_storage_images, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_descriptor_uniform_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageDescriptorUniformBuffers) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_uniform_buffers, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_descriptor_update_after_bind_acceleration_structures => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxPerStageDescriptorUpdateAfterBindAccelerationStructures) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_acceleration_structures, + ffi_members: [properties_acceleration_structure_khr], + required: false, + }, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html#limits-maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_inline_uniform_blocks, + ffi_members: [properties_inline_uniform_block_ext], + required: false, + }, + max_per_stage_descriptor_update_after_bind_input_attachments => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageDescriptorUpdateAfterBindInputAttachments) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_input_attachments, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_per_stage_descriptor_update_after_bind_sampled_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageDescriptorUpdateAfterBindSampledImages) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_sampled_images, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_per_stage_descriptor_update_after_bind_samplers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageDescriptorUpdateAfterBindSamplers) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_samplers, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_per_stage_descriptor_update_after_bind_storage_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageDescriptorUpdateAfterBindStorageBuffers) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_storage_buffers, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_per_stage_descriptor_update_after_bind_storage_images => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageDescriptorUpdateAfterBindStorageImages) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_storage_images, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_per_stage_descriptor_update_after_bind_uniform_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageDescriptorUpdateAfterBindUniformBuffers) + ", + ty: u32, + ffi_name: max_per_stage_descriptor_update_after_bind_uniform_buffers, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_per_stage_resources => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPerStageResources) + ", + ty: u32, + ffi_name: max_per_stage_resources, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_per_stage_update_after_bind_resources => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxPerStageUpdateAfterBindResources) + ", + ty: u32, + ffi_name: max_per_stage_update_after_bind_resources, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_primitive_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-maxPrimitiveCount) + ", + ty: u64, + ffi_name: max_primitive_count, + ffi_members: [properties_acceleration_structure_khr], + required: false, + }, + max_push_constants_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxPushConstantsSize) + ", + ty: u32, + ffi_name: max_push_constants_size, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_push_descriptors => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html#limits-maxPushDescriptors) + ", + ty: u32, + ffi_name: max_push_descriptors, + ffi_members: [properties_push_descriptor_khr], + required: false, + }, + max_ray_dispatch_invocation_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-maxRayDispatchInvocationCount) + ", + ty: u32, + ffi_name: max_ray_dispatch_invocation_count, + ffi_members: [properties_ray_tracing_pipeline_khr], + required: false, + }, + max_ray_hit_attribute_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-maxRayHitAttributeSize) + ", + ty: u32, + ffi_name: max_ray_hit_attribute_size, + ffi_members: [properties_ray_tracing_pipeline_khr], + required: false, + }, + max_ray_recursion_depth => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-maxRayRecursionDepth) + ", + ty: u32, + ffi_name: max_ray_recursion_depth, + ffi_members: [properties_ray_tracing_pipeline_khr], + required: false, + }, + max_recursion_depth => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html#limits-maxRecursionDepth) + ", + ty: u32, + ffi_name: max_recursion_depth, + ffi_members: [properties_ray_tracing_nv], + required: false, + }, + max_sample_location_grid_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html#limits-maxSampleLocationGridSize) + ", + ty: [u32; 2], + ffi_name: max_sample_location_grid_size, + ffi_members: [properties_sample_locations_ext], + required: false, + }, + max_sample_mask_words => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxSampleMaskWords) + ", + ty: u32, + ffi_name: max_sample_mask_words, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_sampler_allocation_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxSamplerAllocationCount) + ", + ty: u32, + ffi_name: max_sampler_allocation_count, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_sampler_anisotropy => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxSamplerAnisotropy) + ", + ty: f32, + ffi_name: max_sampler_anisotropy, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_sampler_lod_bias => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxSamplerLodBias) + ", + ty: f32, + ffi_name: max_sampler_lod_bias, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_sgpr_allocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-maxSgprAllocation) + ", + ty: u32, + ffi_name: max_sgpr_allocation, + ffi_members: [properties_shader_core_amd], + required: false, + }, + max_shader_group_stride => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-maxShaderGroupStride) + ", + ty: u32, + ffi_name: max_shader_group_stride, + ffi_members: [properties_ray_tracing_pipeline_khr, properties_ray_tracing_nv], + required: false, + }, + max_storage_buffer_range => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxStorageBufferRange) + ", + ty: u32, + ffi_name: max_storage_buffer_range, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_subgroup_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html#limits-maxSubgroupSize) + ", + ty: u32, + ffi_name: max_subgroup_size, + ffi_members: [properties_subgroup_size_control_ext], + required: false, + }, + max_subpass_shading_workgroup_size_aspect_ratio => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html#limits-maxSubpassShadingWorkgroupSizeAspectRatio) + ", + ty: u32, + ffi_name: max_subpass_shading_workgroup_size_aspect_ratio, + ffi_members: [properties_subpass_shading_huawei], + required: false, + }, + max_subsampled_array_layers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html#limits-maxSubsampledArrayLayers) + ", + ty: u32, + ffi_name: max_subsampled_array_layers, + ffi_members: [properties_fragment_density_map2_ext], + required: false, + }, + max_task_output_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxTaskOutputCount) + ", + ty: u32, + ffi_name: max_task_output_count, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_task_total_memory_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxTaskTotalMemorySize) + ", + ty: u32, + ffi_name: max_task_total_memory_size, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_task_work_group_invocations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxTaskWorkGroupInvocations) + ", + ty: u32, + ffi_name: max_task_work_group_invocations, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_task_work_group_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-maxTaskWorkGroupSize) + ", + ty: [u32; 3], + ffi_name: max_task_work_group_size, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + max_tessellation_control_per_patch_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationControlPerPatchOutputComponents) + ", + ty: u32, + ffi_name: max_tessellation_control_per_patch_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_control_per_vertex_input_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationControlPerVertexInputComponents) + ", + ty: u32, + ffi_name: max_tessellation_control_per_vertex_input_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_control_per_vertex_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationControlPerVertexOutputComponents) + ", + ty: u32, + ffi_name: max_tessellation_control_per_vertex_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_control_total_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationControlTotalOutputComponents) + ", + ty: u32, + ffi_name: max_tessellation_control_total_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_evaluation_input_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationEvaluationInputComponents) + ", + ty: u32, + ffi_name: max_tessellation_evaluation_input_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_evaluation_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationEvaluationOutputComponents) + ", + ty: u32, + ffi_name: max_tessellation_evaluation_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_generation_level => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationGenerationLevel) + ", + ty: u32, + ffi_name: max_tessellation_generation_level, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_tessellation_patch_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTessellationPatchSize) + ", + ty: u32, + ffi_name: max_tessellation_patch_size, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_texel_buffer_elements => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTexelBufferElements) + ", + ty: u32, + ffi_name: max_texel_buffer_elements, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_texel_gather_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTexelGatherOffset) + ", + ty: u32, + ffi_name: max_texel_gather_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_texel_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxTexelOffset) + ", + ty: u32, + ffi_name: max_texel_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_timeline_semaphore_value_difference => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxTimelineSemaphoreValueDifference) + ", + ty: u64, + ffi_name: max_timeline_semaphore_value_difference, + ffi_members: [properties_vulkan12, properties_timeline_semaphore], + required: false, + }, + max_transform_feedback_buffer_data_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-maxTransformFeedbackBufferDataSize) + ", + ty: u32, + ffi_name: max_transform_feedback_buffer_data_size, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + max_transform_feedback_buffer_data_stride => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-maxTransformFeedbackBufferDataStride) + ", + ty: u32, + ffi_name: max_transform_feedback_buffer_data_stride, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + max_transform_feedback_buffer_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-maxTransformFeedbackBufferSize) + ", + ty: crate::DeviceSize, + ffi_name: max_transform_feedback_buffer_size, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + max_transform_feedback_buffers => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-maxTransformFeedbackBuffers) + ", + ty: u32, + ffi_name: max_transform_feedback_buffers, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + max_transform_feedback_stream_data_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-maxTransformFeedbackStreamDataSize) + ", + ty: u32, + ffi_name: max_transform_feedback_stream_data_size, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + max_transform_feedback_streams => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-maxTransformFeedbackStreams) + ", + ty: u32, + ffi_name: max_transform_feedback_streams, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + max_triangle_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html#limits-maxTriangleCount) + ", + ty: u64, + ffi_name: max_triangle_count, + ffi_members: [properties_ray_tracing_nv], + required: false, + }, + max_uniform_buffer_range => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxUniformBufferRange) + ", + ty: u32, + ffi_name: max_uniform_buffer_range, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_update_after_bind_descriptors_in_all_pools => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-maxUpdateAfterBindDescriptorsInAllPools) + ", + ty: u32, + ffi_name: max_update_after_bind_descriptors_in_all_pools, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + max_vertex_attrib_divisor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html#limits-maxVertexAttribDivisor) + ", + ty: u32, + ffi_name: max_vertex_attrib_divisor, + ffi_members: [properties_vertex_attribute_divisor_ext], + required: false, + }, + max_vertex_input_attribute_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxVertexInputAttributeOffset) + ", + ty: u32, + ffi_name: max_vertex_input_attribute_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_vertex_input_attributes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxVertexInputAttributes) + ", + ty: u32, + ffi_name: max_vertex_input_attributes, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_vertex_input_binding_stride => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxVertexInputBindingStride) + ", + ty: u32, + ffi_name: max_vertex_input_binding_stride, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_vertex_input_bindings => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxVertexInputBindings) + ", + ty: u32, + ffi_name: max_vertex_input_bindings, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_vertex_output_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxVertexOutputComponents) + ", + ty: u32, + ffi_name: max_vertex_output_components, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_vgpr_allocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-maxVgprAllocation) + ", + ty: u32, + ffi_name: max_vgpr_allocation, + ffi_members: [properties_shader_core_amd], + required: false, + }, + max_viewport_dimensions => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxViewportDimensions) + ", + ty: [u32; 2], + ffi_name: max_viewport_dimensions, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + max_viewports => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-maxViewports) + ", + ty: u32, + ffi_name: max_viewports, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + mesh_output_per_primitive_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-meshOutputPerPrimitiveGranularity) + ", + ty: u32, + ffi_name: mesh_output_per_primitive_granularity, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + mesh_output_per_vertex_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html#limits-meshOutputPerVertexGranularity) + ", + ty: u32, + ffi_name: mesh_output_per_vertex_granularity, + ffi_members: [properties_mesh_shader_nv], + required: false, + }, + min_acceleration_structure_scratch_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html#limits-minAccelerationStructureScratchOffsetAlignment) + ", + ty: u32, + ffi_name: min_acceleration_structure_scratch_offset_alignment, + ffi_members: [properties_acceleration_structure_khr], + required: false, + }, + min_fragment_density_texel_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html#limits-minFragmentDensityTexelSize) + ", + ty: [u32; 2], + ffi_name: min_fragment_density_texel_size, + ffi_members: [properties_fragment_density_map_ext], + required: false, + }, + min_fragment_shading_rate_attachment_texel_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-minFragmentShadingRateAttachmentTexelSize) + ", + ty: [u32; 2], + ffi_name: min_fragment_shading_rate_attachment_texel_size, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + min_imported_host_pointer_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html#limits-minImportedHostPointerAlignment) + ", + ty: crate::DeviceSize, + ffi_name: min_imported_host_pointer_alignment, + ffi_members: [properties_external_memory_host_ext], + required: false, + }, + min_indirect_commands_buffer_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-minIndirectCommandsBufferOffsetAlignment) + ", + ty: u32, + ffi_name: min_indirect_commands_buffer_offset_alignment, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + min_interpolation_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minInterpolationOffset) + ", + ty: f32, + ffi_name: min_interpolation_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_memory_map_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minMemoryMapAlignment) + ", + ty: usize, + ffi_name: min_memory_map_alignment, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_sequences_count_buffer_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-minSequencesCountBufferOffsetAlignment) + ", + ty: u32, + ffi_name: min_sequences_count_buffer_offset_alignment, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + min_sequences_index_buffer_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html#limits-minSequencesIndexBufferOffsetAlignment) + ", + ty: u32, + ffi_name: min_sequences_index_buffer_offset_alignment, + ffi_members: [properties_device_generated_commands_nv], + required: false, + }, + min_sgpr_allocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-minSgprAllocation) + ", + ty: u32, + ffi_name: min_sgpr_allocation, + ffi_members: [properties_shader_core_amd], + required: false, + }, + min_storage_buffer_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minStorageBufferOffsetAlignment) + ", + ty: crate::DeviceSize, + ffi_name: min_storage_buffer_offset_alignment, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_subgroup_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html#limits-minSubgroupSize) + ", + ty: u32, + ffi_name: min_subgroup_size, + ffi_members: [properties_subgroup_size_control_ext], + required: false, + }, + min_texel_buffer_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minTexelBufferOffsetAlignment) + ", + ty: crate::DeviceSize, + ffi_name: min_texel_buffer_offset_alignment, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_texel_gather_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minTexelGatherOffset) + ", + ty: i32, + ffi_name: min_texel_gather_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_texel_offset => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minTexelOffset) + ", + ty: i32, + ffi_name: min_texel_offset, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_uniform_buffer_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-minUniformBufferOffsetAlignment) + ", + ty: crate::DeviceSize, + ffi_name: min_uniform_buffer_offset_alignment, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + min_vertex_input_binding_stride_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html#limits-minVertexInputBindingStrideAlignment) + ", + ty: u32, + ffi_name: min_vertex_input_binding_stride_alignment, + ffi_members: [properties_portability_subset_khr], + required: false, + }, + min_vgpr_allocation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-minVgprAllocation) + ", + ty: u32, + ffi_name: min_vgpr_allocation, + ffi_members: [properties_shader_core_amd], + required: false, + }, + mipmap_precision_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-mipmapPrecisionBits) + ", + ty: u32, + ffi_name: mipmap_precision_bits, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + non_coherent_atom_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-nonCoherentAtomSize) + ", + ty: crate::DeviceSize, + ffi_name: non_coherent_atom_size, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + optimal_buffer_copy_offset_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-optimalBufferCopyOffsetAlignment) + ", + ty: crate::DeviceSize, + ffi_name: optimal_buffer_copy_offset_alignment, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + optimal_buffer_copy_row_pitch_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-optimalBufferCopyRowPitchAlignment) + ", + ty: crate::DeviceSize, + ffi_name: optimal_buffer_copy_row_pitch_alignment, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + pci_bus => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html#limits-pciBus) + ", + ty: u32, + ffi_name: pci_bus, + ffi_members: [properties_pci_bus_info_ext], + required: false, + }, + pci_device => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html#limits-pciDevice) + ", + ty: u32, + ffi_name: pci_device, + ffi_members: [properties_pci_bus_info_ext], + required: false, + }, + pci_domain => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html#limits-pciDomain) + ", + ty: u32, + ffi_name: pci_domain, + ffi_members: [properties_pci_bus_info_ext], + required: false, + }, + pci_function => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html#limits-pciFunction) + ", + ty: u32, + ffi_name: pci_function, + ffi_members: [properties_pci_bus_info_ext], + required: false, + }, + per_view_position_all_components => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html#limits-perViewPositionAllComponents) + ", + ty: bool, + ffi_name: per_view_position_all_components, + ffi_members: [properties_multiview_per_view_attributes_nvx], + required: false, + }, + pipeline_cache_uuid => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-pipelineCacheUUID) + ", + ty: [u8; 16], + ffi_name: pipeline_cache_uuid, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + point_clipping_behavior => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-pointClippingBehavior) + ", + ty: crate::device::physical::PointClippingBehavior, + ffi_name: point_clipping_behavior, + ffi_members: [properties_vulkan11, properties_point_clipping], + required: false, + }, + point_size_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-pointSizeGranularity) + ", + ty: f32, + ffi_name: point_size_granularity, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + point_size_range => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-pointSizeRange) + ", + ty: [f32; 2], + ffi_name: point_size_range, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + primary_major => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html#limits-primaryMajor) + ", + ty: i64, + ffi_name: primary_major, + ffi_members: [properties_drm_ext], + required: false, + }, + primary_minor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html#limits-primaryMinor) + ", + ty: i64, + ffi_name: primary_minor, + ffi_members: [properties_drm_ext], + required: false, + }, + primitive_fragment_shading_rate_with_multiple_viewports => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html#limits-primitiveFragmentShadingRateWithMultipleViewports) + ", + ty: bool, + ffi_name: primitive_fragment_shading_rate_with_multiple_viewports, + ffi_members: [properties_fragment_shading_rate_khr], + required: false, + }, + primitive_overestimation_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-primitiveOverestimationSize) + ", + ty: f32, + ffi_name: primitive_overestimation_size, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + primitive_underestimation => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html#limits-primitiveUnderestimation) + ", + ty: bool, + ffi_name: primitive_underestimation, + ffi_members: [properties_conservative_rasterization_ext], + required: false, + }, + protected_no_fault => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-protectedNoFault) + ", + ty: bool, + ffi_name: protected_no_fault, + ffi_members: [properties_vulkan11, properties_protected_memory], + required: false, + }, + provoking_vertex_mode_per_pipeline => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html#limits-provokingVertexModePerPipeline) + ", + ty: bool, + ffi_name: provoking_vertex_mode_per_pipeline, + ffi_members: [properties_provoking_vertex_ext], + required: false, + }, + quad_divergent_implicit_lod => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-quadDivergentImplicitLod) + ", + ty: bool, + ffi_name: quad_divergent_implicit_lod, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + quad_operations_in_all_stages => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html#limits-quadOperationsInAllStages) + ", + ty: bool, + ffi_name: quad_operations_in_all_stages, + ffi_members: [properties_subgroup], + required: false, + }, + render_major => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html#limits-renderMajor) + ", + ty: i64, + ffi_name: render_major, + ffi_members: [properties_drm_ext], + required: false, + }, + render_minor => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html#limits-renderMinor) + ", + ty: i64, + ffi_name: render_minor, + ffi_members: [properties_drm_ext], + required: false, + }, + required_subgroup_size_stages => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html#limits-requiredSubgroupSizeStages) + ", + ty: crate::pipeline::shader::ShaderStages, + ffi_name: required_subgroup_size_stages, + ffi_members: [properties_subgroup_size_control_ext], + required: false, + }, + residency_aligned_mip_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html#limits-residencyAlignedMipSize) + ", + ty: bool, + ffi_name: residency_aligned_mip_size, + ffi_members: [properties_vulkan10.properties.sparse_properties], + required: true, + }, + residency_non_resident_strict => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html#limits-residencyNonResidentStrict) + ", + ty: bool, + ffi_name: residency_non_resident_strict, + ffi_members: [properties_vulkan10.properties.sparse_properties], + required: true, + }, + residency_standard2_d_block_shape => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html#limits-residencyStandard2DBlockShape) + ", + ty: bool, + ffi_name: residency_standard2_d_block_shape, + ffi_members: [properties_vulkan10.properties.sparse_properties], + required: true, + }, + residency_standard2_d_multisample_block_shape => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html#limits-residencyStandard2DMultisampleBlockShape) + ", + ty: bool, + ffi_name: residency_standard2_d_multisample_block_shape, + ffi_members: [properties_vulkan10.properties.sparse_properties], + required: true, + }, + residency_standard3_d_block_shape => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html#limits-residencyStandard3DBlockShape) + ", + ty: bool, + ffi_name: residency_standard3_d_block_shape, + ffi_members: [properties_vulkan10.properties.sparse_properties], + required: true, + }, + robust_buffer_access_update_after_bind => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-robustBufferAccessUpdateAfterBind) + ", + ty: bool, + ffi_name: robust_buffer_access_update_after_bind, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + robust_storage_buffer_access_size_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html#limits-robustStorageBufferAccessSizeAlignment) + ", + ty: crate::DeviceSize, + ffi_name: robust_storage_buffer_access_size_alignment, + ffi_members: [properties_robustness2_ext], + required: false, + }, + robust_uniform_buffer_access_size_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html#limits-robustUniformBufferAccessSizeAlignment) + ", + ty: crate::DeviceSize, + ffi_name: robust_uniform_buffer_access_size_alignment, + ffi_members: [properties_robustness2_ext], + required: false, + }, + rounding_mode_independence => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-roundingModeIndependence) + ", + ty: crate::device::physical::ShaderFloatControlsIndependence, + ffi_name: rounding_mode_independence, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + sample_location_coordinate_range => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html#limits-sampleLocationCoordinateRange) + ", + ty: [f32; 2], + ffi_name: sample_location_coordinate_range, + ffi_members: [properties_sample_locations_ext], + required: false, + }, + sample_location_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html#limits-sampleLocationSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: sample_location_sample_counts, + ffi_members: [properties_sample_locations_ext], + required: false, + }, + sample_location_sub_pixel_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html#limits-sampleLocationSubPixelBits) + ", + ty: u32, + ffi_name: sample_location_sub_pixel_bits, + ffi_members: [properties_sample_locations_ext], + required: false, + }, + sampled_image_color_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-sampledImageColorSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: sampled_image_color_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sampled_image_depth_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-sampledImageDepthSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: sampled_image_depth_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sampled_image_integer_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-sampledImageIntegerSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: sampled_image_integer_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sampled_image_stencil_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-sampledImageStencilSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: sampled_image_stencil_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sgpr_allocation_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-sgprAllocationGranularity) + ", + ty: u32, + ffi_name: sgpr_allocation_granularity, + ffi_members: [properties_shader_core_amd], + required: false, + }, + sgprs_per_simd => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-sgprsPerSimd) + ", + ty: u32, + ffi_name: sgprs_per_simd, + ffi_members: [properties_shader_core_amd], + required: false, + }, + shader_arrays_per_engine_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-shaderArraysPerEngineCount) + ", + ty: u32, + ffi_name: shader_arrays_per_engine_count, + ffi_members: [properties_shader_core_amd], + required: false, + }, + shader_core_features => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html#limits-shaderCoreFeatures) + ", + ty: crate::device::physical::ShaderCoreProperties, + ffi_name: shader_core_features, + ffi_members: [properties_shader_core2_amd], + required: false, + }, + shader_denorm_flush_to_zero_float16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderDenormFlushToZeroFloat16) + ", + ty: bool, + ffi_name: shader_denorm_flush_to_zero_float16, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_denorm_flush_to_zero_float32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderDenormFlushToZeroFloat32) + ", + ty: bool, + ffi_name: shader_denorm_flush_to_zero_float32, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_denorm_flush_to_zero_float64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderDenormFlushToZeroFloat64) + ", + ty: bool, + ffi_name: shader_denorm_flush_to_zero_float64, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_denorm_preserve_float16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderDenormPreserveFloat16) + ", + ty: bool, + ffi_name: shader_denorm_preserve_float16, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_denorm_preserve_float32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderDenormPreserveFloat32) + ", + ty: bool, + ffi_name: shader_denorm_preserve_float32, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_denorm_preserve_float64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderDenormPreserveFloat64) + ", + ty: bool, + ffi_name: shader_denorm_preserve_float64, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_engine_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-shaderEngineCount) + ", + ty: u32, + ffi_name: shader_engine_count, + ffi_members: [properties_shader_core_amd], + required: false, + }, + shader_group_base_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-shaderGroupBaseAlignment) + ", + ty: u32, + ffi_name: shader_group_base_alignment, + ffi_members: [properties_ray_tracing_pipeline_khr, properties_ray_tracing_nv], + required: false, + }, + shader_group_handle_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-shaderGroupHandleAlignment) + ", + ty: u32, + ffi_name: shader_group_handle_alignment, + ffi_members: [properties_ray_tracing_pipeline_khr], + required: false, + }, + shader_group_handle_capture_replay_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-shaderGroupHandleCaptureReplaySize) + ", + ty: u32, + ffi_name: shader_group_handle_capture_replay_size, + ffi_members: [properties_ray_tracing_pipeline_khr], + required: false, + }, + shader_group_handle_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html#limits-shaderGroupHandleSize) + ", + ty: u32, + ffi_name: shader_group_handle_size, + ffi_members: [properties_ray_tracing_pipeline_khr, properties_ray_tracing_nv], + required: false, + }, + shader_input_attachment_array_non_uniform_indexing_native => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderInputAttachmentArrayNonUniformIndexingNative) + ", + ty: bool, + ffi_name: shader_input_attachment_array_non_uniform_indexing_native, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + shader_rounding_mode_rte_float16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderRoundingModeRTEFloat16) + ", + ty: bool, + ffi_name: shader_rounding_mode_rte_float16, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_rounding_mode_rte_float32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderRoundingModeRTEFloat32) + ", + ty: bool, + ffi_name: shader_rounding_mode_rte_float32, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_rounding_mode_rte_float64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderRoundingModeRTEFloat64) + ", + ty: bool, + ffi_name: shader_rounding_mode_rte_float64, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_rounding_mode_rtz_float16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderRoundingModeRTZFloat16) + ", + ty: bool, + ffi_name: shader_rounding_mode_rtz_float16, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_rounding_mode_rtz_float32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderRoundingModeRTZFloat32) + ", + ty: bool, + ffi_name: shader_rounding_mode_rtz_float32, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_rounding_mode_rtz_float64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderRoundingModeRTZFloat64) + ", + ty: bool, + ffi_name: shader_rounding_mode_rtz_float64, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_sampled_image_array_non_uniform_indexing_native => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderSampledImageArrayNonUniformIndexingNative) + ", + ty: bool, + ffi_name: shader_sampled_image_array_non_uniform_indexing_native, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + shader_signed_zero_inf_nan_preserve_float16 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderSignedZeroInfNanPreserveFloat16) + ", + ty: bool, + ffi_name: shader_signed_zero_inf_nan_preserve_float16, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_signed_zero_inf_nan_preserve_float32 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderSignedZeroInfNanPreserveFloat32) + ", + ty: bool, + ffi_name: shader_signed_zero_inf_nan_preserve_float32, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_signed_zero_inf_nan_preserve_float64 => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderSignedZeroInfNanPreserveFloat64) + ", + ty: bool, + ffi_name: shader_signed_zero_inf_nan_preserve_float64, + ffi_members: [properties_vulkan12, properties_float_controls], + required: false, + }, + shader_sm_count => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html#limits-shaderSMCount) + ", + ty: u32, + ffi_name: shader_sm_count, + ffi_members: [properties_shader_sm_builtins_nv], + required: false, + }, + shader_storage_buffer_array_non_uniform_indexing_native => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderStorageBufferArrayNonUniformIndexingNative) + ", + ty: bool, + ffi_name: shader_storage_buffer_array_non_uniform_indexing_native, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + shader_storage_image_array_non_uniform_indexing_native => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderStorageImageArrayNonUniformIndexingNative) + ", + ty: bool, + ffi_name: shader_storage_image_array_non_uniform_indexing_native, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + shader_uniform_buffer_array_non_uniform_indexing_native => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-shaderUniformBufferArrayNonUniformIndexingNative) + ", + ty: bool, + ffi_name: shader_uniform_buffer_array_non_uniform_indexing_native, + ffi_members: [properties_vulkan12, properties_descriptor_indexing], + required: false, + }, + shader_warps_per_sm => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html#limits-shaderWarpsPerSM) + ", + ty: u32, + ffi_name: shader_warps_per_sm, + ffi_members: [properties_shader_sm_builtins_nv], + required: false, + }, + shading_rate_max_coarse_samples => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html#limits-shadingRateMaxCoarseSamples) + ", + ty: u32, + ffi_name: shading_rate_max_coarse_samples, + ffi_members: [properties_shading_rate_image_nv], + required: false, + }, + shading_rate_palette_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html#limits-shadingRatePaletteSize) + ", + ty: u32, + ffi_name: shading_rate_palette_size, + ffi_members: [properties_shading_rate_image_nv], + required: false, + }, + shading_rate_texel_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html#limits-shadingRateTexelSize) + ", + ty: [u32; 2], + ffi_name: shading_rate_texel_size, + ffi_members: [properties_shading_rate_image_nv], + required: false, + }, + simd_per_compute_unit => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-simdPerComputeUnit) + ", + ty: u32, + ffi_name: simd_per_compute_unit, + ffi_members: [properties_shader_core_amd], + required: false, + }, + sparse_address_space_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-sparseAddressSpaceSize) + ", + ty: crate::DeviceSize, + ffi_name: sparse_address_space_size, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + standard_sample_locations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-standardSampleLocations) + ", + ty: bool, + ffi_name: standard_sample_locations, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + storage_image_sample_counts => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-storageImageSampleCounts) + ", + ty: crate::image::SampleCounts, + ffi_name: storage_image_sample_counts, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + storage_texel_buffer_offset_alignment_bytes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html#limits-storageTexelBufferOffsetAlignmentBytes) + ", + ty: crate::DeviceSize, + ffi_name: storage_texel_buffer_offset_alignment_bytes, + ffi_members: [properties_texel_buffer_alignment_ext], + required: false, + }, + storage_texel_buffer_offset_single_texel_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html#limits-storageTexelBufferOffsetSingleTexelAlignment) + ", + ty: bool, + ffi_name: storage_texel_buffer_offset_single_texel_alignment, + ffi_members: [properties_texel_buffer_alignment_ext], + required: false, + }, + strict_lines => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-strictLines) + ", + ty: bool, + ffi_name: strict_lines, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sub_pixel_interpolation_offset_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-subPixelInterpolationOffsetBits) + ", + ty: u32, + ffi_name: sub_pixel_interpolation_offset_bits, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sub_pixel_precision_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-subPixelPrecisionBits) + ", + ty: u32, + ffi_name: sub_pixel_precision_bits, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + sub_texel_precision_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-subTexelPrecisionBits) + ", + ty: u32, + ffi_name: sub_texel_precision_bits, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + subgroup_quad_operations_in_all_stages => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-subgroupQuadOperationsInAllStages) + ", + ty: bool, + ffi_name: subgroup_quad_operations_in_all_stages, + ffi_members: [properties_vulkan11], + required: false, + }, + subgroup_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-subgroupSize) + ", + ty: u32, + ffi_name: subgroup_size, + ffi_members: [properties_vulkan11, properties_subgroup], + required: false, + }, + subgroup_supported_operations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-subgroupSupportedOperations) + ", + ty: crate::device::physical::SubgroupFeatures, + ffi_name: subgroup_supported_operations, + ffi_members: [properties_vulkan11], + required: false, + }, + subgroup_supported_stages => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html#limits-subgroupSupportedStages) + ", + ty: crate::pipeline::shader::ShaderStages, + ffi_name: subgroup_supported_stages, + ffi_members: [properties_vulkan11], + required: false, + }, + subsampled_coarse_reconstruction_early_access => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html#limits-subsampledCoarseReconstructionEarlyAccess) + ", + ty: bool, + ffi_name: subsampled_coarse_reconstruction_early_access, + ffi_members: [properties_fragment_density_map2_ext], + required: false, + }, + subsampled_loads => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html#limits-subsampledLoads) + ", + ty: bool, + ffi_name: subsampled_loads, + ffi_members: [properties_fragment_density_map2_ext], + required: false, + }, + supported_depth_resolve_modes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-supportedDepthResolveModes) + ", + ty: crate::render_pass::ResolveModes, + ffi_name: supported_depth_resolve_modes, + ffi_members: [properties_vulkan12, properties_depth_stencil_resolve], + required: false, + }, + supported_operations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html#limits-supportedOperations) + ", + ty: crate::device::physical::SubgroupFeatures, + ffi_name: supported_operations, + ffi_members: [properties_subgroup], + required: false, + }, + supported_stages => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html#limits-supportedStages) + ", + ty: crate::pipeline::shader::ShaderStages, + ffi_name: supported_stages, + ffi_members: [properties_subgroup], + required: false, + }, + supported_stencil_resolve_modes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html#limits-supportedStencilResolveModes) + ", + ty: crate::render_pass::ResolveModes, + ffi_name: supported_stencil_resolve_modes, + ffi_members: [properties_vulkan12, properties_depth_stencil_resolve], + required: false, + }, + timestamp_compute_and_graphics => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-timestampComputeAndGraphics) + ", + ty: bool, + ffi_name: timestamp_compute_and_graphics, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + timestamp_period => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-timestampPeriod) + ", + ty: f32, + ffi_name: timestamp_period, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + transform_feedback_draw => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-transformFeedbackDraw) + ", + ty: bool, + ffi_name: transform_feedback_draw, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + transform_feedback_preserves_triangle_fan_provoking_vertex => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html#limits-transformFeedbackPreservesTriangleFanProvokingVertex) + ", + ty: bool, + ffi_name: transform_feedback_preserves_triangle_fan_provoking_vertex, + ffi_members: [properties_provoking_vertex_ext], + required: false, + }, + transform_feedback_queries => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-transformFeedbackQueries) + ", + ty: bool, + ffi_name: transform_feedback_queries, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + transform_feedback_rasterization_stream_select => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-transformFeedbackRasterizationStreamSelect) + ", + ty: bool, + ffi_name: transform_feedback_rasterization_stream_select, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + transform_feedback_streams_lines_triangles => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html#limits-transformFeedbackStreamsLinesTriangles) + ", + ty: bool, + ffi_name: transform_feedback_streams_lines_triangles, + ffi_members: [properties_transform_feedback_ext], + required: false, + }, + uniform_texel_buffer_offset_alignment_bytes => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html#limits-uniformTexelBufferOffsetAlignmentBytes) + ", + ty: crate::DeviceSize, + ffi_name: uniform_texel_buffer_offset_alignment_bytes, + ffi_members: [properties_texel_buffer_alignment_ext], + required: false, + }, + uniform_texel_buffer_offset_single_texel_alignment => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html#limits-uniformTexelBufferOffsetSingleTexelAlignment) + ", + ty: bool, + ffi_name: uniform_texel_buffer_offset_single_texel_alignment, + ffi_members: [properties_texel_buffer_alignment_ext], + required: false, + }, + variable_sample_locations => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html#limits-variableSampleLocations) + ", + ty: bool, + ffi_name: variable_sample_locations, + ffi_members: [properties_sample_locations_ext], + required: false, + }, + vendor_id => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html#limits-vendorID) + ", + ty: u32, + ffi_name: vendor_id, + ffi_members: [properties_vulkan10.properties], + required: true, + }, + vgpr_allocation_granularity => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-vgprAllocationGranularity) + ", + ty: u32, + ffi_name: vgpr_allocation_granularity, + ffi_members: [properties_shader_core_amd], + required: false, + }, + vgprs_per_simd => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-vgprsPerSimd) + ", + ty: u32, + ffi_name: vgprs_per_simd, + ffi_members: [properties_shader_core_amd], + required: false, + }, + viewport_bounds_range => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-viewportBoundsRange) + ", + ty: [f32; 2], + ffi_name: viewport_bounds_range, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + viewport_sub_pixel_bits => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html#limits-viewportSubPixelBits) + ", + ty: u32, + ffi_name: viewport_sub_pixel_bits, + ffi_members: [properties_vulkan10.properties.limits], + required: true, + }, + wavefront_size => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-wavefrontSize) + ", + ty: u32, + ffi_name: wavefront_size, + ffi_members: [properties_shader_core_amd], + required: false, + }, + wavefronts_per_simd => { + doc: " + - [Vulkan documentation](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html#limits-wavefrontsPerSimd) + ", + ty: u32, + ffi_name: wavefronts_per_simd, + ffi_members: [properties_shader_core_amd], + required: false, + }, +} + +crate::device::properties::properties_ffi! { + api_version, + device_extensions, + instance_extensions, + properties_vulkan11 => { + ty: PhysicalDeviceVulkan11Properties, + provided_by: [api_version >= crate::Version::V1_2], + conflicts: [], + }, + properties_vulkan12 => { + ty: PhysicalDeviceVulkan12Properties, + provided_by: [api_version >= crate::Version::V1_2], + conflicts: [], + }, + properties_id => { + ty: PhysicalDeviceIDProperties, + provided_by: [api_version >= crate::Version::V1_1, instance_extensions.khr_external_fence_capabilities, instance_extensions.khr_external_memory_capabilities, instance_extensions.khr_external_semaphore_capabilities], + conflicts: [properties_vulkan11], + }, + properties_maintenance3 => { + ty: PhysicalDeviceMaintenance3Properties, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_maintenance3], + conflicts: [properties_vulkan11], + }, + properties_multiview => { + ty: PhysicalDeviceMultiviewProperties, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_multiview], + conflicts: [properties_vulkan11], + }, + properties_point_clipping => { + ty: PhysicalDevicePointClippingProperties, + provided_by: [api_version >= crate::Version::V1_1, device_extensions.khr_maintenance2], + conflicts: [properties_vulkan11], + }, + properties_protected_memory => { + ty: PhysicalDeviceProtectedMemoryProperties, + provided_by: [api_version >= crate::Version::V1_1], + conflicts: [properties_vulkan11], + }, + properties_subgroup => { + ty: PhysicalDeviceSubgroupProperties, + provided_by: [api_version >= crate::Version::V1_1], + conflicts: [properties_vulkan11], + }, + properties_depth_stencil_resolve => { + ty: PhysicalDeviceDepthStencilResolveProperties, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_depth_stencil_resolve], + conflicts: [properties_vulkan12], + }, + properties_descriptor_indexing => { + ty: PhysicalDeviceDescriptorIndexingProperties, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.ext_descriptor_indexing], + conflicts: [properties_vulkan12], + }, + properties_driver => { + ty: PhysicalDeviceDriverProperties, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_driver_properties], + conflicts: [properties_vulkan12], + }, + properties_float_controls => { + ty: PhysicalDeviceFloatControlsProperties, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_shader_float_controls], + conflicts: [properties_vulkan12], + }, + properties_sampler_filter_minmax => { + ty: PhysicalDeviceSamplerFilterMinmaxProperties, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.ext_sampler_filter_minmax], + conflicts: [properties_vulkan12], + }, + properties_timeline_semaphore => { + ty: PhysicalDeviceTimelineSemaphoreProperties, + provided_by: [api_version >= crate::Version::V1_2, device_extensions.khr_timeline_semaphore], + conflicts: [properties_vulkan12], + }, + properties_acceleration_structure_khr => { + ty: PhysicalDeviceAccelerationStructurePropertiesKHR, + provided_by: [device_extensions.khr_acceleration_structure], + conflicts: [], + }, + properties_fragment_shading_rate_khr => { + ty: PhysicalDeviceFragmentShadingRatePropertiesKHR, + provided_by: [device_extensions.khr_fragment_shading_rate], + conflicts: [], + }, + properties_performance_query_khr => { + ty: PhysicalDevicePerformanceQueryPropertiesKHR, + provided_by: [device_extensions.khr_performance_query], + conflicts: [], + }, + properties_portability_subset_khr => { + ty: PhysicalDevicePortabilitySubsetPropertiesKHR, + provided_by: [device_extensions.khr_portability_subset], + conflicts: [], + }, + properties_push_descriptor_khr => { + ty: PhysicalDevicePushDescriptorPropertiesKHR, + provided_by: [device_extensions.khr_push_descriptor], + conflicts: [], + }, + properties_ray_tracing_pipeline_khr => { + ty: PhysicalDeviceRayTracingPipelinePropertiesKHR, + provided_by: [device_extensions.khr_ray_tracing_pipeline], + conflicts: [], + }, + properties_blend_operation_advanced_ext => { + ty: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, + provided_by: [device_extensions.ext_blend_operation_advanced], + conflicts: [], + }, + properties_conservative_rasterization_ext => { + ty: PhysicalDeviceConservativeRasterizationPropertiesEXT, + provided_by: [device_extensions.ext_conservative_rasterization], + conflicts: [], + }, + properties_custom_border_color_ext => { + ty: PhysicalDeviceCustomBorderColorPropertiesEXT, + provided_by: [device_extensions.ext_custom_border_color], + conflicts: [], + }, + properties_discard_rectangle_ext => { + ty: PhysicalDeviceDiscardRectanglePropertiesEXT, + provided_by: [device_extensions.ext_discard_rectangles], + conflicts: [], + }, + properties_drm_ext => { + ty: PhysicalDeviceDrmPropertiesEXT, + provided_by: [device_extensions.ext_physical_device_drm], + conflicts: [], + }, + properties_external_memory_host_ext => { + ty: PhysicalDeviceExternalMemoryHostPropertiesEXT, + provided_by: [device_extensions.ext_external_memory_host], + conflicts: [], + }, + properties_fragment_density_map2_ext => { + ty: PhysicalDeviceFragmentDensityMap2PropertiesEXT, + provided_by: [device_extensions.ext_fragment_density_map2], + conflicts: [], + }, + properties_fragment_density_map_ext => { + ty: PhysicalDeviceFragmentDensityMapPropertiesEXT, + provided_by: [device_extensions.ext_fragment_density_map], + conflicts: [], + }, + properties_inline_uniform_block_ext => { + ty: PhysicalDeviceInlineUniformBlockPropertiesEXT, + provided_by: [device_extensions.ext_inline_uniform_block], + conflicts: [], + }, + properties_line_rasterization_ext => { + ty: PhysicalDeviceLineRasterizationPropertiesEXT, + provided_by: [device_extensions.ext_line_rasterization], + conflicts: [], + }, + properties_multi_draw_ext => { + ty: PhysicalDeviceMultiDrawPropertiesEXT, + provided_by: [device_extensions.ext_multi_draw], + conflicts: [], + }, + properties_pci_bus_info_ext => { + ty: PhysicalDevicePCIBusInfoPropertiesEXT, + provided_by: [device_extensions.ext_pci_bus_info], + conflicts: [], + }, + properties_provoking_vertex_ext => { + ty: PhysicalDeviceProvokingVertexPropertiesEXT, + provided_by: [device_extensions.ext_provoking_vertex], + conflicts: [], + }, + properties_robustness2_ext => { + ty: PhysicalDeviceRobustness2PropertiesEXT, + provided_by: [device_extensions.ext_robustness2], + conflicts: [], + }, + properties_sample_locations_ext => { + ty: PhysicalDeviceSampleLocationsPropertiesEXT, + provided_by: [device_extensions.ext_sample_locations], + conflicts: [], + }, + properties_subgroup_size_control_ext => { + ty: PhysicalDeviceSubgroupSizeControlPropertiesEXT, + provided_by: [device_extensions.ext_subgroup_size_control], + conflicts: [], + }, + properties_texel_buffer_alignment_ext => { + ty: PhysicalDeviceTexelBufferAlignmentPropertiesEXT, + provided_by: [device_extensions.ext_texel_buffer_alignment], + conflicts: [], + }, + properties_transform_feedback_ext => { + ty: PhysicalDeviceTransformFeedbackPropertiesEXT, + provided_by: [device_extensions.ext_transform_feedback], + conflicts: [], + }, + properties_vertex_attribute_divisor_ext => { + ty: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, + provided_by: [device_extensions.ext_vertex_attribute_divisor], + conflicts: [], + }, + properties_cooperative_matrix_nv => { + ty: PhysicalDeviceCooperativeMatrixPropertiesNV, + provided_by: [device_extensions.nv_cooperative_matrix], + conflicts: [], + }, + properties_device_generated_commands_nv => { + ty: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, + provided_by: [device_extensions.nv_device_generated_commands], + conflicts: [], + }, + properties_fragment_shading_rate_enums_nv => { + ty: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, + provided_by: [device_extensions.nv_fragment_shading_rate_enums], + conflicts: [], + }, + properties_mesh_shader_nv => { + ty: PhysicalDeviceMeshShaderPropertiesNV, + provided_by: [device_extensions.nv_mesh_shader], + conflicts: [], + }, + properties_multiview_per_view_attributes_nvx => { + ty: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, + provided_by: [device_extensions.nvx_multiview_per_view_attributes], + conflicts: [], + }, + properties_ray_tracing_nv => { + ty: PhysicalDeviceRayTracingPropertiesNV, + provided_by: [device_extensions.nv_ray_tracing], + conflicts: [properties_ray_tracing_pipeline_khr, properties_acceleration_structure_khr], + }, + properties_shader_core2_amd => { + ty: PhysicalDeviceShaderCoreProperties2AMD, + provided_by: [device_extensions.amd_shader_core_properties2], + conflicts: [], + }, + properties_shader_core_amd => { + ty: PhysicalDeviceShaderCorePropertiesAMD, + provided_by: [device_extensions.amd_shader_core_properties], + conflicts: [], + }, + properties_shader_sm_builtins_nv => { + ty: PhysicalDeviceShaderSMBuiltinsPropertiesNV, + provided_by: [device_extensions.nv_shader_sm_builtins], + conflicts: [], + }, + properties_shading_rate_image_nv => { + ty: PhysicalDeviceShadingRateImagePropertiesNV, + provided_by: [device_extensions.nv_shading_rate_image], + conflicts: [], + }, + properties_subpass_shading_huawei => { + ty: PhysicalDeviceSubpassShadingPropertiesHUAWEI, + provided_by: [device_extensions.huawei_subpass_shading], + conflicts: [], + }, +} diff --git a/external/tinyxml2/resources/out/readme.txt b/external/tinyxml2/resources/out/readme.txt new file mode 100644 index 0000000000..5c8861afc0 --- /dev/null +++ b/external/tinyxml2/resources/out/readme.txt @@ -0,0 +1 @@ +This file is here to create this output directory when the source is pulled from git. \ No newline at end of file