core1_0

type AccessFlags int32

type AttachmentDescription struct {
	Flags   AttachmentDescriptionFlags
	Format  Format
	Samples SampleCountFlags

	LoadOp         AttachmentLoadOp
	StoreOp        AttachmentStoreOp
	StencilLoadOp  AttachmentLoadOp
	StencilStoreOp AttachmentStoreOp

	InitialLayout ImageLayout
	FinalLayout   ImageLayout
}

type AttachmentDescriptionFlags int32

type AttachmentLoadOp int32

type AttachmentReference struct {
	Attachment int
	Layout     ImageLayout
}

type AttachmentStoreOp int32

type BindSparseOptions struct {
	WaitSemaphores   []Semaphore
	SignalSemaphores []Semaphore

	BufferBinds      []SparseBufferMemoryBindInfo
	ImageOpaqueBinds []SparseImageOpaqueMemoryBindInfo
	ImageBinds       []SparseImageMemoryBindInfo

	common.NextOptions
}

type BlendFactor int32

type BlendOp int32

type BorderColor int32

type Buffer interface {
	Handle() driver.VkBuffer
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	MemoryRequirements() *MemoryRequirements
	BindBufferMemory(memory DeviceMemory, offset int) (common.VkResult, error)
}

type BufferCopy struct {
	SrcOffset int
	DstOffset int
	Size      int
}

type BufferCreateFlags int32

type BufferCreateInfo struct {
	Flags              BufferCreateFlags
	Size               int
	Usage              BufferUsageFlags
	SharingMode        SharingMode
	QueueFamilyIndices []int

	common.NextOptions
}

type BufferImageCopy struct {
	BufferOffset      int
	BufferRowLength   int
	BufferImageHeight int

	ImageSubresource ImageSubresourceLayers
	ImageOffset      Offset3D
	ImageExtent      Extent3D
}

type BufferMemoryBarrier struct {
	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags

	SrcQueueFamilyIndex int
	DstQueueFamilyIndex int

	Buffer Buffer

	Offset int
	Size   int

	common.NextOptions
}

type BufferUsageFlags int32

