Disabled.

Standard Vulkan.

Vulkan SC, for safety-critical systems.

Specification authors.

struct Authors <: VulkanSpec.Collection{AuthorTag}

• data::StructArrays.StructVector{AuthorTag, NamedTuple{(:tag, :author), Tuple{Vector{String}, Vector{String}}}, Int64}

API bitmasks.

struct Bitmasks <: VulkanSpec.Collection{SpecBitmask}

• data::StructArrays.StructVector{SpecBitmask, NamedTuple{(:name, :bits, :combinations, :width), Tuple{Vector{Symbol}, Vector{StructArrays.StructVector{SpecBit}}, Vector{StructArrays.StructVector{SpecBitCombination}}, Vector{Integer}}}, Int64}

SPIR-V capabilities.

struct CapabilitiesSPIRV <: VulkanSpec.Collection{VulkanSpec.SpecCapabilitySPIRV}

• data::StructArrays.StructVector{VulkanSpec.SpecCapabilitySPIRV, NamedTuple{(:name, :promoted_to, :enabling_extensions, :enabling_features, :enabling_properties), Tuple{Vector{Symbol}, Vector{Union{Nothing, VersionNumber}}, Vector{Vector{String}}, Vector{Vector{VulkanSpec.FeatureCondition}}, Vector{Vector{VulkanSpec.PropertyCondition}}}}, Int64}

API constants, usually defined in C with #define.

struct Constants <: VulkanSpec.Collection{SpecConstant}

• data::StructArrays.StructVector{SpecConstant, NamedTuple{(:name, :value), Tuple{Vector{Symbol}, Vector{Any}}}, Int64}

API handle constructors.

struct Constructors <: VulkanSpec.Collection{CreateFunc}

• data::StructArrays.StructVector{CreateFunc, NamedTuple{(:func, :handle, :create_info_struct, :create_info_param, :batch), Tuple{Vector{SpecFunc}, Vector{SpecHandle}, Vector{Union{Nothing, SpecStruct}}, Vector{Union{Nothing, SpecFuncParam}}, Vector{Bool}}}, Int64}

Function func that creates a handle from a create info structure create_info_struct passed as the value of the parameter create_info_param.

If batch is true, then func expects a list of multiple create info structures and will create multiple handles at once.

struct CreateFunc <: Spec

• func::SpecFunc

• handle::SpecHandle

• create_info_struct::Union{Nothing, SpecStruct}

• create_info_param::Union{Nothing, SpecFuncParam}

• batch::Bool

Function func that destroys a handle passed as the value of the parameter destroyed_param.

If batch is true, then func expects a list of multiple handles and will destroy all of them at once.

struct DestroyFunc <: Spec

• func::SpecFunc

• handle::SpecHandle

• destroyed_param::SpecFuncParam

• batch::Bool

API handle destructors.

struct Destructors <: VulkanSpec.Collection{DestroyFunc}

• data::StructArrays.StructVector{DestroyFunc, NamedTuple{(:func, :handle, :destroyed_param, :batch), Tuple{Vector{SpecFunc}, Vector{SpecHandle}, Vector{SpecFuncParam}, Vector{Bool}}}, Int64}

API enumerated values, excluding bitmasks.

struct Enums <: VulkanSpec.Collection{SpecEnum}

• data::StructArrays.StructVector{SpecEnum, NamedTuple{(:name, :enums), Tuple{Vector{Symbol}, Vector{StructArrays.StructVector{SpecConstant}}}}, Int64}

Describes what type of support an extension has per the specification.

struct ExtensionSupport <: BitMask{UInt32}

• val::UInt32

API extensions.

struct Extensions <: VulkanSpec.Collection{SpecExtension}

• data::StructArrays.StructVector{SpecExtension, NamedTuple{(:name, :type, :requirements, :support, :author, :symbols, :platform, :is_provisional, :promoted_to, :deprecated_by), Tuple{Vector{String}, Vector{VulkanSpec.ExtensionType}, Vector{Vector{String}}, Vector{VulkanSpec.ExtensionSupport}, Vector{Union{Nothing, String}}, Vector{Vector{Symbol}}, Vector{PlatformType}, Vector{Bool}, Vector{Union{Nothing, VersionNumber, String}}, Vector{Union{Nothing, String}}}}, Int64}

SPIR-V extensions.

struct ExtensionsSPIRV <: VulkanSpec.Collection{VulkanSpec.SpecExtensionSPIRV}

• data::StructArrays.StructVector{VulkanSpec.SpecExtensionSPIRV, NamedTuple{(:name, :promoted_to, :enabling_extensions), Tuple{Vector{String}, Vector{Union{Nothing, VersionNumber}}, Vector{Vector{String}}}}, Int64}

Iterate through function or struct specification fields from a list of fields. list is a sequence of fields to get through from root.

struct FieldIterator

• root::Union{SpecFuncParam, SpecStructMember}

• list::Vector{Symbol}

• structs::Structs

API flags.

struct Flags <: VulkanSpec.Collection{SpecFlag}

• data::StructArrays.StructVector{SpecFlag, NamedTuple{(:name, :typealias, :bitmask), Tuple{Vector{Symbol}, Vector{Symbol}, Vector{Union{Nothing, SpecBitmask}}}}, Int64}

Function type classification.

Types:

• FTYPE_CREATE: constructor (functions that begin with vkCreate).
• FTYPE_DESTROY: destructor (functions that begin with vkDestroy).
• FTYPE_ALLOCATE: allocator (functions that begin with vkAllocate).
• FTYPE_FREE: deallocator (functions that begin with vkFree).
• FTYPE_COMMAND: Vulkan command (functions that begin with vkCmd).
• FTYPE_QUERY: used to query parameters, returned directly or indirectly through pointer mutation (typically, functions that begin with vkEnumerate and vkGet, but not all of them and possibly others).
• FTYPE_OTHER: no identified type.

primitive type FunctionType <: Enum{Int32} 32

API functions.

struct Functions <: VulkanSpec.Collection{SpecFunc}

• data::StructArrays.StructVector{SpecFunc, NamedTuple{(:name, :type, :return_type, :render_pass_compatibility, :queue_compatibility, :params, :success_codes, :error_codes), Tuple{Vector{Symbol}, Vector{FunctionType}, Vector{Union{Nothing, Expr, Symbol}}, Vector{Vector{RenderPassRequirement}}, Vector{Vector{QueueType}}, Vector{StructArrays.StructVector{SpecFuncParam}}, Vector{Vector{Symbol}}, Vector{Vector{Symbol}}}}, Int64}

API handle types.

struct Handles <: VulkanSpec.Collection{SpecHandle}

• data::StructArrays.StructVector{SpecHandle, NamedTuple{(:name, :parent, :is_dispatchable), Tuple{Vector{Symbol}, Vector{Union{Nothing, Symbol}}, Vector{Bool}}}, Int64}

Parameter requirement. Applies both to struct members and function parameters.

Requirement types:

• OPTIONAL: may have its default zero (or nullptr) value, acting as a sentinel value (similar to Nothing in Julia).
• REQUIRED: must be provided, no sentinel value is allowed.
• POINTER_OPTIONAL: is a pointer which may be null, but must have valid elements if provided.
• POINTER_REQUIRED: must be a valid pointer, but its elements are optional (e.g. are allowed to be sentinel values).
• POINTER_FULLY_OPTIONAL: may be null, or a pointer with optional elements (e.g. are allowed to be sentinel values).

primitive type PARAM_REQUIREMENT <: Enum{Int32} 32

Queue type on which a computation can be carried.

abstract type QueueType

The command can be executed outside a render pass.

struct RenderPassOutside <: RenderPassRequirement

Render pass execution specification for commands.

abstract type RenderPassRequirement

Everything that a Vulkan specification can apply to: data structures, functions, parameters...

abstract type Spec

Specification for an alias of the form const <name> = <alias>.

struct SpecAlias{S<:Spec} <: Spec

• name::Symbol: Name of the new alias.