type BufferView interface {
	Handle() driver.VkBufferView
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type BufferViewCreateFlags int32

type BufferViewCreateInfo struct {
	Buffer Buffer
	Flags  BufferViewCreateFlags
	Format Format
	Offset int
	Range  int

	common.NextOptions
}

type ClearAttachment struct {
	AspectMask      ImageAspectFlags
	ColorAttachment int
	ClearValue      ClearValue
}

type ClearColorValue interface {
	PopulateColorUnion(c unsafe.Pointer)
}

type ClearRect struct {
	Rect           Rect2D
	BaseArrayLayer int
	LayerCount     int
}

type ClearValue interface {
	PopulateValueUnion(v unsafe.Pointer)
}

type ClearValueDepthStencil struct {
	Depth   float32
	Stencil uint32
}

type ClearValueFloat [4]float32

type ClearValueInt32 [4]int32

type ClearValueUint32 [4]uint32

type ColorComponentFlags int32

type ColorSpace int32

type CommandBuffer interface {
	Handle() driver.VkCommandBuffer
	Driver() driver.Driver
	DeviceHandle() driver.VkDevice
	CommandPoolHandle() driver.VkCommandPool
	APIVersion() common.APIVersion

	Free()
	Begin(o CommandBufferBeginInfo) (common.VkResult, error)
	End() (common.VkResult, error)
	Reset(flags CommandBufferResetFlags) (common.VkResult, error)
	CommandsRecorded() int
	DrawsRecorded() int
	DispatchesRecorded() int

	CmdBeginRenderPass(contents SubpassContents, o RenderPassBeginInfo) error
	CmdEndRenderPass()
	CmdBindPipeline(bindPoint PipelineBindPoint, pipeline Pipeline)
	CmdDraw(vertexCount, instanceCount int, firstVertex, firstInstance uint32)
	CmdDrawIndexed(indexCount, instanceCount int, firstIndex uint32, vertexOffset int, firstInstance uint32)
	CmdBindVertexBuffers(buffers []Buffer, bufferOffsets []int)
	CmdBindIndexBuffer(buffer Buffer, offset int, indexType IndexType)
	CmdCopyBuffer(srcBuffer Buffer, dstBuffer Buffer, copyRegions []BufferCopy) error
	CmdBindDescriptorSets(bindPoint PipelineBindPoint, layout PipelineLayout, sets []DescriptorSet, dynamicOffsets []int)
	CmdPipelineBarrier(srcStageMask, dstStageMask PipelineStageFlags, dependencies DependencyFlags, memoryBarriers []MemoryBarrier, bufferMemoryBarriers []BufferMemoryBarrier, imageMemoryBarriers []ImageMemoryBarrier) error
	CmdCopyBufferToImage(buffer Buffer, image Image, layout ImageLayout, regions []BufferImageCopy) error
	CmdBlitImage(sourceImage Image, sourceImageLayout ImageLayout, destinationImage Image, destinationImageLayout ImageLayout, regions []ImageBlit, filter Filter) error
	CmdPushConstants(layout PipelineLayout, stageFlags ShaderStageFlags, offset int, valueBytes []byte)
	CmdSetViewport(viewports []Viewport)
	CmdSetScissor(scissors []Rect2D)
	CmdCopyImage(srcImage Image, srcImageLayout ImageLayout, dstImage Image, dstImageLayout ImageLayout, regions []ImageCopy) error
	CmdNextSubpass(contents SubpassContents)
	CmdWaitEvents(events []Event, srcStageMask PipelineStageFlags, dstStageMask PipelineStageFlags, memoryBarriers []MemoryBarrier, bufferMemoryBarriers []BufferMemoryBarrier, imageMemoryBarriers []ImageMemoryBarrier) error
	CmdSetEvent(event Event, stageMask PipelineStageFlags)
	CmdClearColorImage(image Image, imageLayout ImageLayout, color ClearColorValue, ranges []ImageSubresourceRange)
	CmdResetQueryPool(queryPool QueryPool, startQuery, queryCount int)
	CmdBeginQuery(queryPool QueryPool, query int, flags QueryControlFlags)
	CmdEndQuery(queryPool QueryPool, query int)
	CmdCopyQueryPoolResults(queryPool QueryPool, firstQuery, queryCount int, dstBuffer Buffer, dstOffset, stride int, flags QueryResultFlags)
	CmdExecuteCommands(commandBuffers []CommandBuffer)
	CmdClearAttachments(attachments []ClearAttachment, rects []ClearRect) error
	CmdClearDepthStencilImage(image Image, imageLayout ImageLayout, depthStencil *ClearValueDepthStencil, ranges []ImageSubresourceRange)
	CmdCopyImageToBuffer(srcImage Image, srcImageLayout ImageLayout, dstBuffer Buffer, regions []BufferImageCopy) error
	CmdDispatch(groupCountX, groupCountY, groupCountZ int)
	CmdDispatchIndirect(buffer Buffer, offset int)
	CmdDrawIndexedIndirect(buffer Buffer, offset int, drawCount, stride int)
	CmdDrawIndirect(buffer Buffer, offset int, drawCount, stride int)
	CmdFillBuffer(dstBuffer Buffer, dstOffset int, size int, data uint32)
	CmdResetEvent(event Event, stageMask PipelineStageFlags)
	CmdResolveImage(srcImage Image, srcImageLayout ImageLayout, dstImage Image, dstImageLayout ImageLayout, regions []ImageResolve) error
	CmdSetBlendConstants(blendConstants [4]float32)
	CmdSetDepthBias(depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor float32)
	CmdSetDepthBounds(min, max float32)
	CmdSetLineWidth(lineWidth float32)
	CmdSetStencilCompareMask(faceMask StencilFaceFlags, compareMask uint32)
	CmdSetStencilReference(faceMask StencilFaceFlags, reference uint32)
	CmdSetStencilWriteMask(faceMask StencilFaceFlags, writeMask uint32)
	CmdUpdateBuffer(dstBuffer Buffer, dstOffset int, dataSize int, data []byte)
	CmdWriteTimestamp(pipelineStage PipelineStageFlags, queryPool QueryPool, query int)
}

type CommandBufferAllocateInfo struct {
	Level              CommandBufferLevel
	CommandBufferCount int
	CommandPool        CommandPool

	common.NextOptions
}

type CommandBufferBeginInfo struct {
	Flags           CommandBufferUsageFlags
	InheritanceInfo *CommandBufferInheritanceInfo

	common.NextOptions
}

type CommandBufferInheritanceInfo struct {
	Framebuffer Framebuffer
	RenderPass  RenderPass
	Subpass     int

	OcclusionQueryEnable bool
	QueryFlags           QueryControlFlags
	PipelineStatistics   QueryPipelineStatisticFlags

	common.NextOptions
}

type CommandBufferLevel int32

type CommandBufferResetFlags int32

type CommandBufferUsageFlags int32

type CommandCounter struct {
	CommandCount  int
	DrawCallCount int
	DispatchCount int
}

type CommandPool interface {
	Handle() driver.VkCommandPool
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	Reset(flags CommandPoolResetFlags) (common.VkResult, error)
}

type CommandPoolCreateFlags int32

type CommandPoolCreateInfo struct {
	QueueFamilyIndex *int
	Flags            CommandPoolCreateFlags

	common.NextOptions
}

type CommandPoolResetFlags int32

type CompareOp int32

type ComponentMapping struct {
	R ComponentSwizzle
	G ComponentSwizzle
	B ComponentSwizzle
	A ComponentSwizzle
}

type ComponentSwizzle int32

type CompositeAlphaFlags int32

type ComputePipelineCreateInfo struct {
	Flags  PipelineCreateFlags
	Stage  PipelineShaderStageCreateInfo
	Layout PipelineLayout

	BasePipeline      Pipeline
	BasePipelineIndex int

	common.NextOptions
}

type CopyDescriptorSet struct {
	SrcSet          DescriptorSet
	SrcBinding      int
	SrcArrayElement int

	DstSet          DescriptorSet
	DstBinding      int
	DstArrayElement int

	DescriptorCount int

	common.NextOptions
}

type CullModeFlags int32

type DependencyFlags int32

type DescriptorBufferInfo struct {
	Buffer Buffer
	Offset int
	Range  int
}

type DescriptorImageInfo struct {
	Sampler     Sampler
	ImageView   ImageView
	ImageLayout ImageLayout
}

type DescriptorPool interface {
	Handle() driver.VkDescriptorPool
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	Reset(flags DescriptorPoolResetFlags) (common.VkResult, error)
}

type DescriptorPoolCreateFlags int32

type DescriptorPoolCreateInfo struct {
	Flags DescriptorPoolCreateFlags

	MaxSets   int
	PoolSizes []DescriptorPoolSize

	common.NextOptions
}

type DescriptorPoolResetFlags int32

type DescriptorPoolSize struct {
	Type            DescriptorType
	DescriptorCount int
}

type DescriptorSet interface {
	Handle() driver.VkDescriptorSet
	DescriptorPoolHandle() driver.VkDescriptorPool
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Free() (common.VkResult, error)
}

type DescriptorSetAllocateInfo struct {
	DescriptorPool DescriptorPool

	SetLayouts []DescriptorSetLayout

	common.NextOptions
}

type DescriptorSetLayout interface {
	Handle() driver.VkDescriptorSetLayout
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type DescriptorSetLayoutBinding struct {
	Binding         int
	DescriptorType  DescriptorType
	DescriptorCount int
	StageFlags      ShaderStageFlags

	ImmutableSamplers []Sampler
}

type DescriptorSetLayoutCreateFlags int32

type DescriptorSetLayoutCreateInfo struct {
	Flags    DescriptorSetLayoutCreateFlags
	Bindings []DescriptorSetLayoutBinding

	common.NextOptions
}

type DescriptorType int32

type Device interface {
	Handle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	IsDeviceExtensionActive(extensionName string) bool

	CreateBuffer(allocationCallbacks *driver.AllocationCallbacks, o BufferCreateInfo) (Buffer, common.VkResult, error)
	CreateBufferView(allocationCallbacks *driver.AllocationCallbacks, o BufferViewCreateInfo) (BufferView, common.VkResult, error)
	CreateCommandPool(allocationCallbacks *driver.AllocationCallbacks, o CommandPoolCreateInfo) (CommandPool, common.VkResult, error)
	CreateDescriptorPool(allocationCallbacks *driver.AllocationCallbacks, o DescriptorPoolCreateInfo) (DescriptorPool, common.VkResult, error)
	CreateDescriptorSetLayout(allocationCallbacks *driver.AllocationCallbacks, o DescriptorSetLayoutCreateInfo) (DescriptorSetLayout, common.VkResult, error)
	CreateEvent(allocationCallbacks *driver.AllocationCallbacks, options EventCreateInfo) (Event, common.VkResult, error)
	CreateFence(allocationCallbacks *driver.AllocationCallbacks, o FenceCreateInfo) (Fence, common.VkResult, error)
	CreateFramebuffer(allocationCallbacks *driver.AllocationCallbacks, o FramebufferCreateInfo) (Framebuffer, common.VkResult, error)
	CreateGraphicsPipelines(pipelineCache PipelineCache, allocationCallbacks *driver.AllocationCallbacks, o []GraphicsPipelineCreateInfo) ([]Pipeline, common.VkResult, error)
	CreateComputePipelines(pipelineCache PipelineCache, allocationCallbacks *driver.AllocationCallbacks, o []ComputePipelineCreateInfo) ([]Pipeline, common.VkResult, error)
	CreateImage(allocationCallbacks *driver.AllocationCallbacks, options ImageCreateOptions) (Image, common.VkResult, error)
	CreateImageView(allocationCallbacks *driver.AllocationCallbacks, o ImageViewCreateInfo) (ImageView, common.VkResult, error)
	CreatePipelineCache(allocationCallbacks *driver.AllocationCallbacks, o PipelineCacheCreateInfo) (PipelineCache, common.VkResult, error)
	CreatePipelineLayout(allocationCallbacks *driver.AllocationCallbacks, o PipelineLayoutCreateInfo) (PipelineLayout, common.VkResult, error)
	CreateQueryPool(allocationCallbacks *driver.AllocationCallbacks, o QueryPoolCreateInfo) (QueryPool, common.VkResult, error)
	CreateRenderPass(allocationCallbacks *driver.AllocationCallbacks, o RenderPassCreateInfo) (RenderPass, common.VkResult, error)
	CreateSampler(allocationCallbacks *driver.AllocationCallbacks, o SamplerCreateInfo) (Sampler, common.VkResult, error)
	CreateSemaphore(allocationCallbacks *driver.AllocationCallbacks, o SemaphoreCreateInfo) (Semaphore, common.VkResult, error)
	CreateShaderModule(allocationCallbacks *driver.AllocationCallbacks, o ShaderModuleCreateInfo) (ShaderModule, common.VkResult, error)

	GetQueue(queueFamilyIndex int, queueIndex int) Queue
	AllocateMemory(allocationCallbacks *driver.AllocationCallbacks, o MemoryAllocateInfo) (DeviceMemory, common.VkResult, error)
	FreeMemory(deviceMemory DeviceMemory, allocationCallbacks *driver.AllocationCallbacks)

	AllocateCommandBuffers(o CommandBufferAllocateInfo) ([]CommandBuffer, common.VkResult, error)
	FreeCommandBuffers(buffers []CommandBuffer)
	AllocateDescriptorSets(o DescriptorSetAllocateInfo) ([]DescriptorSet, common.VkResult, error)
	FreeDescriptorSets(sets []DescriptorSet) (common.VkResult, error)

	Destroy(callbacks *driver.AllocationCallbacks)
	WaitIdle() (common.VkResult, error)
	WaitForFences(waitForAll bool, timeout time.Duration, fences []Fence) (common.VkResult, error)
	ResetFences(fences []Fence) (common.VkResult, error)
	UpdateDescriptorSets(writes []WriteDescriptorSet, copies []CopyDescriptorSet) error
	FlushMappedMemoryRanges(ranges []MappedMemoryRange) (common.VkResult, error)
	InvalidateMappedMemoryRanges(ranges []MappedMemoryRange) (common.VkResult, error)
}

type DeviceCreateFlags int32

type DeviceCreateInfo struct {
	Flags                 DeviceCreateFlags
	QueueCreateInfos      []DeviceQueueCreateInfo
	EnabledFeatures       *PhysicalDeviceFeatures
	EnabledExtensionNames []string
	EnabledLayerNames     []string

	common.NextOptions
}

type DeviceMemory interface {
	Handle() driver.VkDeviceMemory
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Map(offset int, size int, flags MemoryMapFlags) (unsafe.Pointer, common.VkResult, error)
	Unmap()
	Free(callbacks *driver.AllocationCallbacks)
	Commitment() int
	FlushAll() (common.VkResult, error)
	InvalidateAll() (common.VkResult, error)
}

type DeviceQueueCreateFlags int32

type DeviceQueueCreateInfo struct {
	Flags            DeviceQueueCreateFlags
	QueueFamilyIndex int
	QueuePriorities  []float32

	common.NextOptions
}

type DynamicState int32

type Event interface {
	Handle() driver.VkEvent
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	Set() (common.VkResult, error)
	Reset() (common.VkResult, error)
	Status() (common.VkResult, error)
}

type EventCreateFlags int32

type EventCreateInfo struct {
	Flags EventCreateFlags

	common.NextOptions
}

type ExtensionProperties struct {
	ExtensionName string
	SpecVersion   common.Version
}

type Extent2D struct {
	Width  int
	Height int
}

type Extent3D struct {
	Width  int
	Height int
	Depth  int
}

type Fence interface {
	Handle() driver.VkFence
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	Wait(timeout time.Duration) (common.VkResult, error)
	Reset() (common.VkResult, error)
	Status() (common.VkResult, error)
}

type FenceCreateFlags int32

type FenceCreateInfo struct {
	Flags FenceCreateFlags

	common.NextOptions
}

type Filter int32

type Format int32

type FormatFeatureFlags int32

type FormatProperties struct {
	LinearTilingFeatures  FormatFeatureFlags
	OptimalTilingFeatures FormatFeatureFlags
	BufferFeatures        FormatFeatureFlags
}

type Framebuffer interface {
	Handle() driver.VkFramebuffer
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type FramebufferCreateFlags int32

type FramebufferCreateInfo struct {
	Attachments []ImageView
	Flags       FramebufferCreateFlags

	Width  int
	Height int
	Layers uint32

	RenderPass RenderPass

	common.NextOptions
}

type FrontFace int32

type GraphicsPipelineCreateInfo struct {
	Flags PipelineCreateFlags

	Stages             []PipelineShaderStageCreateInfo
	VertexInputState   *PipelineVertexInputStateCreateInfo
	InputAssemblyState *PipelineInputAssemblyStateCreateInfo
	TessellationState  *PipelineTessellationStateCreateInfo
	ViewportState      *PipelineViewportStateCreateInfo
	RasterizationState *PipelineRasterizationStateCreateInfo
	MultisampleState   *PipelineMultisampleStateCreateInfo
	DepthStencilState  *PipelineDepthStencilStateCreateInfo
	ColorBlendState    *PipelineColorBlendStateCreateInfo
	DynamicState       *PipelineDynamicStateCreateInfo

	Layout     PipelineLayout
	RenderPass RenderPass

	Subpass           int
	BasePipeline      Pipeline
	BasePipelineIndex int

	common.NextOptions
}

type Image interface {
	Handle() driver.VkImage
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	MemoryRequirements() *MemoryRequirements
	BindImageMemory(memory DeviceMemory, offset int) (common.VkResult, error)
	SubresourceLayout(subresource *ImageSubresource) *SubresourceLayout
	SparseMemoryRequirements() []SparseImageMemoryRequirements
}

type ImageAspectFlags int32

type ImageBlit struct {
	SrcSubresource ImageSubresourceLayers
	SrcOffsets     [2]Offset3D

	DstSubresource ImageSubresourceLayers
	DstOffsets     [2]Offset3D
}

type ImageCopy struct {
	SrcSubresource ImageSubresourceLayers
	SrcOffset      Offset3D
	DstSubresource ImageSubresourceLayers
	DstOffset      Offset3D
	Extent         Extent3D
}

type ImageCreateFlags int32

type ImageCreateOptions struct {
	Flags     ImageCreateFlags
	ImageType ImageType
	Format    Format
	Extent    Extent3D

	MipLevels   int
	ArrayLayers int

	Samples     SampleCountFlags
	Tiling      ImageTiling
	Usage       ImageUsageFlags
	SharingMode SharingMode

	QueueFamilies []uint32

	InitialLayout ImageLayout

	common.NextOptions
}

type ImageFormatProperties struct {
	MaxExtent       Extent3D
	MaxMipLevels    int
	MaxArrayLayers  int
	SampleCounts    SampleCountFlags
	MaxResourceSize int
}

type ImageLayout int32

type ImageMemoryBarrier struct {
	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags

	OldLayout ImageLayout
	NewLayout ImageLayout

	SrcQueueFamilyIndex int
	DstQueueFamilyIndex int

	Image            Image
	SubresourceRange ImageSubresourceRange

	common.NextOptions
}

type ImageResolve struct {
	SrcSubresource ImageSubresourceLayers
	SrcOffset      Offset3D
	DstSubresource ImageSubresourceLayers
	DstOffset      Offset3D
	Extent         Extent3D
}

type ImageSubresource struct {
	AspectMask ImageAspectFlags
	MipLevel   uint32
	ArrayLayer uint32
}

type ImageSubresourceLayers struct {
	AspectMask     ImageAspectFlags
	MipLevel       int
	BaseArrayLayer int
	LayerCount     int
}

type ImageSubresourceRange struct {
	AspectMask     ImageAspectFlags
	BaseMipLevel   int
	LevelCount     int
	BaseArrayLayer int
	LayerCount     int
}

type ImageTiling int32

type ImageType int32

type ImageUsageFlags int32

type ImageView interface {
	Handle() driver.VkImageView
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type ImageViewCreateFlags int32

type ImageViewCreateInfo struct {
	Image Image

	Flags            ImageViewCreateFlags
	ViewType         ImageViewType
	Format           Format
	Components       ComponentMapping
	SubresourceRange ImageSubresourceRange

	common.NextOptions
}

type ImageViewType int32

type IndexType int32

type InputRate int32

type Instance interface {
	Handle() driver.VkInstance
	Driver() driver.Driver
	APIVersion() common.APIVersion

	IsInstanceExtensionActive(extensionName string) bool
	EnumeratePhysicalDevices() ([]PhysicalDevice, common.VkResult, error)

	Destroy(callbacks *driver.AllocationCallbacks)
}

type InstanceCreateFlags int32

type InstanceCreateInfo struct {
	ApplicationName    string
	ApplicationVersion common.Version
	EngineName         string
	EngineVersion      common.Version
	APIVersion         common.APIVersion

	Flags InstanceCreateFlags

	EnabledExtensionNames []string
	EnabledLayerNames     []string

	common.NextOptions
}

type LayerProperties struct {
	LayerName             string
	SpecVersion           common.Version
	ImplementationVersion common.Version
	Description           string
}

type LogicOp int32

type MappedMemoryRange struct {
	Memory DeviceMemory
	Offset int
	Size   int

	common.NextOptions
}

type MemoryAllocateInfo struct {
	AllocationSize  int
	MemoryTypeIndex int

	common.NextOptions
}

type MemoryBarrier struct {
	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags

	common.NextOptions
}

type MemoryHeap struct {
	Size  int
	Flags MemoryHeapFlags
}

type MemoryHeapFlags int32

type MemoryMapFlags int32

type MemoryPropertyFlags int32

type MemoryRequirements struct {
	Size           int
	Alignment      int
	MemoryTypeBits uint32
}

type MemoryType struct {
	PropertyFlags MemoryPropertyFlags
	HeapIndex     int
}

type ObjectType int32

type Offset2D struct {
	X int
	Y int
}

type Offset3D struct {
	X int
	Y int
	Z int
}

type PhysicalDevice interface {
	Handle() driver.VkPhysicalDevice
	Driver() driver.Driver
	InstanceAPIVersion() common.APIVersion
	DeviceAPIVersion() common.APIVersion

	CreateDevice(allocationCallbacks *driver.AllocationCallbacks, options DeviceCreateInfo) (Device, common.VkResult, error)

	QueueFamilyProperties() []*QueueFamily
	Properties() (*PhysicalDeviceProperties, error)
	Features() *PhysicalDeviceFeatures
	EnumerateDeviceExtensionProperties() (map[string]*ExtensionProperties, common.VkResult, error)
	EnumerateDeviceExtensionPropertiesForLayer(layerName string) (map[string]*ExtensionProperties, common.VkResult, error)
	EnumerateDeviceLayerProperties() (map[string]*LayerProperties, common.VkResult, error)
	MemoryProperties() *PhysicalDeviceMemoryProperties
	FormatProperties(format Format) *FormatProperties
	ImageFormatProperties(format Format, imageType ImageType, tiling ImageTiling, usages ImageUsageFlags, flags ImageCreateFlags) (*ImageFormatProperties, common.VkResult, error)
	SparseImageFormatProperties(format Format, imageType ImageType, samples SampleCountFlags, usages ImageUsageFlags, tiling ImageTiling) []SparseImageFormatProperties
}