• alias::Spec: Aliased specification element.

Specification for a bit used in a bitmask.

struct SpecBit <: Spec

• name::Symbol: Name of the bit.

• position::Int64: Position of the bit.

Specification for a bitmask type that must be formed through a combination of bits.

Is usually an alias for a UInt32 type which carries meaning through its bits.

struct SpecBitmask <: Spec

• name::Symbol: Name of the bitmask type.

• bits::StructArrays.StructVector{SpecBit}: Valid bits that can be combined to form the final bitmask value.

• combinations::StructArrays.StructVector{SpecBitCombination}

• width::Integer

Specification for a constant.

struct SpecConstant <: Spec

• name::Symbol: Name of the constant.

• value::Any: Value of the constant.

Specification for an enumeration type.

struct SpecEnum <: Spec

• name::Symbol: Name of the enumeration type.

• enums::StructArrays.StructVector{SpecConstant}: Vector of possible enumeration values.

Specification for a flag type name that is a type alias of typealias. Can be associated with a bitmask structure, in which case the bitmask number is set to the corresponding SpecBitmask.

struct SpecFlag <: Spec

• name::Symbol: Name of the flag type.

• typealias::Symbol: The type it aliases.

• bitmask::Union{Nothing, SpecBitmask}: Bitmask, if applicable.

Specification for a function.

struct SpecFunc <: Spec

• name::Symbol: Name of the function.

• type::FunctionType: FunctionType classification.

• return_type::Union{Nothing, Expr, Symbol}: Return type (void if Nothing).

• render_pass_compatibility::Vector{RenderPassRequirement}: Whether the function can be executed inside a render pass, outside, or both. Empty if not specified, in which case it is equivalent to both inside and outside.

• queue_compatibility::Vector{QueueType}: Type of queues on which the function can be executed. Empty if not specified, in which case it is equivalent to being executable on all queues.

• params::StructArrays.StructVector{SpecFuncParam}: Function parameters.

• success_codes::Vector{Symbol}

• error_codes::Vector{Symbol}

Specification for a function parameter.

struct SpecFuncParam <: Spec

• parent::Any: Name of the parent function.

• name::Symbol: Identifier.

• type::Union{Expr, Symbol}: Expression of its idiomatic Julia type.

• is_constant::Bool: If constant, cannot be mutated by Vulkan functions.

• is_externsync::Bool: Whether it must be externally synchronized before calling the function.

• requirement::PARAM_REQUIREMENT: PARAM_REQUIREMENT classification.

• len::Union{Nothing, Expr, Symbol}: Name of the parameter (of the same function) which represents its length. Nothing for non-vector types. Can be an expression of a parameter.

• arglen::Vector{Symbol}: Name of the parameters (of the same function) it is a length of.

• autovalidity::Bool: Whether automatic validity documentation is enabled. If false, this means that the parameter may be an exception to at least one Vulkan convention.

Specification for handle types.

A handle may possess a parent. In this case, the handle can only be valid if its parent is valid.

Some handles are dispatchable, which means that they are represented as opaque pointers. Non-dispatchable handles are 64-bit integer types, and may encode information directly into their value.

struct SpecHandle <: Spec

• name::Symbol: Name of the handle type.

• parent::Union{Nothing, Symbol}: Name of the parent handle, if any.

• is_dispatchable::Bool: Whether the handle is dispatchable or not.

API platforms.

struct SpecPlatform <: Spec

• type::PlatformType

• description::String

Specification for a structure.

struct SpecStruct <: Spec

• name::Symbol: Name of the structure.

• type::StructType: StructType classification.

• is_returnedonly::Bool: Whether the structure is only meant to be filled in by Vulkan functions, as opposed to being constructed by the user.

  Note that the API may still request the user to provide an initialized structure, notably as part of pNext chains for queries.

• extends::Vector{Symbol}: Name of the structures it extends, usually done through the original structures' pNext argument.

• members::StructArrays.StructVector{SpecStructMember}: Structure members.

Specification for a structure parameter.

struct SpecStructMember <: Spec

• parent::Any: Name of the parent structure.

• name::Symbol: Identifier.

• type::Union{Expr, Symbol}: Expression of its idiomatic Julia type.

• is_constant::Bool: If constant, cannot be mutated by Vulkan functions.

• is_externsync::Bool: Whether it must be externally synchronized before calling any function which uses the parent structure.

• requirement::PARAM_REQUIREMENT: PARAM_REQUIREMENT classification.

• len::Union{Nothing, Expr, Symbol}: Name of the member (of the same structure) which represents its length. Nothing for non-vector types.

• arglen::Vector{Union{Expr, Symbol}}: Name of the members (of the same structure) it is a length of.

• autovalidity::Bool: Whether automatic validity documentation is enabled. If false, this means that the member may be an exception to at least one Vulkan convention.

Specification for a union type.

struct SpecUnion <: Spec

• name::Symbol: Name of the union type.

• types::Vector{Union{Expr, Symbol}}: Possible types for the union.

• fields::Vector{Symbol}: Fields which cast the struct into the union types

• selectors::Vector{Symbol}: Selector values, if any, to determine the type of the union in a given context (function call for example).

• is_returnedonly::Bool: Whether the structure is only meant to be filled in by Vulkan functions, as opposed to being constructed by the user.

  Note that the API may still request the user to provide an initialized structure, notably as part of pNext chains for queries.

Structure type classification.

Types:

• STYPE_CREATE_INFO: holds constructor parameters (structures that end with CreateInfo).
• STYPE_ALLOCATE_INFO: holds allocator parameters (structures that end with AllocateInfo).
• STYPE_GENERIC_INFO: holds parameters for another function or structure (structures that end with Info, excluding those falling into the previous types).
• STYPE_DATA: usually represents user or Vulkan data.
• STYPE_PROPERTY: is a property returned by Vulkan in a returnedonly structure, usually done through FTYPE_QUERY type functions.

primitive type StructType <: Enum{Int32} 32

API structure types.

struct Structs <: VulkanSpec.Collection{SpecStruct}

• data::StructArrays.StructVector{SpecStruct, NamedTuple{(:name, :type, :is_returnedonly, :extends, :members), Tuple{Vector{Symbol}, Vector{StructType}, Vector{Bool}, Vector{Vector{Symbol}}, Vector{StructArrays.StructVector{SpecStructMember}}}}, Int64}

API union types.

struct Unions <: VulkanSpec.Collection{SpecUnion}

• data::StructArrays.StructVector{SpecUnion, NamedTuple{(:name, :types, :fields, :selectors, :is_returnedonly), Tuple{Vector{Symbol}, Vector{Vector{Union{Expr, Symbol}}}, Vector{Vector{Symbol}}, Vector{Vector{Symbol}}, Vector{Bool}}}, Int64}

arglen(queueCount)

Return the function parameters or struct members whose length is encoded by the provided argument.

Whether an alias was built from this name.

hasalias(
    name,
    aliases::VulkanSpec.Aliases
) -> Union{Missing, Bool}

True if the argument that can be inferred from other arguments.

is_inferable_length(spec::SpecStructMember) -> Bool

True if the argument behaves differently than other length parameters, and requires special care.

is_length_exception(spec::SpecStructMember) -> Bool

Whether this type is an alias for another name.

isalias(name, aliases::VulkanSpec.Aliases) -> Bool

Return whether an extension is enabled for standard Vulkan - that is, a given symbol x is either core or is from an extension that has not been disabled, or is not exclusive to Vulkan SC.

isenabled(x, extensions::Extensions) -> Any

len(pCode)

Return the function parameter or struct member which describes the length of the provided pointer argument. When the length is more complex than a simple argument, i.e. is a function of another parameter, missing is returned. In this case, refer to the .len field of the argument to get the correct Expr.

Semantically translate C types to their Julia counterpart. Note that since it is a semantic translation, translated types do not necessarily have the same layout, e.g. VkBool32 => Bool (8 bits).

translate_c_type(ctype) -> Any