core1_0

package
v0.0.0-...-0931f86 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 7, 2022 License: MIT Imports: 11 Imported by: 53

Documentation

Index

Constants

View Source 
const (
	BufferCreateSparseBinding   BufferCreateFlags = C.VK_BUFFER_CREATE_SPARSE_BINDING_BIT
	BufferCreateSparseResidency BufferCreateFlags = C.VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
	BufferCreateSparseAliased   BufferCreateFlags = C.VK_BUFFER_CREATE_SPARSE_ALIASED_BIT

	BufferUsageTransferSrc        BufferUsageFlags = C.VK_BUFFER_USAGE_TRANSFER_SRC_BIT
	BufferUsageTransferDst        BufferUsageFlags = C.VK_BUFFER_USAGE_TRANSFER_DST_BIT
	BufferUsageUniformTexelBuffer BufferUsageFlags = C.VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
	BufferUsageStorageTexelBuffer BufferUsageFlags = C.VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
	BufferUsageUniformBuffer      BufferUsageFlags = C.VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
	BufferUsageStorageBuffer      BufferUsageFlags = C.VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
	BufferUsageIndexBuffer        BufferUsageFlags = C.VK_BUFFER_USAGE_INDEX_BUFFER_BIT
	BufferUsageVertexBuffer       BufferUsageFlags = C.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
	BufferUsageIndirectBuffer     BufferUsageFlags = C.VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT

	SharingModeExclusive  SharingMode = C.VK_SHARING_MODE_EXCLUSIVE
	SharingModeConcurrent SharingMode = C.VK_SHARING_MODE_CONCURRENT
)
View Source 
const (
	CommandBufferUsageOneTimeSubmit      CommandBufferUsageFlags = C.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
	CommandBufferUsageRenderPassContinue CommandBufferUsageFlags = C.VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
	CommandBufferUsageSimultaneousUse    CommandBufferUsageFlags = C.VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT

	QueryPrecise QueryControlFlags = C.VK_QUERY_CONTROL_PRECISE_BIT

	QueryPipelineStatisticInputAssemblyVertices                   QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT
	QueryPipelineStatisticInputAssemblyPrimitives                 QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT
	QueryPipelineStatisticVertexShaderInvocations                 QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT
	QueryPipelineStatisticGeometryShaderInvocations               QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT
	QueryPipelineStatisticGeometryShaderPrimitives                QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT
	QueryPipelineStatisticClippingInvocations                     QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT
	QueryPipelineStatisticClippingPrimitives                      QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT
	QueryPipelineStatisticFragmentShaderInvocations               QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT
	QueryPipelineStatisticTessellationControlShaderPatches        QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT
	QueryPipelineStatisticTessellationEvaluationShaderInvocations QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT
	QueryPipelineStatisticComputeShaderInvocations                QueryPipelineStatisticFlags = C.VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
)
View Source 
const (
	CommandBufferResetReleaseResources CommandBufferResetFlags = C.VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT

	CommandBufferLevelPrimary   CommandBufferLevel = C.VK_COMMAND_BUFFER_LEVEL_PRIMARY
	CommandBufferLevelSecondary CommandBufferLevel = C.VK_COMMAND_BUFFER_LEVEL_SECONDARY

	IndexTypeUInt16 IndexType = C.VK_INDEX_TYPE_UINT16
	IndexTypeUInt32 IndexType = C.VK_INDEX_TYPE_UINT32

	StencilFaceFront StencilFaceFlags = C.VK_STENCIL_FACE_FRONT_BIT
	StencilFaceBack  StencilFaceFlags = C.VK_STENCIL_FACE_BACK_BIT
)
View Source 
const (
	CommandPoolResetReleaseResources CommandPoolResetFlags = C.VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT

	CommandPoolCreateTransient   CommandPoolCreateFlags = C.VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
	CommandPoolCreateResetBuffer CommandPoolCreateFlags = C.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
)
View Source 
const (
	SparseImageFormatSingleMipTail        SparseImageFormatFlags = C.VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT
	SparseImageFormatAlignedMipSize       SparseImageFormatFlags = C.VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT
	SparseImageFormatNonstandardBlockSize SparseImageFormatFlags = C.VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT

	ImageAspectColor    ImageAspectFlags = C.VK_IMAGE_ASPECT_COLOR_BIT
	ImageAspectDepth    ImageAspectFlags = C.VK_IMAGE_ASPECT_DEPTH_BIT
	ImageAspectStencil  ImageAspectFlags = C.VK_IMAGE_ASPECT_STENCIL_BIT
	ImageAspectMetadata ImageAspectFlags = C.VK_IMAGE_ASPECT_METADATA_BIT
)
View Source 
const (
	ImageCreateSparseBinding   ImageCreateFlags = C.VK_IMAGE_CREATE_SPARSE_BINDING_BIT
	ImageCreateSparseResidency ImageCreateFlags = C.VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
	ImageCreateSparseAliased   ImageCreateFlags = C.VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
	ImageCreateMutableFormat   ImageCreateFlags = C.VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
	ImageCreateCubeCompatible  ImageCreateFlags = C.VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT

	ImageLayoutUndefined                     ImageLayout = C.VK_IMAGE_LAYOUT_UNDEFINED
	ImageLayoutGeneral                       ImageLayout = C.VK_IMAGE_LAYOUT_GENERAL
	ImageLayoutColorAttachmentOptimal        ImageLayout = C.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
	ImageLayoutDepthStencilAttachmentOptimal ImageLayout = C.VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
	ImageLayoutDepthStencilReadOnlyOptimal   ImageLayout = C.VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
	ImageLayoutShaderReadOnlyOptimal         ImageLayout = C.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
	ImageLayoutTransferSrcOptimal            ImageLayout = C.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
	ImageLayoutTransferDstOptimal            ImageLayout = C.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
	ImageLayoutPreInitialized                ImageLayout = C.VK_IMAGE_LAYOUT_PREINITIALIZED

	ImageTilingOptimal ImageTiling = C.VK_IMAGE_TILING_OPTIMAL
	ImageTilingLinear  ImageTiling = C.VK_IMAGE_TILING_LINEAR

	ImageType1D ImageType = C.VK_IMAGE_TYPE_1D
	ImageType2D ImageType = C.VK_IMAGE_TYPE_2D
	ImageType3D ImageType = C.VK_IMAGE_TYPE_3D

	ImageUsageTransferSrc            ImageUsageFlags = C.VK_IMAGE_USAGE_TRANSFER_SRC_BIT
	ImageUsageTransferDst            ImageUsageFlags = C.VK_IMAGE_USAGE_TRANSFER_DST_BIT
	ImageUsageSampled                ImageUsageFlags = C.VK_IMAGE_USAGE_SAMPLED_BIT
	ImageUsageStorage                ImageUsageFlags = C.VK_IMAGE_USAGE_STORAGE_BIT
	ImageUsageColorAttachment        ImageUsageFlags = C.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
	ImageUsageDepthStencilAttachment ImageUsageFlags = C.VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
	ImageUsageTransientAttachment    ImageUsageFlags = C.VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
	ImageUsageInputAttachment        ImageUsageFlags = C.VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT

	Samples1  SampleCountFlags = C.VK_SAMPLE_COUNT_1_BIT
	Samples2  SampleCountFlags = C.VK_SAMPLE_COUNT_2_BIT
	Samples4  SampleCountFlags = C.VK_SAMPLE_COUNT_4_BIT
	Samples8  SampleCountFlags = C.VK_SAMPLE_COUNT_8_BIT
	Samples16 SampleCountFlags = C.VK_SAMPLE_COUNT_16_BIT
	Samples32 SampleCountFlags = C.VK_SAMPLE_COUNT_32_BIT
	Samples64 SampleCountFlags = C.VK_SAMPLE_COUNT_64_BIT
)
View Source 
const (
	ComponentSwizzleIdentity ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_IDENTITY
	ComponentSwizzleZero     ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_ZERO
	ComponentSwizzleOne      ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_ONE
	ComponentSwizzleRed      ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_R
	ComponentSwizzleGreen    ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_G
	ComponentSwizzleBlue     ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_B
	ComponentSwizzleAlpha    ComponentSwizzle = C.VK_COMPONENT_SWIZZLE_A

	ImageViewType1D        ImageViewType = C.VK_IMAGE_VIEW_TYPE_1D
	ImageViewType2D        ImageViewType = C.VK_IMAGE_VIEW_TYPE_2D
	ImageViewType3D        ImageViewType = C.VK_IMAGE_VIEW_TYPE_3D
	ImageViewTypeCube      ImageViewType = C.VK_IMAGE_VIEW_TYPE_CUBE
	ImageViewType1DArray   ImageViewType = C.VK_IMAGE_VIEW_TYPE_1D_ARRAY
	ImageViewType2DArray   ImageViewType = C.VK_IMAGE_VIEW_TYPE_2D_ARRAY
	ImageViewTypeCubeArray ImageViewType = C.VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
)
View Source 
const (
	QueueGraphics      QueueFlags = C.VK_QUEUE_GRAPHICS_BIT
	QueueCompute       QueueFlags = C.VK_QUEUE_COMPUTE_BIT
	QueueTransfer      QueueFlags = C.VK_QUEUE_TRANSFER_BIT
	QueueSparseBinding QueueFlags = C.VK_QUEUE_SPARSE_BINDING_BIT

	MemoryPropertyDeviceLocal     MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
	MemoryPropertyHostVisible     MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
	MemoryPropertyHostCoherent    MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
	MemoryPropertyLazilyAllocated MemoryPropertyFlags = C.VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT

	MemoryHeapDeviceLocal MemoryHeapFlags = C.VK_MEMORY_HEAP_DEVICE_LOCAL_BIT

	PhysicalDeviceTypeOther         PhysicalDeviceType = C.VK_PHYSICAL_DEVICE_TYPE_OTHER
	PhysicalDeviceTypeIntegratedGPU PhysicalDeviceType = C.VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU
	PhysicalDeviceTypeDiscreteGPU   PhysicalDeviceType = C.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
	PhysicalDeviceTypeVirtualGPU    PhysicalDeviceType = C.VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU
	PhysicalDeviceTypeCPU           PhysicalDeviceType = C.VK_PHYSICAL_DEVICE_TYPE_CPU
)
View Source 
const (
	QueryTypeOcclusion          QueryType = C.VK_QUERY_TYPE_OCCLUSION
	QueryTypePipelineStatistics QueryType = C.VK_QUERY_TYPE_PIPELINE_STATISTICS
	QueryTypeTimestamp          QueryType = C.VK_QUERY_TYPE_TIMESTAMP

	QueryResult64Bit            QueryResultFlags = C.VK_QUERY_RESULT_64_BIT
	QueryResultWait             QueryResultFlags = C.VK_QUERY_RESULT_WAIT_BIT
	QueryResultWithAvailability QueryResultFlags = C.VK_QUERY_RESULT_WITH_AVAILABILITY_BIT
	QueryResultPartial          QueryResultFlags = C.VK_QUERY_RESULT_PARTIAL_BIT
)
View Source 
const (
	AttachmentDescriptionMayAlias AttachmentDescriptionFlags = C.VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT

	AttachmentLoadOpLoad     AttachmentLoadOp = C.VK_ATTACHMENT_LOAD_OP_LOAD
	AttachmentLoadOpClear    AttachmentLoadOp = C.VK_ATTACHMENT_LOAD_OP_CLEAR
	AttachmentLoadOpDontCare AttachmentLoadOp = C.VK_ATTACHMENT_LOAD_OP_DONT_CARE

	AttachmentStoreOpStore    AttachmentStoreOp = C.VK_ATTACHMENT_STORE_OP_STORE
	AttachmentStoreOpDontCare AttachmentStoreOp = C.VK_ATTACHMENT_STORE_OP_DONT_CARE

	DependencyByRegion DependencyFlags = C.VK_DEPENDENCY_BY_REGION_BIT

	PipelineBindPointGraphics PipelineBindPoint = C.VK_PIPELINE_BIND_POINT_GRAPHICS
	PipelineBindPointCompute  PipelineBindPoint = C.VK_PIPELINE_BIND_POINT_COMPUTE

	SubpassExternal = int(C.VK_SUBPASS_EXTERNAL)
)
View Source 
const (
	BorderColorFloatTransparentBlack BorderColor = C.VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK
	BorderColorIntTransparentBlack   BorderColor = C.VK_BORDER_COLOR_INT_TRANSPARENT_BLACK
	BorderColorFloatOpaqueBlack      BorderColor = C.VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK
	BorderColorIntOpaqueBlack        BorderColor = C.VK_BORDER_COLOR_INT_OPAQUE_BLACK
	BorderColorFloatOpaqueWhite      BorderColor = C.VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE
	BorderColorIntOpaqueWhite        BorderColor = C.VK_BORDER_COLOR_INT_OPAQUE_WHITE

	CompareOpNever          CompareOp = C.VK_COMPARE_OP_NEVER
	CompareOpLess           CompareOp = C.VK_COMPARE_OP_LESS
	CompareOpEqual          CompareOp = C.VK_COMPARE_OP_EQUAL
	CompareOpLessOrEqual    CompareOp = C.VK_COMPARE_OP_LESS_OR_EQUAL
	CompareOpGreater        CompareOp = C.VK_COMPARE_OP_GREATER
	CompareOpNotEqual       CompareOp = C.VK_COMPARE_OP_NOT_EQUAL
	CompareOpGreaterOrEqual CompareOp = C.VK_COMPARE_OP_GREATER_OR_EQUAL
	CompareOpAlways         CompareOp = C.VK_COMPARE_OP_ALWAYS

	FilterNearest Filter = C.VK_FILTER_NEAREST
	FilterLinear  Filter = C.VK_FILTER_LINEAR

	SamplerMipmapModeNearest SamplerMipmapMode = C.VK_SAMPLER_MIPMAP_MODE_NEAREST
	SamplerMipmapModeLinear  SamplerMipmapMode = C.VK_SAMPLER_MIPMAP_MODE_LINEAR

	SamplerAddressModeRepeat         SamplerAddressMode = C.VK_SAMPLER_ADDRESS_MODE_REPEAT
	SamplerAddressModeMirroredRepeat SamplerAddressMode = C.VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT
	SamplerAddressModeClampToEdge    SamplerAddressMode = C.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE
	SamplerAddressModeClampToBorder  SamplerAddressMode = C.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER
)
View Source 
const (
	BlendFactorZero                  BlendFactor = C.VK_BLEND_FACTOR_ZERO
	BlendFactorOne                   BlendFactor = C.VK_BLEND_FACTOR_ONE
	BlendFactorSrcColor              BlendFactor = C.VK_BLEND_FACTOR_SRC_COLOR
	BlendFactorOneMinusSrcColor      BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR
	BlendFactorDstColor              BlendFactor = C.VK_BLEND_FACTOR_DST_COLOR
	BlendFactorOneMinusDstColor      BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR
	BlendFactorSrcAlpha              BlendFactor = C.VK_BLEND_FACTOR_SRC_ALPHA
	BlendFactorOneMinusSrcAlpha      BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
	BlendFactorDstAlpha              BlendFactor = C.VK_BLEND_FACTOR_DST_ALPHA
	BlendFactorOneMinusDstAlpha      BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA
	BlendFactorConstantColor         BlendFactor = C.VK_BLEND_FACTOR_CONSTANT_COLOR
	BlendFactorOneMinusConstantColor BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR
	BlendFactorConstantAlpha         BlendFactor = C.VK_BLEND_FACTOR_CONSTANT_ALPHA
	BlendFactorOneMinusConstantAlpha BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
	BlendFactorSrcAlphaSaturate      BlendFactor = C.VK_BLEND_FACTOR_SRC_ALPHA_SATURATE
	BlendFactorSrc1Color             BlendFactor = C.VK_BLEND_FACTOR_SRC1_COLOR
	BlendFactorOneMinusSrc1Color     BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR
	BlendFactorSrc1Alpha             BlendFactor = C.VK_BLEND_FACTOR_SRC1_ALPHA
	BlendFactorOneMinusSrc1Alpha     BlendFactor = C.VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA

	BlendOpAdd      BlendOp = C.VK_BLEND_OP_ADD
	BlendOpSubtract BlendOp = C.VK_BLEND_OP_SUBTRACT
	BlendOpMin      BlendOp = C.VK_BLEND_OP_MIN
	BlendOpMax      BlendOp = C.VK_BLEND_OP_MAX

	LogicOpClear        LogicOp = C.VK_LOGIC_OP_CLEAR
	LogicOpAnd          LogicOp = C.VK_LOGIC_OP_AND
	LogicOpAndReverse   LogicOp = C.VK_LOGIC_OP_AND_REVERSE
	LogicOpCopy         LogicOp = C.VK_LOGIC_OP_COPY
	LogicOpAndInverted  LogicOp = C.VK_LOGIC_OP_AND_INVERTED
	LogicOpNoop         LogicOp = C.VK_LOGIC_OP_NO_OP
	LogicOpXor          LogicOp = C.VK_LOGIC_OP_XOR
	LogicOpOr           LogicOp = C.VK_LOGIC_OP_OR
	LogicOpNor          LogicOp = C.VK_LOGIC_OP_NOR
	LogicOpEquivalent   LogicOp = C.VK_LOGIC_OP_EQUIVALENT
	LogicOpInvert       LogicOp = C.VK_LOGIC_OP_INVERT
	LogicOpOrReverse    LogicOp = C.VK_LOGIC_OP_OR_REVERSE
	LogicOpCopyInverted LogicOp = C.VK_LOGIC_OP_COPY_INVERTED
	LogicOpOrInverted   LogicOp = C.VK_LOGIC_OP_OR_INVERTED
	LogicOpNand         LogicOp = C.VK_LOGIC_OP_NAND
	LogicOpSet          LogicOp = C.VK_LOGIC_OP_SET
)
View Source 
const (
	PolygonModeFill  PolygonMode = C.VK_POLYGON_MODE_FILL
	PolygonModeLine  PolygonMode = C.VK_POLYGON_MODE_LINE
	PolygonModePoint PolygonMode = C.VK_POLYGON_MODE_POINT

	CullModeFront CullModeFlags = C.VK_CULL_MODE_FRONT_BIT
	CullModeBack  CullModeFlags = C.VK_CULL_MODE_BACK_BIT

	FrontFaceCounterClockwise FrontFace = C.VK_FRONT_FACE_COUNTER_CLOCKWISE
	FrontFaceClockwise        FrontFace = C.VK_FRONT_FACE_CLOCKWISE
)
View Source 
const (
	VKSuccess                   common.VkResult = C.VK_SUCCESS
	VKNotReady                  common.VkResult = C.VK_NOT_READY
	VKTimeout                   common.VkResult = C.VK_TIMEOUT
	VKEventSet                  common.VkResult = C.VK_EVENT_SET
	VKEventReset                common.VkResult = C.VK_EVENT_RESET
	VKIncomplete                common.VkResult = C.VK_INCOMPLETE
	VKErrorOutOfHostMemory      common.VkResult = C.VK_ERROR_OUT_OF_HOST_MEMORY
	VKErrorOutOfDeviceMemory    common.VkResult = C.VK_ERROR_OUT_OF_DEVICE_MEMORY
	VKErrorInitializationFailed common.VkResult = C.VK_ERROR_INITIALIZATION_FAILED
	VKErrorDeviceLost           common.VkResult = C.VK_ERROR_DEVICE_LOST
	VKErrorMemoryMapFailed      common.VkResult = C.VK_ERROR_MEMORY_MAP_FAILED
	VKErrorLayerNotPresent      common.VkResult = C.VK_ERROR_LAYER_NOT_PRESENT
	VKErrorExtensionNotPresent  common.VkResult = C.VK_ERROR_EXTENSION_NOT_PRESENT
	VKErrorFeatureNotPresent    common.VkResult = C.VK_ERROR_FEATURE_NOT_PRESENT
	VKErrorIncompatibleDriver   common.VkResult = C.VK_ERROR_INCOMPATIBLE_DRIVER
	VKErrorTooManyObjects       common.VkResult = C.VK_ERROR_TOO_MANY_OBJECTS
	VKErrorFormatNotSupported   common.VkResult = C.VK_ERROR_FORMAT_NOT_SUPPORTED
	VKErrorFragmentedPool       common.VkResult = C.VK_ERROR_FRAGMENTED_POOL
	VKErrorUnknown              common.VkResult = C.VK_ERROR_UNKNOWN
)
View Source 
const AttachmentUnused int = -1

Variables

View Source 
var FormatMapping = make(map[Format]string)

Functions

This section is empty.

Types

type AccessFlags 

type AccessFlags int32
const (
	AccessIndirectCommandRead         AccessFlags = C.VK_ACCESS_INDIRECT_COMMAND_READ_BIT
	AccessIndexRead                   AccessFlags = C.VK_ACCESS_INDEX_READ_BIT
	AccessVertexAttributeRead         AccessFlags = C.VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
	AccessUniformRead                 AccessFlags = C.VK_ACCESS_UNIFORM_READ_BIT
	AccessInputAttachmentRead         AccessFlags = C.VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
	AccessShaderRead                  AccessFlags = C.VK_ACCESS_SHADER_READ_BIT
	AccessShaderWrite                 AccessFlags = C.VK_ACCESS_SHADER_WRITE_BIT
	AccessColorAttachmentRead         AccessFlags = C.VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
	AccessColorAttachmentWrite        AccessFlags = C.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
	AccessDepthStencilAttachmentRead  AccessFlags = C.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT
	AccessDepthStencilAttachmentWrite AccessFlags = C.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
	AccessTransferRead                AccessFlags = C.VK_ACCESS_TRANSFER_READ_BIT
	AccessTransferWrite               AccessFlags = C.VK_ACCESS_TRANSFER_WRITE_BIT
	AccessHostRead                    AccessFlags = C.VK_ACCESS_HOST_READ_BIT
	AccessHostWrite                   AccessFlags = C.VK_ACCESS_HOST_WRITE_BIT
	AccessMemoryRead                  AccessFlags = C.VK_ACCESS_MEMORY_READ_BIT
	AccessMemoryWrite                 AccessFlags = C.VK_ACCESS_MEMORY_WRITE_BIT
)

func (AccessFlags) Register 

func (f AccessFlags) Register(str string)

func (AccessFlags) String 

func (f AccessFlags) String() string

type AttachmentDescription 

type AttachmentDescription struct {
	Flags   AttachmentDescriptionFlags
	Format  Format
	Samples SampleCountFlags

	LoadOp         AttachmentLoadOp
	StoreOp        AttachmentStoreOp
	StencilLoadOp  AttachmentLoadOp
	StencilStoreOp AttachmentStoreOp

	InitialLayout ImageLayout
	FinalLayout   ImageLayout
}

type AttachmentDescriptionFlags 

type AttachmentDescriptionFlags int32

func (AttachmentDescriptionFlags) Register 

func (f AttachmentDescriptionFlags) Register(str string)

func (AttachmentDescriptionFlags) String 

func (f AttachmentDescriptionFlags) String() string

type AttachmentLoadOp 

type AttachmentLoadOp int32

func (AttachmentLoadOp) Register 

func (e AttachmentLoadOp) Register(str string)

func (AttachmentLoadOp) String 

func (e AttachmentLoadOp) String() string

type AttachmentReference 

type AttachmentReference struct {
	Attachment int
	Layout     ImageLayout
}

type AttachmentStoreOp 

type AttachmentStoreOp int32

func (AttachmentStoreOp) Register 

func (e AttachmentStoreOp) Register(str string)

func (AttachmentStoreOp) String 

func (e AttachmentStoreOp) String() string

type BindSparseOptions 

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

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

	common.NextOptions
}

func (BindSparseOptions) PopulateCPointer 

func (b BindSparseOptions) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type BlendFactor 

type BlendFactor int32

func (BlendFactor) Register 

func (e BlendFactor) Register(str string)

func (BlendFactor) String 

func (e BlendFactor) String() string

type BlendOp 

type BlendOp int32

func (BlendOp) Register 

func (e BlendOp) Register(str string)

func (BlendOp) String 

func (e BlendOp) String() string

type BorderColor 

type BorderColor int32

func (BorderColor) Register 

func (e BorderColor) Register(str string)

func (BorderColor) String 

func (e BorderColor) String() string

type Buffer 

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 

type BufferCopy struct {
	SrcOffset int
	DstOffset int
	Size      int
}

func (BufferCopy) PopulateCPointer 

func (c BufferCopy) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type BufferCreateFlags 

type BufferCreateFlags int32

func (BufferCreateFlags) Register 

func (f BufferCreateFlags) Register(str string)

func (BufferCreateFlags) String 

func (f BufferCreateFlags) String() string

type BufferCreateInfo 

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

	common.NextOptions
}

func (BufferCreateInfo) PopulateCPointer 

func (o BufferCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type BufferImageCopy 

type BufferImageCopy struct {
	BufferOffset      int
	BufferRowLength   int
	BufferImageHeight int

	ImageSubresource ImageSubresourceLayers
	ImageOffset      Offset3D
	ImageExtent      Extent3D
}

func (BufferImageCopy) PopulateCPointer 

func (c BufferImageCopy) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type BufferMemoryBarrier 

type BufferMemoryBarrier struct {
	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags

	SrcQueueFamilyIndex int
	DstQueueFamilyIndex int

	Buffer Buffer

	Offset int
	Size   int

	common.NextOptions
}

func (BufferMemoryBarrier) PopulateCPointer 

func (o BufferMemoryBarrier) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type BufferUsageFlags 

type BufferUsageFlags int32

func (BufferUsageFlags) Register 

func (f BufferUsageFlags) Register(str string)

func (BufferUsageFlags) String 

func (f BufferUsageFlags) String() string

type BufferView 

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

	Destroy(callbacks *driver.AllocationCallbacks)
}

type BufferViewCreateFlags 

type BufferViewCreateFlags int32

func (BufferViewCreateFlags) Register 

func (f BufferViewCreateFlags) Register(str string)

func (BufferViewCreateFlags) String 

func (f BufferViewCreateFlags) String() string

type BufferViewCreateInfo 

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

	common.NextOptions
}

func (BufferViewCreateInfo) PopulateCPointer 

func (o BufferViewCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ClearAttachment 

type ClearAttachment struct {
	AspectMask      ImageAspectFlags
	ColorAttachment int
	ClearValue      ClearValue
}

func (ClearAttachment) PopulateCPointer 

func (c ClearAttachment) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type ClearColorValue 

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

type ClearRect 

type ClearRect struct {
	Rect           Rect2D
	BaseArrayLayer int
	LayerCount     int
}

func (ClearRect) PopulateCPointer 

func (r ClearRect) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type ClearValue 

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

type ClearValueDepthStencil 

type ClearValueDepthStencil struct {
	Depth   float32
	Stencil uint32
}

func (ClearValueDepthStencil) PopulateValueUnion 

func (s ClearValueDepthStencil) PopulateValueUnion(c unsafe.Pointer)

type ClearValueFloat 

type ClearValueFloat [4]float32

func (ClearValueFloat) PopulateColorUnion 

func (v ClearValueFloat) PopulateColorUnion(c unsafe.Pointer)

func (ClearValueFloat) PopulateValueUnion 

func (v ClearValueFloat) PopulateValueUnion(c unsafe.Pointer)

type ClearValueInt32 

type ClearValueInt32 [4]int32

func (ClearValueInt32) PopulateColorUnion 

func (v ClearValueInt32) PopulateColorUnion(c unsafe.Pointer)

func (ClearValueInt32) PopulateValueUnion 

func (v ClearValueInt32) PopulateValueUnion(c unsafe.Pointer)

type ClearValueUint32 

type ClearValueUint32 [4]uint32

func (ClearValueUint32) PopulateColorUnion 

func (v ClearValueUint32) PopulateColorUnion(c unsafe.Pointer)

func (ClearValueUint32) PopulateValueUnion 

func (v ClearValueUint32) PopulateValueUnion(c unsafe.Pointer)

type ColorComponentFlags 

type ColorComponentFlags int32
const (
	ColorComponentRed   ColorComponentFlags = C.VK_COLOR_COMPONENT_R_BIT
	ColorComponentGreen ColorComponentFlags = C.VK_COLOR_COMPONENT_G_BIT
	ColorComponentBlue  ColorComponentFlags = C.VK_COLOR_COMPONENT_B_BIT
	ColorComponentAlpha ColorComponentFlags = C.VK_COLOR_COMPONENT_A_BIT
)

func (ColorComponentFlags) String 

func (c ColorComponentFlags) String() string

type ColorSpace 

type ColorSpace int32

func (ColorSpace) Register 

func (e ColorSpace) Register(str string)

func (ColorSpace) String 

func (e ColorSpace) String() string

type CommandBuffer 

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 

type CommandBufferAllocateInfo struct {
	Level              CommandBufferLevel
	CommandBufferCount int
	CommandPool        CommandPool

	common.NextOptions
}

func (CommandBufferAllocateInfo) PopulateCPointer 

func (o CommandBufferAllocateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type CommandBufferBeginInfo 

type CommandBufferBeginInfo struct {
	Flags           CommandBufferUsageFlags
	InheritanceInfo *CommandBufferInheritanceInfo

	common.NextOptions
}

func (CommandBufferBeginInfo) PopulateCPointer 

func (o CommandBufferBeginInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type CommandBufferInheritanceInfo 

type CommandBufferInheritanceInfo struct {
	Framebuffer Framebuffer
	RenderPass  RenderPass
	Subpass     int

	OcclusionQueryEnable bool
	QueryFlags           QueryControlFlags
	PipelineStatistics   QueryPipelineStatisticFlags

	common.NextOptions
}

func (CommandBufferInheritanceInfo) PopulateCPointer 

func (o CommandBufferInheritanceInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type CommandBufferLevel 

type CommandBufferLevel int32

func (CommandBufferLevel) Register 

func (e CommandBufferLevel) Register(str string)

func (CommandBufferLevel) String 

func (e CommandBufferLevel) String() string

type CommandBufferResetFlags 

type CommandBufferResetFlags int32

func (CommandBufferResetFlags) Register 

func (f CommandBufferResetFlags) Register(str string)

func (CommandBufferResetFlags) String 

func (f CommandBufferResetFlags) String() string

type CommandBufferUsageFlags 

type CommandBufferUsageFlags int32

func (CommandBufferUsageFlags) Register 

func (f CommandBufferUsageFlags) Register(str string)

func (CommandBufferUsageFlags) String 

func (f CommandBufferUsageFlags) String() string

type CommandCounter 

type CommandCounter struct {
	CommandCount  int
	DrawCallCount int
	DispatchCount int
}

type CommandPool 

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 

type CommandPoolCreateFlags int32

func (CommandPoolCreateFlags) Register 

func (f CommandPoolCreateFlags) Register(str string)

func (CommandPoolCreateFlags) String 

func (f CommandPoolCreateFlags) String() string

type CommandPoolCreateInfo 

type CommandPoolCreateInfo struct {
	QueueFamilyIndex *int
	Flags            CommandPoolCreateFlags

	common.NextOptions
}

func (CommandPoolCreateInfo) PopulateCPointer 

func (o CommandPoolCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type CommandPoolResetFlags 

type CommandPoolResetFlags int32

func (CommandPoolResetFlags) Register 

func (f CommandPoolResetFlags) Register(str string)

func (CommandPoolResetFlags) String 

func (f CommandPoolResetFlags) String() string

type CompareOp 

type CompareOp int32

func (CompareOp) Register 

func (e CompareOp) Register(str string)

func (CompareOp) String 

func (e CompareOp) String() string

type ComponentMapping 

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

type ComponentSwizzle 

type ComponentSwizzle int32

func (ComponentSwizzle) Register 

func (e ComponentSwizzle) Register(str string)

func (ComponentSwizzle) String 

func (e ComponentSwizzle) String() string

type CompositeAlphaFlags 

type CompositeAlphaFlags int32

func (CompositeAlphaFlags) Register 

func (f CompositeAlphaFlags) Register(str string)

func (CompositeAlphaFlags) String 

func (f CompositeAlphaFlags) String() string

type ComputePipelineCreateInfo 

type ComputePipelineCreateInfo struct {
	Flags  PipelineCreateFlags
	Stage  PipelineShaderStageCreateInfo
	Layout PipelineLayout

	BasePipeline      Pipeline
	BasePipelineIndex int

	common.NextOptions
}

func (ComputePipelineCreateInfo) PopulateCPointer 

func (o ComputePipelineCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type CopyDescriptorSet 

type CopyDescriptorSet struct {
	SrcSet          DescriptorSet
	SrcBinding      int
	SrcArrayElement int

	DstSet          DescriptorSet
	DstBinding      int
	DstArrayElement int

	DescriptorCount int

	common.NextOptions
}

func (CopyDescriptorSet) PopulateCPointer 

func (o CopyDescriptorSet) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type CullModeFlags 

type CullModeFlags int32

func (CullModeFlags) Register 

func (f CullModeFlags) Register(str string)

func (CullModeFlags) String 

func (f CullModeFlags) String() string

type DependencyFlags 

type DependencyFlags int32

func (DependencyFlags) Register 

func (f DependencyFlags) Register(str string)

func (DependencyFlags) String 

func (f DependencyFlags) String() string

type DescriptorBufferInfo 

type DescriptorBufferInfo struct {
	Buffer Buffer
	Offset int
	Range  int
}

type DescriptorImageInfo 

type DescriptorImageInfo struct {
	Sampler     Sampler
	ImageView   ImageView
	ImageLayout ImageLayout
}

type DescriptorPool 

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 

type DescriptorPoolCreateFlags int32
const (
	DescriptorPoolCreateFreeDescriptorSet DescriptorPoolCreateFlags = C.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
)

func (DescriptorPoolCreateFlags) Register 

func (f DescriptorPoolCreateFlags) Register(str string)

func (DescriptorPoolCreateFlags) String 

func (f DescriptorPoolCreateFlags) String() string

type DescriptorPoolCreateInfo 

type DescriptorPoolCreateInfo struct {
	Flags DescriptorPoolCreateFlags

	MaxSets   int
	PoolSizes []DescriptorPoolSize

	common.NextOptions
}

func (DescriptorPoolCreateInfo) PopulateCPointer 

func (o DescriptorPoolCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type DescriptorPoolResetFlags 

type DescriptorPoolResetFlags int32

func (DescriptorPoolResetFlags) Register 

func (f DescriptorPoolResetFlags) Register(str string)

func (DescriptorPoolResetFlags) String 

func (f DescriptorPoolResetFlags) String() string

type DescriptorPoolSize 

type DescriptorPoolSize struct {
	Type            DescriptorType
	DescriptorCount int
}

type DescriptorSet 

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

	Free() (common.VkResult, error)
}

type DescriptorSetAllocateInfo 

type DescriptorSetAllocateInfo struct {
	DescriptorPool DescriptorPool

	SetLayouts []DescriptorSetLayout

	common.NextOptions
}

func (DescriptorSetAllocateInfo) PopulateCPointer 

func (o DescriptorSetAllocateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type DescriptorSetLayout 

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

	Destroy(callbacks *driver.AllocationCallbacks)
}

type DescriptorSetLayoutBinding 

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

	ImmutableSamplers []Sampler
}

type DescriptorSetLayoutCreateFlags 

type DescriptorSetLayoutCreateFlags int32

func (DescriptorSetLayoutCreateFlags) Register 

func (f DescriptorSetLayoutCreateFlags) Register(str string)

func (DescriptorSetLayoutCreateFlags) String 

func (f DescriptorSetLayoutCreateFlags) String() string

type DescriptorSetLayoutCreateInfo 

type DescriptorSetLayoutCreateInfo struct {
	Flags    DescriptorSetLayoutCreateFlags
	Bindings []DescriptorSetLayoutBinding

	common.NextOptions
}

func (DescriptorSetLayoutCreateInfo) PopulateCPointer 

func (o DescriptorSetLayoutCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type DescriptorType 

type DescriptorType int32
const (
	DescriptorTypeSampler              DescriptorType = C.VK_DESCRIPTOR_TYPE_SAMPLER
	DescriptorTypeCombinedImageSampler DescriptorType = C.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
	DescriptorTypeSampledImage         DescriptorType = C.VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
	DescriptorTypeStorageImage         DescriptorType = C.VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
	DescriptorTypeUniformTexelBuffer   DescriptorType = C.VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
	DescriptorTypeStorageTexelBuffer   DescriptorType = C.VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
	DescriptorTypeUniformBuffer        DescriptorType = C.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
	DescriptorTypeStorageBuffer        DescriptorType = C.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
	DescriptorTypeUniformBufferDynamic DescriptorType = C.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
	DescriptorTypeStorageBufferDynamic DescriptorType = C.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
	DescriptorTypeInputAttachment      DescriptorType = C.VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
)

func (DescriptorType) Register 

func (e DescriptorType) Register(str string)

func (DescriptorType) String 

func (e DescriptorType) String() string

type Device 

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 

type DeviceCreateFlags int32

func (DeviceCreateFlags) Register 

func (f DeviceCreateFlags) Register(str string)

func (DeviceCreateFlags) String 

func (f DeviceCreateFlags) String() string

type DeviceCreateInfo 

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

	common.NextOptions
}

func (DeviceCreateInfo) PopulateCPointer 

func (o DeviceCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type DeviceMemory 

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 

type DeviceQueueCreateFlags int32

func (DeviceQueueCreateFlags) Register 

func (f DeviceQueueCreateFlags) Register(str string)

func (DeviceQueueCreateFlags) String 

func (f DeviceQueueCreateFlags) String() string

type DeviceQueueCreateInfo 

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

	common.NextOptions
}

func (DeviceQueueCreateInfo) PopulateCPointer 

func (o DeviceQueueCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type DynamicState 

type DynamicState int32
const (
	DynamicStateViewport           DynamicState = C.VK_DYNAMIC_STATE_VIEWPORT
	DynamicStateScissor            DynamicState = C.VK_DYNAMIC_STATE_SCISSOR
	DynamicStateLineWidth          DynamicState = C.VK_DYNAMIC_STATE_LINE_WIDTH
	DynamicStateDepthBias          DynamicState = C.VK_DYNAMIC_STATE_DEPTH_BIAS
	DynamicStateBlendConstants     DynamicState = C.VK_DYNAMIC_STATE_BLEND_CONSTANTS
	DynamicStateDepthBounds        DynamicState = C.VK_DYNAMIC_STATE_DEPTH_BOUNDS
	DynamicStateStencilCompareMask DynamicState = C.VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK
	DynamicStateStencilWriteMask   DynamicState = C.VK_DYNAMIC_STATE_STENCIL_WRITE_MASK
	DynamicStateStencilReference   DynamicState = C.VK_DYNAMIC_STATE_STENCIL_REFERENCE
)

func (DynamicState) Register 

func (e DynamicState) Register(str string)

func (DynamicState) String 

func (e DynamicState) String() string

type Event 

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 

type EventCreateFlags int32

func (EventCreateFlags) Register 

func (f EventCreateFlags) Register(str string)

func (EventCreateFlags) String 

func (f EventCreateFlags) String() string

type EventCreateInfo 

type EventCreateInfo struct {
	Flags EventCreateFlags

	common.NextOptions
}

func (EventCreateInfo) PopulateCPointer 

func (o EventCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ExtensionProperties 

type ExtensionProperties struct {
	ExtensionName string
	SpecVersion   common.Version
}

type Extent2D 

type Extent2D struct {
	Width  int
	Height int
}

type Extent3D 

type Extent3D struct {
	Width  int
	Height int
	Depth  int
}

type Fence 

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 

type FenceCreateFlags int32
const (
	FenceCreateSignaled FenceCreateFlags = C.VK_FENCE_CREATE_SIGNALED_BIT
)

func (FenceCreateFlags) Register 

func (f FenceCreateFlags) Register(str string)

func (FenceCreateFlags) String 

func (f FenceCreateFlags) String() string

type FenceCreateInfo 

type FenceCreateInfo struct {
	Flags FenceCreateFlags

	common.NextOptions
}

func (FenceCreateInfo) PopulateCPointer 

func (o FenceCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type Filter 

type Filter int32

func (Filter) Register 

func (e Filter) Register(str string)

func (Filter) String 

func (e Filter) String() string

type Format 

type Format int32
const (
	FormatUndefined                    Format = C.VK_FORMAT_UNDEFINED
	FormatR4G4UnsignedNormalizedPacked Format = C.VK_FORMAT_R4G4_UNORM_PACK8

	FormatR4G4B4A4UnsignedNormalizedPacked Format = C.VK_FORMAT_R4G4B4A4_UNORM_PACK16
	FormatB4G4R4A4UnsignedNormalizedPacked Format = C.VK_FORMAT_B4G4R4A4_UNORM_PACK16
	FormatR5G6B5UnsignedNormalizedPacked   Format = C.VK_FORMAT_R5G6B5_UNORM_PACK16
	FormatB5G6R5UnsignedNormalizedPacked   Format = C.VK_FORMAT_B5G6R5_UNORM_PACK16
	FormatR5G5B5A1UnsignedNormalizedPacked Format = C.VK_FORMAT_R5G5B5A1_UNORM_PACK16
	FormatB5G5R5A1UnsignedNormalizedPacked Format = C.VK_FORMAT_B5G5R5A1_UNORM_PACK16
	FormatA1R5G5B5UnsignedNormalizedPacked Format = C.VK_FORMAT_A1R5G5B5_UNORM_PACK16

	FormatR8UnsignedNormalized Format = C.VK_FORMAT_R8_UNORM
	FormatR8SignedNormalized   Format = C.VK_FORMAT_R8_SNORM
	FormatR8UnsignedScaled     Format = C.VK_FORMAT_R8_USCALED
	FormatR8SignedScaled       Format = C.VK_FORMAT_R8_SSCALED
	FormatR8UnsignedInt        Format = C.VK_FORMAT_R8_UINT
	FormatR8SignedInt          Format = C.VK_FORMAT_R8_SINT
	FormatR8SRGB               Format = C.VK_FORMAT_R8_SRGB

	FormatR8G8UnsignedNormalized Format = C.VK_FORMAT_R8G8_UNORM
	FormatR8G8SignedNormalized   Format = C.VK_FORMAT_R8G8_SNORM
	FormatR8G8UnsignedScaled     Format = C.VK_FORMAT_R8G8_USCALED
	FormatR8G8SignedScaled       Format = C.VK_FORMAT_R8G8_SSCALED
	FormatR8G8UnsignedInt        Format = C.VK_FORMAT_R8G8_UINT
	FormatR8G8SignedInt          Format = C.VK_FORMAT_R8G8_SINT
	FormatR8G8SRGB               Format = C.VK_FORMAT_R8G8_SRGB

	FormatR8G8B8UnsignedNormalized Format = C.VK_FORMAT_R8G8B8_UNORM
	FormatR8G8B8SignedNormalized   Format = C.VK_FORMAT_R8G8B8_SNORM
	FormatR8G8B8UnsignedScaled     Format = C.VK_FORMAT_R8G8B8_USCALED
	FormatR8G8B8SignedScaled       Format = C.VK_FORMAT_R8G8B8_SSCALED
	FormatR8G8B8UnsignedInt        Format = C.VK_FORMAT_R8G8B8_UINT
	FormatR8G8B8SignedInt          Format = C.VK_FORMAT_R8G8B8_SINT
	FormatR8G8B8SRGB               Format = C.VK_FORMAT_R8G8B8_SRGB

	FormatB8G8R8UnsignedNormalized Format = C.VK_FORMAT_B8G8R8_UNORM
	FormatB8G8R8SignedNormalized   Format = C.VK_FORMAT_B8G8R8_SNORM
	FormatB8G8R8UnsignedScaled     Format = C.VK_FORMAT_B8G8R8_USCALED
	FormatB8G8R8SignedScaled       Format = C.VK_FORMAT_B8G8R8_SSCALED
	FormatB8G8R8UnsignedInt        Format = C.VK_FORMAT_B8G8R8_UINT
	FormatB8G8R8SignedInt          Format = C.VK_FORMAT_B8G8R8_SINT
	FormatB8G8R8SRGB               Format = C.VK_FORMAT_B8G8R8_SRGB

	FormatR8G8B8A8UnsignedNormalized Format = C.VK_FORMAT_R8G8B8A8_UNORM
	FormatR8G8B8A8SignedNormalized   Format = C.VK_FORMAT_R8G8B8A8_SNORM
	FormatR8G8B8A8UnsignedScaled     Format = C.VK_FORMAT_R8G8B8A8_USCALED
	FormatR8G8B8A8SignedScaled       Format = C.VK_FORMAT_R8G8B8A8_SSCALED
	FormatR8G8B8A8UnsignedInt        Format = C.VK_FORMAT_R8G8B8A8_UINT
	FormatR8G8B8A8SignedInt          Format = C.VK_FORMAT_R8G8B8A8_SINT
	FormatR8G8B8A8SRGB               Format = C.VK_FORMAT_R8G8B8A8_SRGB

	FormatB8G8R8A8UnsignedNormalized Format = C.VK_FORMAT_B8G8R8A8_UNORM
	FormatB8G8R8A8SignedNormalized   Format = C.VK_FORMAT_B8G8R8A8_SNORM
	FormatB8G8R8A8UnsignedScaled     Format = C.VK_FORMAT_B8G8R8A8_USCALED
	FormatB8G8R8A8SignedScaled       Format = C.VK_FORMAT_B8G8R8A8_SSCALED
	FormatB8G8R8A8UnsignedInt        Format = C.VK_FORMAT_B8G8R8A8_UINT
	FormatB8G8R8A8SignedInt          Format = C.VK_FORMAT_B8G8R8A8_SINT
	FormatB8G8R8A8SRGB               Format = C.VK_FORMAT_B8G8R8A8_SRGB

	FormatA8B8G8R8UnsignedNormalizedPacked Format = C.VK_FORMAT_A8B8G8R8_UNORM_PACK32
	FormatA8B8G8R8SignedNormalizedPacked   Format = C.VK_FORMAT_A8B8G8R8_SNORM_PACK32
	FormatA8B8G8R8UnsignedScaledPacked     Format = C.VK_FORMAT_A8B8G8R8_USCALED_PACK32
	FormatA8B8G8R8SignedScaledPacked       Format = C.VK_FORMAT_A8B8G8R8_SSCALED_PACK32
	FormatA8B8G8R8UnsignedIntPacked        Format = C.VK_FORMAT_A8B8G8R8_UINT_PACK32
	FormatA8B8G8R8SignedIntPacked          Format = C.VK_FORMAT_A8B8G8R8_SINT_PACK32
	FormatA8B8G8R8SRGBPacked               Format = C.VK_FORMAT_A8B8G8R8_SRGB_PACK32

	FormatA2R10G10B10UnsignedNormalizedPacked Format = C.VK_FORMAT_A2R10G10B10_UNORM_PACK32
	FormatA2R10G10B10SignedNormalizedPacked   Format = C.VK_FORMAT_A2R10G10B10_SNORM_PACK32
	FormatA2R10G10B10UnsignedScaledPacked     Format = C.VK_FORMAT_A2R10G10B10_USCALED_PACK32
	FormatA2R10G10B10SignedScaledPacked       Format = C.VK_FORMAT_A2R10G10B10_SSCALED_PACK32
	FormatA2R10G10B10UnsignedIntPacked        Format = C.VK_FORMAT_A2R10G10B10_UINT_PACK32
	FormatA2R10G10B10SignedIntPacked          Format = C.VK_FORMAT_A2R10G10B10_SINT_PACK32

	FormatA2B10G10R10UnsignedNormalizedPacked Format = C.VK_FORMAT_A2B10G10R10_UNORM_PACK32
	FormatA2B10G10R10SignedNormalizedPacked   Format = C.VK_FORMAT_A2B10G10R10_SNORM_PACK32
	FormatA2B10G10R10UnsignedScaledPacked     Format = C.VK_FORMAT_A2B10G10R10_USCALED_PACK32
	FormatA2B10G10R10SignedScaledPacked       Format = C.VK_FORMAT_A2B10G10R10_SSCALED_PACK32
	FormatA2B10G10R10UnsignedIntPacked        Format = C.VK_FORMAT_A2B10G10R10_UINT_PACK32
	FormatA2B10G10R10SignedIntPacked          Format = C.VK_FORMAT_A2B10G10R10_SINT_PACK32

	FormatR16UnsignedNormalized Format = C.VK_FORMAT_R16_UNORM
	FormatR16SignedNormalized   Format = C.VK_FORMAT_R16_SNORM
	FormatR16UnsignedScaled     Format = C.VK_FORMAT_R16_USCALED
	FormatR16SignedScaled       Format = C.VK_FORMAT_R16_SSCALED
	FormatR16UnsignedInt        Format = C.VK_FORMAT_R16_UINT
	FormatR16SignedInt          Format = C.VK_FORMAT_R16_SINT
	FormatR16SignedFloat        Format = C.VK_FORMAT_R16_SFLOAT

	FormatR16G16UnsignedNormalized Format = C.VK_FORMAT_R16G16_UNORM
	FormatR16G16SignedNormalized   Format = C.VK_FORMAT_R16G16_SNORM
	FormatR16G16UnsignedScaled     Format = C.VK_FORMAT_R16G16_USCALED
	FormatR16G16SignedScaled       Format = C.VK_FORMAT_R16G16_SSCALED
	FormatR16G16UnsignedInt        Format = C.VK_FORMAT_R16G16_UINT
	FormatR16G16SignedInt          Format = C.VK_FORMAT_R16G16_SINT
	FormatR16G16SignedFloat        Format = C.VK_FORMAT_R16G16_SFLOAT

	FormatR16G16B16UnsignedNormalized Format = C.VK_FORMAT_R16G16B16_UNORM
	FormatR16G16B16SignedNormalized   Format = C.VK_FORMAT_R16G16B16_SNORM
	FormatR16G16B16UnsignedScaled     Format = C.VK_FORMAT_R16G16B16_USCALED
	FormatR16G16B16SignedScaled       Format = C.VK_FORMAT_R16G16B16_SSCALED
	FormatR16G16B16UnsignedInt        Format = C.VK_FORMAT_R16G16B16_UINT
	FormatR16G16B16SignedInt          Format = C.VK_FORMAT_R16G16B16_SINT
	FormatR16G16B16SignedFloat        Format = C.VK_FORMAT_R16G16B16_SFLOAT

	FormatR16G16B16A16UnsignedNormalized Format = C.VK_FORMAT_R16G16B16A16_UNORM
	FormatR16G16B16A16SignedNormalized   Format = C.VK_FORMAT_R16G16B16A16_SNORM
	FormatR16G16B16A16UnsignedScaled     Format = C.VK_FORMAT_R16G16B16A16_USCALED
	FormatR16G16B16A16SignedScaled       Format = C.VK_FORMAT_R16G16B16A16_SSCALED
	FormatR16G16B16A16UnsignedInt        Format = C.VK_FORMAT_R16G16B16A16_UINT
	FormatR16G16B16A16SignedInt          Format = C.VK_FORMAT_R16G16B16A16_SINT
	FormatR16G16B16A16SignedFloat        Format = C.VK_FORMAT_R16G16B16A16_SFLOAT

	FormatR32UnsignedInt          Format = C.VK_FORMAT_R32_UINT
	FormatR32SignedInt            Format = C.VK_FORMAT_R32_SINT
	FormatR32SignedFloat          Format = C.VK_FORMAT_R32_SFLOAT
	FormatR32G32UnsignedInt       Format = C.VK_FORMAT_R32G32_UINT
	FormatR32G32SignedInt         Format = C.VK_FORMAT_R32G32_SINT
	FormatR32G32SignedFloat       Format = C.VK_FORMAT_R32G32_SFLOAT
	FormatR32G32B32UnsignedInt    Format = C.VK_FORMAT_R32G32B32_UINT
	FormatR32G32B32SignedInt      Format = C.VK_FORMAT_R32G32B32_SINT
	FormatR32G32B32SignedFloat    Format = C.VK_FORMAT_R32G32B32_SFLOAT
	FormatR32G32B32A32UnsignedInt Format = C.VK_FORMAT_R32G32B32A32_UINT
	FormatR32G32B32A32SignedInt   Format = C.VK_FORMAT_R32G32B32A32_SINT
	FormatR32G32B32A32SignedFloat Format = C.VK_FORMAT_R32G32B32A32_SFLOAT

	FormatR64UnsignedInt          Format = C.VK_FORMAT_R64_UINT
	FormatR64SignedInt            Format = C.VK_FORMAT_R64_SINT
	FormatR64SignedFloat          Format = C.VK_FORMAT_R64_SFLOAT
	FormatR64G64UnsignedInt       Format = C.VK_FORMAT_R64G64_UINT
	FormatR64G64SignedInt         Format = C.VK_FORMAT_R64G64_SINT
	FormatR64G64SignedFloat       Format = C.VK_FORMAT_R64G64_SFLOAT
	FormatR64G64B64UnsignedInt    Format = C.VK_FORMAT_R64G64B64_UINT
	FormatR64G64B64SignedInt      Format = C.VK_FORMAT_R64G64B64_SINT
	FormatR64G64B64SignedFloat    Format = C.VK_FORMAT_R64G64B64_SFLOAT
	FormatR64G64B64A64UnsignedInt Format = C.VK_FORMAT_R64G64B64A64_UINT
	FormatR64G64B64A64SignedInt   Format = C.VK_FORMAT_R64G64B64A64_SINT
	FormatR64G64B64A64SignedFloat Format = C.VK_FORMAT_R64G64B64A64_SFLOAT

	FormatB10G11R11UnsignedFloatPacked  Format = C.VK_FORMAT_B10G11R11_UFLOAT_PACK32
	FormatE5B9G9R9UnsignedFloatPacked   Format = C.VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
	FormatD16UnsignedNormalized         Format = C.VK_FORMAT_D16_UNORM
	FormatD24X8UnsignedNormalizedPacked Format = C.VK_FORMAT_X8_D24_UNORM_PACK32
	FormatD32SignedFloat                Format = C.VK_FORMAT_D32_SFLOAT
	FormatS8UnsignedInt                 Format = C.VK_FORMAT_S8_UINT

	FormatD16UnsignedNormalizedS8UnsignedInt Format = C.VK_FORMAT_D16_UNORM_S8_UINT
	FormatD24UnsignedNormalizedS8UnsignedInt Format = C.VK_FORMAT_D24_UNORM_S8_UINT
	FormatD32SignedFloatS8UnsignedInt        Format = C.VK_FORMAT_D32_SFLOAT_S8_UINT

	FormatBC1_RGBUnsignedNormalized  Format = C.VK_FORMAT_BC1_RGB_UNORM_BLOCK
	FormatBC1_RGBsRGB                Format = C.VK_FORMAT_BC1_RGB_SRGB_BLOCK
	FormatBC1_RGBAUnsignedNormalized Format = C.VK_FORMAT_BC1_RGBA_UNORM_BLOCK
	FormatBC1_RGBAsRGB               Format = C.VK_FORMAT_BC1_RGBA_SRGB_BLOCK

	FormatBC2_UnsignedNormalized Format = C.VK_FORMAT_BC2_UNORM_BLOCK
	FormatBC2_sRGB               Format = C.VK_FORMAT_BC2_SRGB_BLOCK

	FormatBC3_UnsignedNormalized Format = C.VK_FORMAT_BC3_UNORM_BLOCK
	FormatBC3_sRGB               Format = C.VK_FORMAT_BC3_SRGB_BLOCK

	FormatBC4_UnsignedNormalized Format = C.VK_FORMAT_BC4_UNORM_BLOCK
	FormatBC4_SignedNormalized   Format = C.VK_FORMAT_BC4_SNORM_BLOCK

	FormatBC5_UnsignedNormalized Format = C.VK_FORMAT_BC5_UNORM_BLOCK
	FormatBC5_SignedNormalized   Format = C.VK_FORMAT_BC5_SNORM_BLOCK

	FormatBC6_UnsignedFloat Format = C.VK_FORMAT_BC6H_UFLOAT_BLOCK
	FormatBC6_SignedFloat   Format = C.VK_FORMAT_BC6H_SFLOAT_BLOCK

	FormatBC7_UnsignedNormalized Format = C.VK_FORMAT_BC7_UNORM_BLOCK
	FormatBC7_sRGB               Format = C.VK_FORMAT_BC7_SRGB_BLOCK

	FormatETC2_R8G8B8UnsignedNormalized   Format = C.VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
	FormatETC2_R8G8B8sRGB                 Format = C.VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
	FormatETC2_R8G8B8A1UnsignedNormalized Format = C.VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
	FormatETC2_R8G8B8A1sRGB               Format = C.VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
	FormatETC2_R8G8B8A8UnsignedNormalized Format = C.VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
	FormatETC2_R8G8B8A8sRGB               Format = C.VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK

	FormatEAC_R11UnsignedNormalized    Format = C.VK_FORMAT_EAC_R11_UNORM_BLOCK
	FormatEAC_R11SignedNormalized      Format = C.VK_FORMAT_EAC_R11_SNORM_BLOCK
	FormatEAC_R11G11UnsignedNormalized Format = C.VK_FORMAT_EAC_R11G11_UNORM_BLOCK
	FormatEAC_R11G11SignedNormalized   Format = C.VK_FORMAT_EAC_R11G11_SNORM_BLOCK

	FormatASTC4x4_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_4x4_UNORM_BLOCK
	FormatASTC4x4_sRGB                 Format = C.VK_FORMAT_ASTC_4x4_SRGB_BLOCK
	FormatASTC5x4_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_5x4_UNORM_BLOCK
	FormatASTC5x4_sRGB                 Format = C.VK_FORMAT_ASTC_5x4_SRGB_BLOCK
	FormatASTC5x5_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_5x5_UNORM_BLOCK
	FormatASTC5x5_sRGB                 Format = C.VK_FORMAT_ASTC_5x5_SRGB_BLOCK
	FormatASTC6x5_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_6x5_UNORM_BLOCK
	FormatASTC6x5_sRGB                 Format = C.VK_FORMAT_ASTC_6x5_SRGB_BLOCK
	FormatASTC6x6_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_6x6_UNORM_BLOCK
	FormatASTC6x6_sRGB                 Format = C.VK_FORMAT_ASTC_6x6_SRGB_BLOCK
	FormatASTC8x5_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_8x5_UNORM_BLOCK
	FormatASTC8x5_sRGB                 Format = C.VK_FORMAT_ASTC_8x5_SRGB_BLOCK
	FormatASTC8x6_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_8x6_UNORM_BLOCK
	FormatASTC8x6_sRGB                 Format = C.VK_FORMAT_ASTC_8x6_SRGB_BLOCK
	FormatASTC8x8_UnsignedNormalized   Format = C.VK_FORMAT_ASTC_8x8_UNORM_BLOCK
	FormatASTC8x8_sRGB                 Format = C.VK_FORMAT_ASTC_8x8_SRGB_BLOCK
	FormatASTC10x5_UnsignedNormalized  Format = C.VK_FORMAT_ASTC_10x5_UNORM_BLOCK
	FormatASTC10x5_sRGB                Format = C.VK_FORMAT_ASTC_10x5_SRGB_BLOCK
	FormatASTC10x6_UnsignedNormalized  Format = C.VK_FORMAT_ASTC_10x6_UNORM_BLOCK
	FormatASTC10x6_sRGB                Format = C.VK_FORMAT_ASTC_10x6_SRGB_BLOCK
	FormatASTC10x8_UnsignedNormalized  Format = C.VK_FORMAT_ASTC_10x8_UNORM_BLOCK
	FormatASTC10x8_sRGB                Format = C.VK_FORMAT_ASTC_10x8_SRGB_BLOCK
	FormatASTC10x10_UnsignedNormalized Format = C.VK_FORMAT_ASTC_10x10_UNORM_BLOCK
	FormatASTC10x10_sRGB               Format = C.VK_FORMAT_ASTC_10x10_SRGB_BLOCK
	FormatASTC12x10_UnsignedNormalized Format = C.VK_FORMAT_ASTC_12x10_UNORM_BLOCK
	FormatASTC12x10_sRGB               Format = C.VK_FORMAT_ASTC_12x10_SRGB_BLOCK
	FormatASTC12x12_UnsignedNormalized Format = C.VK_FORMAT_ASTC_12x12_UNORM_BLOCK
	FormatASTC12x12_sRGB               Format = C.VK_FORMAT_ASTC_12x12_SRGB_BLOCK
)

func (Format) Register 

func (e Format) Register(str string)

func (Format) String 

func (e Format) String() string

type FormatFeatureFlags 

type FormatFeatureFlags int32
const (
	FormatFeatureSampledImage             FormatFeatureFlags = C.VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
	FormatFeatureStorageImage             FormatFeatureFlags = C.VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
	FormatFeatureStorageImageAtomic       FormatFeatureFlags = C.VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
	FormatFeatureUniformTexelBuffer       FormatFeatureFlags = C.VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
	FormatFeatureStorageTexelBuffer       FormatFeatureFlags = C.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
	FormatFeatureStorageTexelBufferAtomic FormatFeatureFlags = C.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
	FormatFeatureVertexBuffer             FormatFeatureFlags = C.VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
	FormatFeatureColorAttachment          FormatFeatureFlags = C.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
	FormatFeatureColorAttachmentBlend     FormatFeatureFlags = C.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
	FormatFeatureDepthStencilAttachment   FormatFeatureFlags = C.VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
	FormatFeatureBlitSource               FormatFeatureFlags = C.VK_FORMAT_FEATURE_BLIT_SRC_BIT
	FormatFeatureBlitDestination          FormatFeatureFlags = C.VK_FORMAT_FEATURE_BLIT_DST_BIT
	FormatFeatureSampledImageFilterLinear FormatFeatureFlags = C.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
)

func (FormatFeatureFlags) Register 

func (f FormatFeatureFlags) Register(str string)

func (FormatFeatureFlags) String 

func (f FormatFeatureFlags) String() string

type FormatProperties 

type FormatProperties struct {
	LinearTilingFeatures  FormatFeatureFlags
	OptimalTilingFeatures FormatFeatureFlags
	BufferFeatures        FormatFeatureFlags
}

type Framebuffer 

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

	Destroy(callbacks *driver.AllocationCallbacks)
}

type FramebufferCreateFlags 

type FramebufferCreateFlags int32

func (FramebufferCreateFlags) Register 

func (f FramebufferCreateFlags) Register(str string)

func (FramebufferCreateFlags) String 

func (f FramebufferCreateFlags) String() string

type FramebufferCreateInfo 

type FramebufferCreateInfo struct {
	Attachments []ImageView
	Flags       FramebufferCreateFlags

	Width  int
	Height int
	Layers uint32

	RenderPass RenderPass

	common.NextOptions
}

func (FramebufferCreateInfo) PopulateCPointer 

func (o FramebufferCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type FrontFace 

type FrontFace int32

func (FrontFace) Register 

func (e FrontFace) Register(str string)

func (FrontFace) String 

func (e FrontFace) String() string

type GraphicsPipelineCreateInfo 

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
}

func (GraphicsPipelineCreateInfo) PopulateCPointer 

func (o GraphicsPipelineCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type Image 

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 

type ImageAspectFlags int32

func (ImageAspectFlags) Register 

func (f ImageAspectFlags) Register(str string)

func (ImageAspectFlags) String 

func (f ImageAspectFlags) String() string

type ImageBlit 

type ImageBlit struct {
	SrcSubresource ImageSubresourceLayers
	SrcOffsets     [2]Offset3D

	DstSubresource ImageSubresourceLayers
	DstOffsets     [2]Offset3D
}

func (ImageBlit) PopulateCPointer 

func (b ImageBlit) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type ImageCopy 

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

func (ImageCopy) PopulateCPointer 

func (c ImageCopy) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type ImageCreateFlags 

type ImageCreateFlags int32

func (ImageCreateFlags) Register 

func (f ImageCreateFlags) Register(str string)

func (ImageCreateFlags) String 

func (f ImageCreateFlags) String() string

type ImageCreateOptions 

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
}

func (ImageCreateOptions) PopulateCPointer 

func (o ImageCreateOptions) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ImageFormatProperties 

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

type ImageLayout 

type ImageLayout int32

func (ImageLayout) Register 

func (e ImageLayout) Register(str string)

func (ImageLayout) String 

func (e ImageLayout) String() string

type ImageMemoryBarrier 

type ImageMemoryBarrier struct {
	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags

	OldLayout ImageLayout
	NewLayout ImageLayout

	SrcQueueFamilyIndex int
	DstQueueFamilyIndex int

	Image            Image
	SubresourceRange ImageSubresourceRange

	common.NextOptions
}

func (ImageMemoryBarrier) PopulateCPointer 

func (o ImageMemoryBarrier) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ImageResolve 

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

func (ImageResolve) PopulateCPointer 

func (r ImageResolve) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type ImageSubresource 

type ImageSubresource struct {
	AspectMask ImageAspectFlags
	MipLevel   uint32
	ArrayLayer uint32
}

type ImageSubresourceLayers 

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

type ImageSubresourceRange 

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

type ImageTiling 

type ImageTiling int32

func (ImageTiling) Register 

func (e ImageTiling) Register(str string)

func (ImageTiling) String 

func (e ImageTiling) String() string

type ImageType 

type ImageType int32

func (ImageType) Register 

func (e ImageType) Register(str string)

func (ImageType) String 

func (e ImageType) String() string

type ImageUsageFlags 

type ImageUsageFlags int32

func (ImageUsageFlags) Register 

func (f ImageUsageFlags) Register(str string)

func (ImageUsageFlags) String 

func (f ImageUsageFlags) String() string

type ImageView 

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

	Destroy(callbacks *driver.AllocationCallbacks)
}

type ImageViewCreateFlags 

type ImageViewCreateFlags int32

func (ImageViewCreateFlags) Register 

func (f ImageViewCreateFlags) Register(str string)

func (ImageViewCreateFlags) String 

func (f ImageViewCreateFlags) String() string

type ImageViewCreateInfo 

type ImageViewCreateInfo struct {
	Image Image

	Flags            ImageViewCreateFlags
	ViewType         ImageViewType
	Format           Format
	Components       ComponentMapping
	SubresourceRange ImageSubresourceRange

	common.NextOptions
}

func (ImageViewCreateInfo) PopulateCPointer 

func (o ImageViewCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ImageViewType 

type ImageViewType int32

func (ImageViewType) Register 

func (e ImageViewType) Register(str string)

func (ImageViewType) String 

func (e ImageViewType) String() string

type IndexType 

type IndexType int32

func (IndexType) Register 

func (e IndexType) Register(str string)

func (IndexType) String 

func (e IndexType) String() string

type InputRate 

type InputRate int32
const (
	RateVertex   InputRate = C.VK_VERTEX_INPUT_RATE_VERTEX
	RateInstance InputRate = C.VK_VERTEX_INPUT_RATE_INSTANCE
)

func (InputRate) Register 

func (e InputRate) Register(str string)

func (InputRate) String 

func (e InputRate) String() string

type Instance 

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 

type InstanceCreateFlags int32

func (InstanceCreateFlags) Register 

func (f InstanceCreateFlags) Register(str string)

func (InstanceCreateFlags) String 

func (f InstanceCreateFlags) String() string

type InstanceCreateInfo 

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

	Flags InstanceCreateFlags

	EnabledExtensionNames []string
	EnabledLayerNames     []string

	common.NextOptions
}

func (InstanceCreateInfo) PopulateCPointer 

func (o InstanceCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type LayerProperties 

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

type LogicOp 

type LogicOp int32

func (LogicOp) Register 

func (e LogicOp) Register(str string)

func (LogicOp) String 

func (e LogicOp) String() string

type MappedMemoryRange 

type MappedMemoryRange struct {
	Memory DeviceMemory
	Offset int
	Size   int

	common.NextOptions
}

func (MappedMemoryRange) PopulateCPointer 

func (r MappedMemoryRange) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type MemoryAllocateInfo 

type MemoryAllocateInfo struct {
	AllocationSize  int
	MemoryTypeIndex int

	common.NextOptions
}

func (MemoryAllocateInfo) PopulateCPointer 

func (o MemoryAllocateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type MemoryBarrier 

type MemoryBarrier struct {
	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags

	common.NextOptions
}

func (MemoryBarrier) PopulateCPointer 

func (o MemoryBarrier) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type MemoryHeap 

type MemoryHeap struct {
	Size  int
	Flags MemoryHeapFlags
}

type MemoryHeapFlags 

type MemoryHeapFlags int32

func (MemoryHeapFlags) Register 

func (f MemoryHeapFlags) Register(str string)

func (MemoryHeapFlags) String 

func (f MemoryHeapFlags) String() string

type MemoryMapFlags 

type MemoryMapFlags int32

func (MemoryMapFlags) String 

func (f MemoryMapFlags) String() string

type MemoryPropertyFlags 

type MemoryPropertyFlags int32

func (MemoryPropertyFlags) Register 

func (f MemoryPropertyFlags) Register(str string)

func (MemoryPropertyFlags) String 

func (f MemoryPropertyFlags) String() string

type MemoryRequirements 

type MemoryRequirements struct {
	Size           int
	Alignment      int
	MemoryTypeBits uint32
}

type MemoryType 

type MemoryType struct {
	PropertyFlags MemoryPropertyFlags
	HeapIndex     int
}

type ObjectType 

type ObjectType int32
const (
	ObjectTypeUnknown             ObjectType = C.VK_OBJECT_TYPE_UNKNOWN
	ObjectTypeInstance            ObjectType = C.VK_OBJECT_TYPE_INSTANCE
	ObjectTypePhysicalDevice      ObjectType = C.VK_OBJECT_TYPE_PHYSICAL_DEVICE
	ObjectTypeDevice              ObjectType = C.VK_OBJECT_TYPE_DEVICE
	ObjectTypeQueue               ObjectType = C.VK_OBJECT_TYPE_QUEUE
	ObjectTypeSemaphore           ObjectType = C.VK_OBJECT_TYPE_SEMAPHORE
	ObjectTypeCommandBuffer       ObjectType = C.VK_OBJECT_TYPE_COMMAND_BUFFER
	ObjectTypeFence               ObjectType = C.VK_OBJECT_TYPE_FENCE
	ObjectTypeDeviceMemory        ObjectType = C.VK_OBJECT_TYPE_DEVICE_MEMORY
	ObjectTypeBuffer              ObjectType = C.VK_OBJECT_TYPE_BUFFER
	ObjectTypeImage               ObjectType = C.VK_OBJECT_TYPE_IMAGE
	ObjectTypeEvent               ObjectType = C.VK_OBJECT_TYPE_EVENT
	ObjectTypeQueryPool           ObjectType = C.VK_OBJECT_TYPE_QUERY_POOL
	ObjectTypeBufferView          ObjectType = C.VK_OBJECT_TYPE_BUFFER_VIEW
	ObjectTypeImageView           ObjectType = C.VK_OBJECT_TYPE_IMAGE_VIEW
	ObjectTypeShaderModule        ObjectType = C.VK_OBJECT_TYPE_SHADER_MODULE
	ObjectTypePipelineCache       ObjectType = C.VK_OBJECT_TYPE_PIPELINE_CACHE
	ObjectTypePipelineLayout      ObjectType = C.VK_OBJECT_TYPE_PIPELINE_LAYOUT
	ObjectTypeRenderPass          ObjectType = C.VK_OBJECT_TYPE_RENDER_PASS
	ObjectTypePipeline            ObjectType = C.VK_OBJECT_TYPE_PIPELINE
	ObjectTypeDescriptorSetLayout ObjectType = C.VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT
	ObjectTypeSampler             ObjectType = C.VK_OBJECT_TYPE_SAMPLER
	ObjectTypeDescriptorPool      ObjectType = C.VK_OBJECT_TYPE_DESCRIPTOR_POOL
	ObjectTypeDescriptorSet       ObjectType = C.VK_OBJECT_TYPE_DESCRIPTOR_SET
	ObjectTypeFramebuffer         ObjectType = C.VK_OBJECT_TYPE_FRAMEBUFFER
	ObjectTypeCommandPool         ObjectType = C.VK_OBJECT_TYPE_COMMAND_POOL
)

func (ObjectType) Register 

func (e ObjectType) Register(str string)

func (ObjectType) String 

func (e ObjectType) String() string

type Offset2D 

type Offset2D struct {
	X int
	Y int
}

type Offset3D 

type Offset3D struct {
	X int
	Y int
	Z int
}

type PhysicalDevice 

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
}

type PhysicalDeviceFeatures 

type PhysicalDeviceFeatures struct {
	RobustBufferAccess                      bool
	FullDrawIndexUint32                     bool
	ImageCubeArray                          bool
	IndependentBlend                        bool
	GeometryShader                          bool
	TessellationShader                      bool
	SampleRateShading                       bool
	DualSrcBlend                            bool
	LogicOp                                 bool
	MultiDrawIndirect                       bool
	DrawIndirectFirstInstance               bool
	DepthClamp                              bool
	DepthBiasClamp                          bool
	FillModeNonSolid                        bool
	DepthBounds                             bool
	WideLines                               bool
	LargePoints                             bool
	AlphaToOne                              bool
	MultiViewport                           bool
	SamplerAnisotropy                       bool
	TextureCompressionEtc2                  bool
	TextureCompressionAstcLdc               bool
	TextureCompressionBc                    bool
	OcclusionQueryPrecise                   bool
	PipelineStatisticsQuery                 bool
	VertexPipelineStoresAndAtomics          bool
	FragmentStoresAndAtomics                bool
	ShaderTessellationAndGeometryPointSize  bool
	ShaderImageGatherExtended               bool
	ShaderStorageImageExtendedFormats       bool
	ShaderStorageImageMultisample           bool
	ShaderStorageImageReadWithoutFormat     bool
	ShaderStorageImageWriteWithoutFormat    bool
	ShaderUniformBufferArrayDynamicIndexing bool
	ShaderSampledImageArrayDynamicIndexing  bool
	ShaderStorageBufferArrayDynamicIndexing bool
	ShaderStorageImageArrayDynamicIndexing  bool
	ShaderClipDistance                      bool
	ShaderCullDistance                      bool
	ShaderFloat64                           bool
	ShaderInt64                             bool
	ShaderInt16                             bool
	ShaderResourceResidency                 bool
	ShaderResourceMinLod                    bool
	SparseBinding                           bool
	SparseResidencyBuffer                   bool
	SparseResidencyImage2D                  bool
	SparseResidencyImage3D                  bool
	SparseResidency2Samples                 bool
	SparseResidency4Samples                 bool
	SparseResidency8Samples                 bool
	SparseResidency16Samples                bool
	SparseResidencyAliased                  bool
	VariableMultisampleRate                 bool
	InheritedQueries                        bool
}

func (*PhysicalDeviceFeatures) PopulateCPointer 

func (p *PhysicalDeviceFeatures) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

func (*PhysicalDeviceFeatures) PopulateFromCPointer 

func (p *PhysicalDeviceFeatures) PopulateFromCPointer(cPointer unsafe.Pointer)

type PhysicalDeviceLimits 

type PhysicalDeviceLimits struct {
	MaxImageDimension1D    int
	MaxImageDimension2D    int
	MaxImageDimension3D    int
	MaxImageDimensionCube  int
	MaxImageArrayLayers    int
	MaxTexelBufferElements int

	MaxUniformBufferRange int
	MaxStorageBufferRange int
	MaxPushConstantsSize  int

	MaxMemoryAllocationCount  int
	MaxSamplerAllocationCount int

	BufferImageGranularity int
	SparseAddressSpaceSize int

	MaxBoundDescriptorSets                int
	MaxPerStageDescriptorSamplers         int
	MaxPerStageDescriptorUniformBuffers   int
	MaxPerStageDescriptorStorageBuffers   int
	MaxPerStageDescriptorSampledImages    int
	MaxPerStageDescriptorStorageImages    int
	MaxPerStageDescriptorInputAttachments int
	MaxPerStageResources                  int

	MaxDescriptorSetSamplers              int
	MaxDescriptorSetUniformBuffers        int
	MaxDescriptorSetUniformBuffersDynamic int
	MaxDescriptorSetStorageBuffers        int
	MaxDescriptorSetStorageBuffersDynamic int
	MaxDescriptorSetSampledImages         int
	MaxDescriptorSetStorageImages         int
	MaxDescriptorSetInputAttachments      int

	MaxVertexInputAttributes      int
	MaxVertexInputBindings        int
	MaxVertexInputAttributeOffset int
	MaxVertexInputBindingStride   int
	MaxVertexOutputComponents     int

	MaxTessellationGenerationLevel                  int
	MaxTessellationPatchSize                        int
	MaxTessellationControlPerVertexInputComponents  int
	MaxTessellationControlPerVertexOutputComponents int
	MaxTessellationControlPerPatchOutputComponents  int
	MaxTessellationControlTotalOutputComponents     int
	MaxTessellationEvaluationInputComponents        int
	MaxTessellationEvaluationOutputComponents       int

	MaxGeometryShaderInvocations     int
	MaxGeometryInputComponents       int
	MaxGeometryOutputComponents      int
	MaxGeometryOutputVertices        int
	MaxGeometryTotalOutputComponents int

	MaxFragmentInputComponents         int
	MaxFragmentOutputAttachments       int
	MaxFragmentDualSrcAttachments      int
	MaxFragmentCombinedOutputResources int

	MaxComputeSharedMemorySize     int
	MaxComputeWorkGroupCount       [3]int
	MaxComputeWorkGroupInvocations int
	MaxComputeWorkGroupSize        [3]int

	SubPixelPrecisionBits int
	SubTexelPrecisionBits int
	MipmapPrecisionBits   int

	MaxDrawIndexedIndexValue int
	MaxDrawIndirectCount     int

	MaxSamplerLodBias    float32
	MaxSamplerAnisotropy float32

	MaxViewports          int
	MaxViewportDimensions [2]int
	ViewportBoundsRange   [2]float32
	ViewportSubPixelBits  int

	MinMemoryMapAlignment           int
	MinTexelBufferOffsetAlignment   int
	MinUniformBufferOffsetAlignment int
	MinStorageBufferOffsetAlignment int

	MinTexelOffset                  int
	MaxTexelOffset                  int
	MinTexelGatherOffset            int
	MaxTexelGatherOffset            int
	MinInterpolationOffset          float32
	MaxInterpolationOffset          float32
	SubPixelInterpolationOffsetBits int

	MaxFramebufferWidth  int
	MaxFramebufferHeight int
	MaxFramebufferLayers int

	FramebufferColorSampleCounts         SampleCountFlags
	FramebufferDepthSampleCounts         SampleCountFlags
	FramebufferStencilSampleCounts       SampleCountFlags
	FramebufferNoAttachmentsSampleCounts SampleCountFlags

	MaxColorAttachments             int
	SampledImageColorSampleCounts   SampleCountFlags
	SampledImageIntegerSampleCounts SampleCountFlags
	SampledImageDepthSampleCounts   SampleCountFlags
	SampledImageStencilSampleCounts SampleCountFlags
	StorageImageSampleCounts        SampleCountFlags
	MaxSampleMaskWords              int

	TimestampComputeAndGraphics bool
	TimestampPeriod             float32

	MaxClipDistances                int
	MaxCullDistances                int
	MaxCombinedClipAndCullDistances int

	DiscreteQueuePriorities int

	PointSizeRange       [2]float32
	LineWidthRange       [2]float32
	PointSizeGranularity float32
	LineWidthGranularity float32

	StrictLines             bool
	StandardSampleLocations bool

	OptimalBufferCopyOffsetAlignment   int
	OptimalBufferCopyRowPitchAlignment int
	NonCoherentAtomSize                int
}

type PhysicalDeviceMemoryProperties 

type PhysicalDeviceMemoryProperties struct {
	MemoryTypes []MemoryType
	MemoryHeaps []MemoryHeap
}

type PhysicalDeviceProperties 

type PhysicalDeviceProperties struct {
	DriverType PhysicalDeviceType
	DriverName string

	APIVersion    common.APIVersion
	DriverVersion common.Version
	VendorID      uint32
	DeviceID      uint32

	PipelineCacheUUID uuid.UUID
	Limits            *PhysicalDeviceLimits
	SparseProperties  *PhysicalDeviceSparseProperties
}

func (*PhysicalDeviceProperties) PopulateFromCPointer 

func (p *PhysicalDeviceProperties) PopulateFromCPointer(cPointer unsafe.Pointer) error

type PhysicalDeviceSparseProperties 

type PhysicalDeviceSparseProperties struct {
	ResidencyStandard2DBlockShape            bool
	ResidencyStandard2DMultisampleBlockShape bool
	ResidencyStandard3DBlockShape            bool
	ResidencyAlignedMipSize                  bool
	ResidencyNonResidentStrict               bool
}

type PhysicalDeviceType 

type PhysicalDeviceType int32

func (PhysicalDeviceType) Register 

func (e PhysicalDeviceType) Register(str string)

func (PhysicalDeviceType) String 

func (e PhysicalDeviceType) String() string

type Pipeline 

type Pipeline interface {
	Handle() driver.VkPipeline
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type PipelineBindPoint 

type PipelineBindPoint int32

func (PipelineBindPoint) Register 

func (e PipelineBindPoint) Register(str string)

func (PipelineBindPoint) String 

func (e PipelineBindPoint) String() string

type PipelineCache 

type PipelineCache interface {
	Handle() driver.VkPipelineCache
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	CacheData() ([]byte, common.VkResult, error)
	MergePipelineCaches(srcCaches []PipelineCache) (common.VkResult, error)
}

type PipelineCacheCreateFlags 

type PipelineCacheCreateFlags int32

func (PipelineCacheCreateFlags) Register 

func (f PipelineCacheCreateFlags) Register(str string)

func (PipelineCacheCreateFlags) String 

func (f PipelineCacheCreateFlags) String() string

type PipelineCacheCreateInfo 

type PipelineCacheCreateInfo struct {
	Flags       PipelineCacheCreateFlags
	InitialData []byte

	common.NextOptions
}

func (PipelineCacheCreateInfo) PopulateCPointer 

func (o PipelineCacheCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineCacheHeaderVersion 

type PipelineCacheHeaderVersion int32
const (
	PipelineCacheHeaderVersionOne PipelineCacheHeaderVersion = C.VK_PIPELINE_CACHE_HEADER_VERSION_ONE
)

func (PipelineCacheHeaderVersion) Register 

func (e PipelineCacheHeaderVersion) Register(str string)

func (PipelineCacheHeaderVersion) String 

func (e PipelineCacheHeaderVersion) String() string

type PipelineColorBlendAttachmentState 

type PipelineColorBlendAttachmentState struct {
	BlendEnabled bool

	SrcColorBlendFactor BlendFactor
	DstColorBlendFactor BlendFactor
	ColorBlendOp        BlendOp

	SrcAlphaBlendFactor BlendFactor
	DstAlphaBlendFactor BlendFactor
	AlphaBlendOp        BlendOp

	ColorWriteMask ColorComponentFlags
}

type PipelineColorBlendStateCreateFlags 

type PipelineColorBlendStateCreateFlags uint32

func (PipelineColorBlendStateCreateFlags) Register 

func (f PipelineColorBlendStateCreateFlags) Register(str string)

func (PipelineColorBlendStateCreateFlags) String 

func (f PipelineColorBlendStateCreateFlags) String() string

type PipelineColorBlendStateCreateInfo 

type PipelineColorBlendStateCreateInfo struct {
	Flags          PipelineColorBlendStateCreateFlags
	LogicOpEnabled bool
	LogicOp        LogicOp

	BlendConstants [4]float32
	Attachments    []PipelineColorBlendAttachmentState

	common.NextOptions
}

func (PipelineColorBlendStateCreateInfo) PopulateCPointer 

func (o PipelineColorBlendStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineCreateFlags 

type PipelineCreateFlags int32
const (
	PipelineCreateDisableOptimization PipelineCreateFlags = C.VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT
	PipelineCreateAllowDerivatives    PipelineCreateFlags = C.VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT
	PipelineCreateDerivative          PipelineCreateFlags = C.VK_PIPELINE_CREATE_DERIVATIVE_BIT
)

func (PipelineCreateFlags) Register 

func (f PipelineCreateFlags) Register(str string)

func (PipelineCreateFlags) String 

func (f PipelineCreateFlags) String() string

type PipelineDepthStencilStateCreateFlags 

type PipelineDepthStencilStateCreateFlags uint32

func (PipelineDepthStencilStateCreateFlags) Register 

func (f PipelineDepthStencilStateCreateFlags) Register(str string)

func (PipelineDepthStencilStateCreateFlags) String 

func (f PipelineDepthStencilStateCreateFlags) String() string

type PipelineDepthStencilStateCreateInfo 

type PipelineDepthStencilStateCreateInfo struct {
	Flags PipelineDepthStencilStateCreateFlags

	DepthTestEnable  bool
	DepthWriteEnable bool
	DepthCompareOp   CompareOp

	DepthBoundsTestEnable bool
	StencilTestEnable     bool

	Front StencilOpState
	Back  StencilOpState

	MinDepthBounds float32
	MaxDepthBounds float32

	common.NextOptions
}

func (PipelineDepthStencilStateCreateInfo) PopulateCPointer 

func (o PipelineDepthStencilStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineDynamicStateCreateFlags 

type PipelineDynamicStateCreateFlags uint32

func (PipelineDynamicStateCreateFlags) Register 

func (f PipelineDynamicStateCreateFlags) Register(str string)

func (PipelineDynamicStateCreateFlags) String 

func (f PipelineDynamicStateCreateFlags) String() string

type PipelineDynamicStateCreateInfo 

type PipelineDynamicStateCreateInfo struct {
	Flags         PipelineDynamicStateCreateFlags
	DynamicStates []DynamicState

	common.NextOptions
}

func (PipelineDynamicStateCreateInfo) PopulateCPointer 

func (o PipelineDynamicStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineInputAssemblyStateCreateFlags 

type PipelineInputAssemblyStateCreateFlags uint32

func (PipelineInputAssemblyStateCreateFlags) Register 

func (f PipelineInputAssemblyStateCreateFlags) Register(str string)

func (PipelineInputAssemblyStateCreateFlags) String 

func (f PipelineInputAssemblyStateCreateFlags) String() string

type PipelineInputAssemblyStateCreateInfo 

type PipelineInputAssemblyStateCreateInfo struct {
	Flags                  PipelineInputAssemblyStateCreateFlags
	Topology               PrimitiveTopology
	PrimitiveRestartEnable bool

	common.NextOptions
}

func (PipelineInputAssemblyStateCreateInfo) PopulateCPointer 

func (o PipelineInputAssemblyStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineLayout 

type PipelineLayout interface {
	Handle() driver.VkPipelineLayout
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type PipelineLayoutCreateFlags 

type PipelineLayoutCreateFlags uint32

func (PipelineLayoutCreateFlags) Register 

func (f PipelineLayoutCreateFlags) Register(str string)

func (PipelineLayoutCreateFlags) String 

func (f PipelineLayoutCreateFlags) String() string

type PipelineLayoutCreateInfo 

type PipelineLayoutCreateInfo struct {
	Flags PipelineLayoutCreateFlags

	SetLayouts         []DescriptorSetLayout
	PushConstantRanges []PushConstantRange

	common.NextOptions
}

func (PipelineLayoutCreateInfo) PopulateCPointer 

func (o PipelineLayoutCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineMultisampleStateCreateFlags 

type PipelineMultisampleStateCreateFlags uint32

func (PipelineMultisampleStateCreateFlags) Register 

func (f PipelineMultisampleStateCreateFlags) Register(str string)

func (PipelineMultisampleStateCreateFlags) String 

func (f PipelineMultisampleStateCreateFlags) String() string

type PipelineMultisampleStateCreateInfo 

type PipelineMultisampleStateCreateInfo struct {
	Flags                PipelineMultisampleStateCreateFlags
	RasterizationSamples SampleCountFlags

	SampleShadingEnable bool
	MinSampleShading    float32
	SampleMask          []uint32

	AlphaToCoverageEnable bool
	AlphaToOneEnable      bool

	common.NextOptions
}

func (PipelineMultisampleStateCreateInfo) PopulateCPointer 

func (o PipelineMultisampleStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineRasterizationStateCreateFlags 

type PipelineRasterizationStateCreateFlags uint32

func (PipelineRasterizationStateCreateFlags) Register 

func (f PipelineRasterizationStateCreateFlags) Register(str string)

func (PipelineRasterizationStateCreateFlags) String 

func (f PipelineRasterizationStateCreateFlags) String() string

type PipelineRasterizationStateCreateInfo 

type PipelineRasterizationStateCreateInfo struct {
	Flags                   PipelineRasterizationStateCreateFlags
	DepthClampEnable        bool
	RasterizerDiscardEnable bool

	PolygonMode PolygonMode
	CullMode    CullModeFlags
	FrontFace   FrontFace

	DepthBiasEnable         bool
	DepthBiasClamp          float32
	DepthBiasConstantFactor float32
	DepthBiasSlopeFactor    float32

	LineWidth float32

	common.NextOptions
}

func (PipelineRasterizationStateCreateInfo) PopulateCPointer 

func (o PipelineRasterizationStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineShaderStageCreateInfo 

type PipelineShaderStageCreateInfo struct {
	Flags              ShaderStageCreateFlags
	Name               string
	Stage              ShaderStageFlags
	Module             ShaderModule
	SpecializationInfo map[uint32]any

	common.NextOptions
}

func (PipelineShaderStageCreateInfo) PopulateCPointer 

func (s PipelineShaderStageCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineStageFlags 

type PipelineStageFlags int32
const (
	PipelineStageTopOfPipe                    PipelineStageFlags = C.VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
	PipelineStageDrawIndirect                 PipelineStageFlags = C.VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
	PipelineStageVertexInput                  PipelineStageFlags = C.VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
	PipelineStageVertexShader                 PipelineStageFlags = C.VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
	PipelineStageTessellationControlShader    PipelineStageFlags = C.VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
	PipelineStageTessellationEvaluationShader PipelineStageFlags = C.VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
	PipelineStageGeometryShader               PipelineStageFlags = C.VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
	PipelineStageFragmentShader               PipelineStageFlags = C.VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
	PipelineStageEarlyFragmentTests           PipelineStageFlags = C.VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
	PipelineStageLateFragmentTests            PipelineStageFlags = C.VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
	PipelineStageColorAttachmentOutput        PipelineStageFlags = C.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
	PipelineStageComputeShader                PipelineStageFlags = C.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
	PipelineStageTransfer                     PipelineStageFlags = C.VK_PIPELINE_STAGE_TRANSFER_BIT
	PipelineStageBottomOfPipe                 PipelineStageFlags = C.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
	PipelineStageHost                         PipelineStageFlags = C.VK_PIPELINE_STAGE_HOST_BIT
	PipelineStageAllGraphics                  PipelineStageFlags = C.VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT
	PipelineStageAllCommands                  PipelineStageFlags = C.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
)

func (PipelineStageFlags) Register 

func (f PipelineStageFlags) Register(str string)

func (PipelineStageFlags) String 

func (f PipelineStageFlags) String() string

type PipelineTessellationStateCreateFlags 

type PipelineTessellationStateCreateFlags uint32

func (PipelineTessellationStateCreateFlags) Register 

func (f PipelineTessellationStateCreateFlags) Register(str string)

func (PipelineTessellationStateCreateFlags) String 

func (f PipelineTessellationStateCreateFlags) String() string

type PipelineTessellationStateCreateInfo 

type PipelineTessellationStateCreateInfo struct {
	Flags              PipelineTessellationStateCreateFlags
	PatchControlPoints uint32

	common.NextOptions
}

func (PipelineTessellationStateCreateInfo) PopulateCPointer 

func (o PipelineTessellationStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatePointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineVertexInputStateCreateInfo 

type PipelineVertexInputStateCreateInfo struct {
	VertexBindingDescriptions   []VertexInputBindingDescription
	VertexAttributeDescriptions []VertexInputAttributeDescription

	common.NextOptions
}

func (PipelineVertexInputStateCreateInfo) PopulateCPointer 

func (o PipelineVertexInputStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PipelineViewportStateCreateFlags 

type PipelineViewportStateCreateFlags uint32

func (PipelineViewportStateCreateFlags) Register 

func (f PipelineViewportStateCreateFlags) Register(str string)

func (PipelineViewportStateCreateFlags) String 

func (f PipelineViewportStateCreateFlags) String() string

type PipelineViewportStateCreateInfo 

type PipelineViewportStateCreateInfo struct {
	Viewports []Viewport
	Scissors  []Rect2D
	Flags     PipelineViewportStateCreateFlags

	common.NextOptions
}

func (PipelineViewportStateCreateInfo) PopulateCPointer 

func (o PipelineViewportStateCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type PolygonMode 

type PolygonMode int32

func (PolygonMode) Register 

func (e PolygonMode) Register(str string)

func (PolygonMode) String 

func (e PolygonMode) String() string

type PrimitiveTopology 

type PrimitiveTopology int32
const (
	PrimitiveTopologyPointList                  PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_POINT_LIST
	PrimitiveTopologyLineList                   PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_LINE_LIST
	PrimitiveTopologyLineStrip                  PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP
	PrimitiveTopologyTriangleList               PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
	PrimitiveTopologyTriangleStrip              PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
	PrimitiveTopologyTriangleFan                PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN
	PrimitiveTopologyLineListWithAdjacency      PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY
	PrimitiveTopologyLineStripWithAdjacency     PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY
	PrimitiveTopologyTriangleListWithAdjacency  PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY
	PrimitiveTopologyTriangleStripWithAdjacency PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY
	PrimitiveTopologyPatchlist                  PrimitiveTopology = C.VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
)

func (PrimitiveTopology) Register 

func (e PrimitiveTopology) Register(str string)

func (PrimitiveTopology) String 

func (e PrimitiveTopology) String() string

type PushConstantRange 

type PushConstantRange struct {
	StageFlags ShaderStageFlags
	Offset     int
	Size       int
}

type QueryControlFlags 

type QueryControlFlags int32

func (QueryControlFlags) Register 

func (f QueryControlFlags) Register(str string)

func (QueryControlFlags) String 

func (f QueryControlFlags) String() string

type QueryPipelineStatisticFlags 

type QueryPipelineStatisticFlags int32

func (QueryPipelineStatisticFlags) Register 

func (f QueryPipelineStatisticFlags) Register(str string)

func (QueryPipelineStatisticFlags) String 

func (f QueryPipelineStatisticFlags) String() string

type QueryPool 

type QueryPool interface {
	Handle() driver.VkQueryPool
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	PopulateResults(firstQuery, queryCount int, results []byte, resultStride int, flags QueryResultFlags) (common.VkResult, error)
}

type QueryPoolCreateFlags 

type QueryPoolCreateFlags uint32

func (QueryPoolCreateFlags) Register 

func (f QueryPoolCreateFlags) Register(str string)

func (QueryPoolCreateFlags) String 

func (f QueryPoolCreateFlags) String() string

type QueryPoolCreateInfo 

type QueryPoolCreateInfo struct {
	Flags QueryPoolCreateFlags

	QueryType          QueryType
	QueryCount         int
	PipelineStatistics QueryPipelineStatisticFlags

	common.NextOptions
}

func (QueryPoolCreateInfo) PopulateCPointer 

func (o QueryPoolCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type QueryResultFlags 

type QueryResultFlags int32

func (QueryResultFlags) Register 

func (f QueryResultFlags) Register(str string)

func (QueryResultFlags) String 

func (f QueryResultFlags) String() string

type QueryType 

type QueryType int32

func (QueryType) Register 

func (e QueryType) Register(str string)

func (QueryType) String 

func (e QueryType) String() string

type Queue 

type Queue interface {
	Handle() driver.VkQueue
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	WaitIdle() (common.VkResult, error)
	Submit(fence Fence, o []SubmitInfo) (common.VkResult, error)
	BindSparse(fence Fence, bindInfos []BindSparseOptions) (common.VkResult, error)
}

type QueueFamily 

type QueueFamily struct {
	QueueFlags                  QueueFlags
	QueueCount                  int
	TimestampValidBits          uint32
	MinImageTransferGranularity Extent3D
}

type QueueFlags 

type QueueFlags int32

func (QueueFlags) Register 

func (f QueueFlags) Register(str string)

func (QueueFlags) String 

func (f QueueFlags) String() string

type Rect2D 

type Rect2D struct {
	Offset Offset2D
	Extent Extent2D
}

type RenderPass 

type RenderPass interface {
	Handle() driver.VkRenderPass
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
	RenderAreaGranularity() Extent2D
}

type RenderPassBeginInfo 

type RenderPassBeginInfo struct {
	RenderPass  RenderPass
	Framebuffer Framebuffer

	RenderArea  Rect2D
	ClearValues []ClearValue

	common.NextOptions
}

func (RenderPassBeginInfo) PopulateCPointer 

func (o RenderPassBeginInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type RenderPassCreateFlags 

type RenderPassCreateFlags int32

func (RenderPassCreateFlags) Register 

func (f RenderPassCreateFlags) Register(str string)

func (RenderPassCreateFlags) String 

func (f RenderPassCreateFlags) String() string

type RenderPassCreateInfo 

type RenderPassCreateInfo struct {
	Flags               RenderPassCreateFlags
	Attachments         []AttachmentDescription
	Subpasses           []SubpassDescription
	SubpassDependencies []SubpassDependency

	common.NextOptions
}

func (RenderPassCreateInfo) PopulateCPointer 

func (o RenderPassCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type SampleCountFlags 

type SampleCountFlags int32

func (SampleCountFlags) Count 

func (f SampleCountFlags) Count() int

func (SampleCountFlags) RegisterSamples 

func (f SampleCountFlags) RegisterSamples(str string, sampleCount int)

func (SampleCountFlags) String 

func (f SampleCountFlags) String() string

type Sampler 

type Sampler interface {
	Handle() driver.VkSampler
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type SamplerAddressMode 

type SamplerAddressMode int32

func (SamplerAddressMode) Register 

func (e SamplerAddressMode) Register(str string)

func (SamplerAddressMode) String 

func (e SamplerAddressMode) String() string

type SamplerCreateFlags 

type SamplerCreateFlags int32

func (SamplerCreateFlags) Register 

func (f SamplerCreateFlags) Register(str string)

func (SamplerCreateFlags) String 

func (f SamplerCreateFlags) String() string

type SamplerCreateInfo 

type SamplerCreateInfo struct {
	Flags        SamplerCreateFlags
	MagFilter    Filter
	MinFilter    Filter
	MipmapMode   SamplerMipmapMode
	AddressModeU SamplerAddressMode
	AddressModeV SamplerAddressMode
	AddressModeW SamplerAddressMode

	MipLodBias float32
	MinLod     float32
	MaxLod     float32

	AnisotropyEnable bool
	MaxAnisotropy    float32

	CompareEnable bool
	CompareOp     CompareOp

	BorderColor             BorderColor
	UnnormalizedCoordinates bool

	common.NextOptions
}

func (SamplerCreateInfo) PopulateCPointer 

func (o SamplerCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type SamplerMipmapMode 

type SamplerMipmapMode int32

func (SamplerMipmapMode) Register 

func (e SamplerMipmapMode) Register(str string)

func (SamplerMipmapMode) String 

func (e SamplerMipmapMode) String() string

type Semaphore 

type Semaphore interface {
	Handle() driver.VkSemaphore
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type SemaphoreCreateFlags 

type SemaphoreCreateFlags int32

func (SemaphoreCreateFlags) Register 

func (f SemaphoreCreateFlags) Register(str string)

func (SemaphoreCreateFlags) String 

func (f SemaphoreCreateFlags) String() string

type SemaphoreCreateInfo 

type SemaphoreCreateInfo struct {
	Flags SemaphoreCreateFlags

	common.NextOptions
}

func (SemaphoreCreateInfo) PopulateCPointer 

func (o SemaphoreCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ShaderModule 

type ShaderModule interface {
	Handle() driver.VkShaderModule
	DeviceHandle() driver.VkDevice
	Driver() driver.Driver
	APIVersion() common.APIVersion

	Destroy(callbacks *driver.AllocationCallbacks)
}

type ShaderModuleCreateFlags 

type ShaderModuleCreateFlags int32

func (ShaderModuleCreateFlags) Register 

func (f ShaderModuleCreateFlags) Register(str string)

func (ShaderModuleCreateFlags) String 

func (f ShaderModuleCreateFlags) String() string

type ShaderModuleCreateInfo 

type ShaderModuleCreateInfo struct {
	Code  []uint32
	Flags ShaderModuleCreateFlags

	common.NextOptions
}

func (ShaderModuleCreateInfo) PopulateCPointer 

func (o ShaderModuleCreateInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type ShaderStageCreateFlags 

type ShaderStageCreateFlags int32

func (ShaderStageCreateFlags) Register 

func (f ShaderStageCreateFlags) Register(str string)

func (ShaderStageCreateFlags) String 

func (f ShaderStageCreateFlags) String() string

type ShaderStageFlags 

type ShaderStageFlags int32
const (
	StageVertex                 ShaderStageFlags = C.VK_SHADER_STAGE_VERTEX_BIT
	StageTessellationControl    ShaderStageFlags = C.VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
	StageTessellationEvaluation ShaderStageFlags = C.VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
	StageGeometry               ShaderStageFlags = C.VK_SHADER_STAGE_GEOMETRY_BIT
	StageFragment               ShaderStageFlags = C.VK_SHADER_STAGE_FRAGMENT_BIT
	StageCompute                ShaderStageFlags = C.VK_SHADER_STAGE_COMPUTE_BIT
	StageAllGraphics            ShaderStageFlags = C.VK_SHADER_STAGE_ALL_GRAPHICS
	StageAll                    ShaderStageFlags = C.VK_SHADER_STAGE_ALL
)

func (ShaderStageFlags) Register 

func (f ShaderStageFlags) Register(str string)

func (ShaderStageFlags) String 

func (f ShaderStageFlags) String() string

type SharingMode 

type SharingMode int32

func (SharingMode) Register 

func (e SharingMode) Register(str string)

func (SharingMode) String 

func (e SharingMode) String() string

type SparseBufferMemoryBindInfo 

type SparseBufferMemoryBindInfo struct {
	Buffer Buffer
	Binds  []SparseMemoryBind
}

type SparseImageFormatFlags 

type SparseImageFormatFlags int32

func (SparseImageFormatFlags) Register 

func (f SparseImageFormatFlags) Register(str string)

func (SparseImageFormatFlags) String 

func (f SparseImageFormatFlags) String() string

type SparseImageFormatProperties 

type SparseImageFormatProperties struct {
	AspectMask       ImageAspectFlags
	ImageGranularity Extent3D
	Flags            SparseImageFormatFlags
}

type SparseImageMemoryBind 

type SparseImageMemoryBind struct {
	Subresource ImageSubresource
	Offset      Offset3D
	Extent      Extent3D

	Memory       DeviceMemory
	MemoryOffset int

	Flags SparseMemoryBindFlags
}

type SparseImageMemoryBindInfo 

type SparseImageMemoryBindInfo struct {
	Image Image
	Binds []SparseImageMemoryBind
}

type SparseImageMemoryRequirements 

type SparseImageMemoryRequirements struct {
	FormatProperties     SparseImageFormatProperties
	ImageMipTailFirstLod int
	ImageMipTailSize     int
	ImageMipTailOffset   int
	ImageMipTailStride   int
}

type SparseImageOpaqueMemoryBindInfo 

type SparseImageOpaqueMemoryBindInfo struct {
	Image Image
	Binds []SparseMemoryBind
}

type SparseMemoryBind 

type SparseMemoryBind struct {
	ResourceOffset int
	Size           int

	Memory       DeviceMemory
	MemoryOffset int

	Flags SparseMemoryBindFlags
}

func (SparseMemoryBind) PopulateCPointer 

func (b SparseMemoryBind) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer) (unsafe.Pointer, error)

type SparseMemoryBindFlags 

type SparseMemoryBindFlags int32
const (
	SparseMemoryBindMetadata SparseMemoryBindFlags = C.VK_SPARSE_MEMORY_BIND_METADATA_BIT
)

func (SparseMemoryBindFlags) Register 

func (f SparseMemoryBindFlags) Register(str string)

func (SparseMemoryBindFlags) String 

func (f SparseMemoryBindFlags) String() string

type StencilFaceFlags 

type StencilFaceFlags int32

func (StencilFaceFlags) Register 

func (f StencilFaceFlags) Register(str string)

func (StencilFaceFlags) String 

func (f StencilFaceFlags) String() string

type StencilOp 

type StencilOp int32
const (
	StencilKeep              StencilOp = C.VK_STENCIL_OP_KEEP
	StencilZero              StencilOp = C.VK_STENCIL_OP_ZERO
	StencilReplace           StencilOp = C.VK_STENCIL_OP_REPLACE
	StencilIncrementAndClamp StencilOp = C.VK_STENCIL_OP_INCREMENT_AND_CLAMP
	StencilDecrementAndClamp StencilOp = C.VK_STENCIL_OP_DECREMENT_AND_CLAMP
	StencilInvert            StencilOp = C.VK_STENCIL_OP_INVERT
	StencilIncrementAndWrap  StencilOp = C.VK_STENCIL_OP_INCREMENT_AND_WRAP
	StencilDecrementAndWrap  StencilOp = C.VK_STENCIL_OP_DECREMENT_AND_WRAP
)

func (StencilOp) Register 

func (e StencilOp) Register(str string)

func (StencilOp) String 

func (e StencilOp) String() string

type StencilOpState 

type StencilOpState struct {
	FailOp      StencilOp
	PassOp      StencilOp
	DepthFailOp StencilOp

	CompareOp   CompareOp
	CompareMask uint32
	WriteMask   uint32

	Reference uint32
}

type SubmitInfo 

type SubmitInfo struct {
	CommandBuffers   []CommandBuffer
	WaitSemaphores   []Semaphore
	WaitDstStageMask []PipelineStageFlags
	SignalSemaphores []Semaphore

	common.NextOptions
}

func (SubmitInfo) PopulateCPointer 

func (o SubmitInfo) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type SubpassContents 

type SubpassContents int32
const (
	SubpassContentsInline                  SubpassContents = C.VK_SUBPASS_CONTENTS_INLINE
	SubpassContentsSecondaryCommandBuffers SubpassContents = C.VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
)

func (SubpassContents) Register 

func (e SubpassContents) Register(str string)

func (SubpassContents) String 

func (e SubpassContents) String() string

type SubpassDependency 

type SubpassDependency struct {
	DependencyFlags DependencyFlags

	SrcSubpass int
	DstSubpass int

	SrcStageMask PipelineStageFlags
	DstStageMask PipelineStageFlags

	SrcAccessMask AccessFlags
	DstAccessMask AccessFlags
}

type SubpassDescription 

type SubpassDescription struct {
	Flags             SubpassDescriptionFlags
	PipelineBindPoint PipelineBindPoint

	InputAttachments       []AttachmentReference
	ColorAttachments       []AttachmentReference
	ResolveAttachments     []AttachmentReference
	DepthStencilAttachment *AttachmentReference
	PreserveAttachments    []int
}

type SubpassDescriptionFlags 

type SubpassDescriptionFlags int32

func (SubpassDescriptionFlags) Register 

func (f SubpassDescriptionFlags) Register(str string)

func (SubpassDescriptionFlags) String 

func (f SubpassDescriptionFlags) String() string

type SubresourceLayout 

type SubresourceLayout struct {
	Offset     int
	Size       int
	RowPitch   int
	ArrayPitch int
	DepthPitch int
}

type VertexInputAttributeDescription 

type VertexInputAttributeDescription struct {
	Location uint32
	Binding  int
	Format   Format
	Offset   int
}

type VertexInputBindingDescription 

type VertexInputBindingDescription struct {
	InputRate InputRate
	Binding   int
	Stride    int
}

type Viewport 

type Viewport struct {
	X        float32
	Y        float32
	Width    float32
	Height   float32
	MinDepth float32
	MaxDepth float32
}

type VulkanBuffer 

type VulkanBuffer struct {
	// contains filtered or unexported fields
}

func (*VulkanBuffer) APIVersion 

func (b *VulkanBuffer) APIVersion() common.APIVersion

func (*VulkanBuffer) BindBufferMemory 

func (b *VulkanBuffer) BindBufferMemory(memory DeviceMemory, offset int) (common.VkResult, error)

func (*VulkanBuffer) Destroy 

func (b *VulkanBuffer) Destroy(allocationCallbacks *driver.AllocationCallbacks)

func (*VulkanBuffer) DeviceHandle 

func (b *VulkanBuffer) DeviceHandle() driver.VkDevice

func (*VulkanBuffer) Driver 

func (b *VulkanBuffer) Driver() driver.Driver

func (*VulkanBuffer) Handle 

func (b *VulkanBuffer) Handle() driver.VkBuffer

func (*VulkanBuffer) MemoryRequirements 

func (b *VulkanBuffer) MemoryRequirements() *MemoryRequirements

type VulkanBufferView 

type VulkanBufferView struct {
	// contains filtered or unexported fields
}

func (*VulkanBufferView) APIVersion 

func (v *VulkanBufferView) APIVersion() common.APIVersion

func (*VulkanBufferView) Destroy 

func (v *VulkanBufferView) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanBufferView) DeviceHandle 

func (v *VulkanBufferView) DeviceHandle() driver.VkDevice

func (*VulkanBufferView) Driver 

func (v *VulkanBufferView) Driver() driver.Driver

func (*VulkanBufferView) Handle 

func (v *VulkanBufferView) Handle() driver.VkBufferView

type VulkanCommandBuffer 

type VulkanCommandBuffer struct {
	// contains filtered or unexported fields
}

func (*VulkanCommandBuffer) APIVersion 

func (c *VulkanCommandBuffer) APIVersion() common.APIVersion

func (*VulkanCommandBuffer) Begin 

func (c *VulkanCommandBuffer) Begin(o CommandBufferBeginInfo) (common.VkResult, error)

func (*VulkanCommandBuffer) CmdBeginQuery 

func (c *VulkanCommandBuffer) CmdBeginQuery(queryPool QueryPool, query int, flags QueryControlFlags)

func (*VulkanCommandBuffer) CmdBeginRenderPass 

func (c *VulkanCommandBuffer) CmdBeginRenderPass(contents SubpassContents, o RenderPassBeginInfo) error

func (*VulkanCommandBuffer) CmdBindDescriptorSets 

func (c *VulkanCommandBuffer) CmdBindDescriptorSets(bindPoint PipelineBindPoint, layout PipelineLayout, sets []DescriptorSet, dynamicOffsets []int)

func (*VulkanCommandBuffer) CmdBindIndexBuffer 

func (c *VulkanCommandBuffer) CmdBindIndexBuffer(buffer Buffer, offset int, indexType IndexType)

func (*VulkanCommandBuffer) CmdBindPipeline 

func (c *VulkanCommandBuffer) CmdBindPipeline(bindPoint PipelineBindPoint, pipeline Pipeline)

func (*VulkanCommandBuffer) CmdBindVertexBuffers 

func (c *VulkanCommandBuffer) CmdBindVertexBuffers(buffers []Buffer, bufferOffsets []int)

func (*VulkanCommandBuffer) CmdBlitImage 

func (c *VulkanCommandBuffer) CmdBlitImage(sourceImage Image, sourceImageLayout ImageLayout, destinationImage Image, destinationImageLayout ImageLayout, regions []ImageBlit, filter Filter) error

func (*VulkanCommandBuffer) CmdClearAttachments 

func (c *VulkanCommandBuffer) CmdClearAttachments(attachments []ClearAttachment, rects []ClearRect) error

func (*VulkanCommandBuffer) CmdClearColorImage 

func (c *VulkanCommandBuffer) CmdClearColorImage(image Image, imageLayout ImageLayout, color ClearColorValue, ranges []ImageSubresourceRange)

func (*VulkanCommandBuffer) CmdClearDepthStencilImage 

func (c *VulkanCommandBuffer) CmdClearDepthStencilImage(image Image, imageLayout ImageLayout, depthStencil *ClearValueDepthStencil, ranges []ImageSubresourceRange)

func (*VulkanCommandBuffer) CmdCopyBuffer 

func (c *VulkanCommandBuffer) CmdCopyBuffer(srcBuffer Buffer, dstBuffer Buffer, copyRegions []BufferCopy) error

func (*VulkanCommandBuffer) CmdCopyBufferToImage 

func (c *VulkanCommandBuffer) CmdCopyBufferToImage(buffer Buffer, image Image, layout ImageLayout, regions []BufferImageCopy) error

func (*VulkanCommandBuffer) CmdCopyImage 

func (c *VulkanCommandBuffer) CmdCopyImage(srcImage Image, srcImageLayout ImageLayout, dstImage Image, dstImageLayout ImageLayout, regions []ImageCopy) error

func (*VulkanCommandBuffer) CmdCopyImageToBuffer 

func (c *VulkanCommandBuffer) CmdCopyImageToBuffer(srcImage Image, srcImageLayout ImageLayout, dstBuffer Buffer, regions []BufferImageCopy) error

func (*VulkanCommandBuffer) CmdCopyQueryPoolResults 

func (c *VulkanCommandBuffer) CmdCopyQueryPoolResults(queryPool QueryPool, firstQuery, queryCount int, dstBuffer Buffer, dstOffset, stride int, flags QueryResultFlags)

func (*VulkanCommandBuffer) CmdDispatch 

func (c *VulkanCommandBuffer) CmdDispatch(groupCountX, groupCountY, groupCountZ int)

func (*VulkanCommandBuffer) CmdDispatchIndirect 

func (c *VulkanCommandBuffer) CmdDispatchIndirect(buffer Buffer, offset int)

func (*VulkanCommandBuffer) CmdDraw 

func (c *VulkanCommandBuffer) CmdDraw(vertexCount, instanceCount int, firstVertex, firstInstance uint32)

func (*VulkanCommandBuffer) CmdDrawIndexed 

func (c *VulkanCommandBuffer) CmdDrawIndexed(indexCount, instanceCount int, firstIndex uint32, vertexOffset int, firstInstance uint32)

func (*VulkanCommandBuffer) CmdDrawIndexedIndirect 

func (c *VulkanCommandBuffer) CmdDrawIndexedIndirect(buffer Buffer, offset int, drawCount, stride int)

func (*VulkanCommandBuffer) CmdDrawIndirect 

func (c *VulkanCommandBuffer) CmdDrawIndirect(buffer Buffer, offset int, drawCount, stride int)

func (*VulkanCommandBuffer) CmdEndQuery 

func (c *VulkanCommandBuffer) CmdEndQuery(queryPool QueryPool, query int)

func (*VulkanCommandBuffer) CmdEndRenderPass 

func (c *VulkanCommandBuffer) CmdEndRenderPass()

func (*VulkanCommandBuffer) CmdExecuteCommands 

func (c *VulkanCommandBuffer) CmdExecuteCommands(commandBuffers []CommandBuffer)

func (*VulkanCommandBuffer) CmdFillBuffer 

func (c *VulkanCommandBuffer) CmdFillBuffer(dstBuffer Buffer, dstOffset int, size int, data uint32)

func (*VulkanCommandBuffer) CmdNextSubpass 

func (c *VulkanCommandBuffer) CmdNextSubpass(contents SubpassContents)

func (*VulkanCommandBuffer) CmdPipelineBarrier 

func (c *VulkanCommandBuffer) CmdPipelineBarrier(srcStageMask, dstStageMask PipelineStageFlags, dependencies DependencyFlags, memoryBarriers []MemoryBarrier, bufferMemoryBarriers []BufferMemoryBarrier, imageMemoryBarriers []ImageMemoryBarrier) error

func (*VulkanCommandBuffer) CmdPushConstants 

func (c *VulkanCommandBuffer) CmdPushConstants(layout PipelineLayout, stageFlags ShaderStageFlags, offset int, valueBytes []byte)

func (*VulkanCommandBuffer) CmdResetEvent 

func (c *VulkanCommandBuffer) CmdResetEvent(event Event, stageMask PipelineStageFlags)

func (*VulkanCommandBuffer) CmdResetQueryPool 

func (c *VulkanCommandBuffer) CmdResetQueryPool(queryPool QueryPool, startQuery, queryCount int)

func (*VulkanCommandBuffer) CmdResolveImage 

func (c *VulkanCommandBuffer) CmdResolveImage(srcImage Image, srcImageLayout ImageLayout, dstImage Image, dstImageLayout ImageLayout, regions []ImageResolve) error

func (*VulkanCommandBuffer) CmdSetBlendConstants 

func (c *VulkanCommandBuffer) CmdSetBlendConstants(blendConstants [4]float32)

func (*VulkanCommandBuffer) CmdSetDepthBias 

func (c *VulkanCommandBuffer) CmdSetDepthBias(depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor float32)

func (*VulkanCommandBuffer) CmdSetDepthBounds 

func (c *VulkanCommandBuffer) CmdSetDepthBounds(min, max float32)

func (*VulkanCommandBuffer) CmdSetEvent 

func (c *VulkanCommandBuffer) CmdSetEvent(event Event, stageMask PipelineStageFlags)

func (*VulkanCommandBuffer) CmdSetLineWidth 

func (c *VulkanCommandBuffer) CmdSetLineWidth(lineWidth float32)

func (*VulkanCommandBuffer) CmdSetScissor 

func (c *VulkanCommandBuffer) CmdSetScissor(scissors []Rect2D)

func (*VulkanCommandBuffer) CmdSetStencilCompareMask 

func (c *VulkanCommandBuffer) CmdSetStencilCompareMask(faceMask StencilFaceFlags, compareMask uint32)

func (*VulkanCommandBuffer) CmdSetStencilReference 

func (c *VulkanCommandBuffer) CmdSetStencilReference(faceMask StencilFaceFlags, reference uint32)

func (*VulkanCommandBuffer) CmdSetStencilWriteMask 

func (c *VulkanCommandBuffer) CmdSetStencilWriteMask(faceMask StencilFaceFlags, writeMask uint32)

func (*VulkanCommandBuffer) CmdSetViewport 

func (c *VulkanCommandBuffer) CmdSetViewport(viewports []Viewport)

func (*VulkanCommandBuffer) CmdUpdateBuffer 

func (c *VulkanCommandBuffer) CmdUpdateBuffer(dstBuffer Buffer, dstOffset int, dataSize int, data []byte)

func (*VulkanCommandBuffer) CmdWaitEvents 

func (c *VulkanCommandBuffer) CmdWaitEvents(events []Event, srcStageMask PipelineStageFlags, dstStageMask PipelineStageFlags, memoryBarriers []MemoryBarrier, bufferMemoryBarriers []BufferMemoryBarrier, imageMemoryBarriers []ImageMemoryBarrier) error

func (*VulkanCommandBuffer) CmdWriteTimestamp 

func (c *VulkanCommandBuffer) CmdWriteTimestamp(pipelineStage PipelineStageFlags, queryPool QueryPool, query int)

func (*VulkanCommandBuffer) CommandCounter 

func (c *VulkanCommandBuffer) CommandCounter() *CommandCounter

func (*VulkanCommandBuffer) CommandPoolHandle 

func (c *VulkanCommandBuffer) CommandPoolHandle() driver.VkCommandPool

func (*VulkanCommandBuffer) CommandsRecorded 

func (c *VulkanCommandBuffer) CommandsRecorded() int

func (*VulkanCommandBuffer) DeviceHandle 

func (c *VulkanCommandBuffer) DeviceHandle() driver.VkDevice

func (*VulkanCommandBuffer) DispatchesRecorded 

func (c *VulkanCommandBuffer) DispatchesRecorded() int

func (*VulkanCommandBuffer) DrawsRecorded 

func (c *VulkanCommandBuffer) DrawsRecorded() int

func (*VulkanCommandBuffer) Driver 

func (c *VulkanCommandBuffer) Driver() driver.Driver

func (*VulkanCommandBuffer) End 

func (c *VulkanCommandBuffer) End() (common.VkResult, error)

func (*VulkanCommandBuffer) Free 

func (c *VulkanCommandBuffer) Free()

func (*VulkanCommandBuffer) Handle 

func (c *VulkanCommandBuffer) Handle() driver.VkCommandBuffer

func (*VulkanCommandBuffer) Reset 

func (c *VulkanCommandBuffer) Reset(flags CommandBufferResetFlags) (common.VkResult, error)

type VulkanCommandPool 

type VulkanCommandPool struct {
	// contains filtered or unexported fields
}

func (*VulkanCommandPool) APIVersion 

func (p *VulkanCommandPool) APIVersion() common.APIVersion

func (*VulkanCommandPool) Destroy 

func (p *VulkanCommandPool) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanCommandPool) DeviceHandle 

func (p *VulkanCommandPool) DeviceHandle() driver.VkDevice

func (*VulkanCommandPool) Driver 

func (p *VulkanCommandPool) Driver() driver.Driver

func (*VulkanCommandPool) Handle 

func (p *VulkanCommandPool) Handle() driver.VkCommandPool

func (*VulkanCommandPool) Reset 

func (p *VulkanCommandPool) Reset(flags CommandPoolResetFlags) (common.VkResult, error)

type VulkanDescriptorPool 

type VulkanDescriptorPool struct {
	// contains filtered or unexported fields
}

func (*VulkanDescriptorPool) APIVersion 

func (p *VulkanDescriptorPool) APIVersion() common.APIVersion

func (*VulkanDescriptorPool) Destroy 

func (p *VulkanDescriptorPool) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanDescriptorPool) DeviceHandle 

func (p *VulkanDescriptorPool) DeviceHandle() driver.VkDevice

func (*VulkanDescriptorPool) Driver 

func (p *VulkanDescriptorPool) Driver() driver.Driver

func (*VulkanDescriptorPool) Handle 

func (p *VulkanDescriptorPool) Handle() driver.VkDescriptorPool

func (*VulkanDescriptorPool) Reset 

func (p *VulkanDescriptorPool) Reset(flags DescriptorPoolResetFlags) (common.VkResult, error)

type VulkanDescriptorSet 

type VulkanDescriptorSet struct {
	// contains filtered or unexported fields
}

func (*VulkanDescriptorSet) APIVersion 

func (s *VulkanDescriptorSet) APIVersion() common.APIVersion

func (*VulkanDescriptorSet) DescriptorPoolHandle 

func (s *VulkanDescriptorSet) DescriptorPoolHandle() driver.VkDescriptorPool

func (*VulkanDescriptorSet) DeviceHandle 

func (s *VulkanDescriptorSet) DeviceHandle() driver.VkDevice

func (*VulkanDescriptorSet) Driver 

func (s *VulkanDescriptorSet) Driver() driver.Driver

func (*VulkanDescriptorSet) Free 

func (s *VulkanDescriptorSet) Free() (common.VkResult, error)

func (*VulkanDescriptorSet) Handle 

func (s *VulkanDescriptorSet) Handle() driver.VkDescriptorSet

type VulkanDescriptorSetLayout 

type VulkanDescriptorSetLayout struct {
	// contains filtered or unexported fields
}

func (*VulkanDescriptorSetLayout) APIVersion 

func (h *VulkanDescriptorSetLayout) APIVersion() common.APIVersion

func (*VulkanDescriptorSetLayout) Destroy 

func (h *VulkanDescriptorSetLayout) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanDescriptorSetLayout) DeviceHandle 

func (h *VulkanDescriptorSetLayout) DeviceHandle() driver.VkDevice

func (*VulkanDescriptorSetLayout) Driver 

func (h *VulkanDescriptorSetLayout) Driver() driver.Driver

func (*VulkanDescriptorSetLayout) Handle 

func (h *VulkanDescriptorSetLayout) Handle() driver.VkDescriptorSetLayout

type VulkanDevice 

type VulkanDevice struct {
	// contains filtered or unexported fields
}

func (*VulkanDevice) APIVersion 

func (d *VulkanDevice) APIVersion() common.APIVersion

func (*VulkanDevice) AllocateCommandBuffers 

func (d *VulkanDevice) AllocateCommandBuffers(o CommandBufferAllocateInfo) ([]CommandBuffer, common.VkResult, error)

func (*VulkanDevice) AllocateDescriptorSets 

func (d *VulkanDevice) AllocateDescriptorSets(o DescriptorSetAllocateInfo) ([]DescriptorSet, common.VkResult, error)

func (*VulkanDevice) AllocateMemory 

func (d *VulkanDevice) AllocateMemory(allocationCallbacks *driver.AllocationCallbacks, o MemoryAllocateInfo) (DeviceMemory, common.VkResult, error)

func (*VulkanDevice) CreateBuffer 

func (d *VulkanDevice) CreateBuffer(allocationCallbacks *driver.AllocationCallbacks, o BufferCreateInfo) (Buffer, common.VkResult, error)

func (*VulkanDevice) CreateBufferView 

func (d *VulkanDevice) CreateBufferView(allocationCallbacks *driver.AllocationCallbacks, options BufferViewCreateInfo) (BufferView, common.VkResult, error)

func (*VulkanDevice) CreateCommandPool 

func (d *VulkanDevice) CreateCommandPool(allocationCallbacks *driver.AllocationCallbacks, o CommandPoolCreateInfo) (CommandPool, common.VkResult, error)

func (*VulkanDevice) CreateComputePipelines 

func (d *VulkanDevice) CreateComputePipelines(pipelineCache PipelineCache, allocationCallbacks *driver.AllocationCallbacks, o []ComputePipelineCreateInfo) ([]Pipeline, common.VkResult, error)

func (*VulkanDevice) CreateDescriptorPool 

func (d *VulkanDevice) CreateDescriptorPool(allocationCallbacks *driver.AllocationCallbacks, o DescriptorPoolCreateInfo) (DescriptorPool, common.VkResult, error)

func (*VulkanDevice) CreateDescriptorSetLayout 

func (d *VulkanDevice) CreateDescriptorSetLayout(allocationCallbacks *driver.AllocationCallbacks, o DescriptorSetLayoutCreateInfo) (DescriptorSetLayout, common.VkResult, error)

func (*VulkanDevice) CreateEvent 

func (d *VulkanDevice) CreateEvent(allocationCallbacks *driver.AllocationCallbacks, o EventCreateInfo) (Event, common.VkResult, error)

func (*VulkanDevice) CreateFence 

func (d *VulkanDevice) CreateFence(allocationCallbacks *driver.AllocationCallbacks, o FenceCreateInfo) (Fence, common.VkResult, error)

func (*VulkanDevice) CreateFramebuffer 

func (d *VulkanDevice) CreateFramebuffer(allocationCallbacks *driver.AllocationCallbacks, o FramebufferCreateInfo) (Framebuffer, common.VkResult, error)

func (*VulkanDevice) CreateGraphicsPipelines 

func (d *VulkanDevice) CreateGraphicsPipelines(pipelineCache PipelineCache, allocationCallbacks *driver.AllocationCallbacks, o []GraphicsPipelineCreateInfo) ([]Pipeline, common.VkResult, error)

func (*VulkanDevice) CreateImage 

func (d *VulkanDevice) CreateImage(allocationCallbacks *driver.AllocationCallbacks, o ImageCreateOptions) (Image, common.VkResult, error)

func (*VulkanDevice) CreateImageView 

func (d *VulkanDevice) CreateImageView(allocationCallbacks *driver.AllocationCallbacks, o ImageViewCreateInfo) (ImageView, common.VkResult, error)

func (*VulkanDevice) CreatePipelineCache 

func (d *VulkanDevice) CreatePipelineCache(allocationCallbacks *driver.AllocationCallbacks, o PipelineCacheCreateInfo) (PipelineCache, common.VkResult, error)

func (*VulkanDevice) CreatePipelineLayout 

func (d *VulkanDevice) CreatePipelineLayout(allocationCallbacks *driver.AllocationCallbacks, o PipelineLayoutCreateInfo) (PipelineLayout, common.VkResult, error)

func (*VulkanDevice) CreateQueryPool 

func (d *VulkanDevice) CreateQueryPool(allocationCallbacks *driver.AllocationCallbacks, o QueryPoolCreateInfo) (QueryPool, common.VkResult, error)

func (*VulkanDevice) CreateRenderPass 

func (d *VulkanDevice) CreateRenderPass(allocationCallbacks *driver.AllocationCallbacks, o RenderPassCreateInfo) (RenderPass, common.VkResult, error)

func (*VulkanDevice) CreateSampler 

func (d *VulkanDevice) CreateSampler(allocationCallbacks *driver.AllocationCallbacks, o SamplerCreateInfo) (Sampler, common.VkResult, error)

func (*VulkanDevice) CreateSemaphore 

func (d *VulkanDevice) CreateSemaphore(allocationCallbacks *driver.AllocationCallbacks, o SemaphoreCreateInfo) (Semaphore, common.VkResult, error)

func (*VulkanDevice) CreateShaderModule 

func (d *VulkanDevice) CreateShaderModule(allocationCallbacks *driver.AllocationCallbacks, o ShaderModuleCreateInfo) (ShaderModule, common.VkResult, error)

func (*VulkanDevice) Destroy 

func (d *VulkanDevice) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanDevice) Driver 

func (d *VulkanDevice) Driver() driver.Driver

func (*VulkanDevice) FlushMappedMemoryRanges 

func (d *VulkanDevice) FlushMappedMemoryRanges(ranges []MappedMemoryRange) (common.VkResult, error)

func (*VulkanDevice) FreeCommandBuffers 

func (d *VulkanDevice) FreeCommandBuffers(buffers []CommandBuffer)

func (*VulkanDevice) FreeDescriptorSets 

func (d *VulkanDevice) FreeDescriptorSets(sets []DescriptorSet) (common.VkResult, error)

func (*VulkanDevice) FreeMemory 

func (d *VulkanDevice) FreeMemory(deviceMemory DeviceMemory, allocationCallbacks *driver.AllocationCallbacks)

func (*VulkanDevice) GetQueue 

func (d *VulkanDevice) GetQueue(queueFamilyIndex int, queueIndex int) Queue

func (*VulkanDevice) Handle 

func (d *VulkanDevice) Handle() driver.VkDevice

func (*VulkanDevice) InvalidateMappedMemoryRanges 

func (d *VulkanDevice) InvalidateMappedMemoryRanges(ranges []MappedMemoryRange) (common.VkResult, error)

func (*VulkanDevice) IsDeviceExtensionActive 

func (d *VulkanDevice) IsDeviceExtensionActive(extensionName string) bool

func (*VulkanDevice) ResetFences 

func (d *VulkanDevice) ResetFences(fences []Fence) (common.VkResult, error)

func (*VulkanDevice) UpdateDescriptorSets 

func (d *VulkanDevice) UpdateDescriptorSets(writes []WriteDescriptorSet, copies []CopyDescriptorSet) error

func (*VulkanDevice) WaitForFences 

func (d *VulkanDevice) WaitForFences(waitForAll bool, timeout time.Duration, fences []Fence) (common.VkResult, error)

func (*VulkanDevice) WaitIdle 

func (d *VulkanDevice) WaitIdle() (common.VkResult, error)

type VulkanDeviceMemory 

type VulkanDeviceMemory struct {
	// contains filtered or unexported fields
}

func (*VulkanDeviceMemory) APIVersion 

func (m *VulkanDeviceMemory) APIVersion() common.APIVersion

func (*VulkanDeviceMemory) Commitment 

func (m *VulkanDeviceMemory) Commitment() int

func (*VulkanDeviceMemory) DeviceHandle 

func (m *VulkanDeviceMemory) DeviceHandle() driver.VkDevice

func (*VulkanDeviceMemory) Driver 

func (m *VulkanDeviceMemory) Driver() driver.Driver

func (*VulkanDeviceMemory) FlushAll 

func (m *VulkanDeviceMemory) FlushAll() (common.VkResult, error)

func (*VulkanDeviceMemory) Free 

func (m *VulkanDeviceMemory) Free(allocationCallbacks *driver.AllocationCallbacks)

func (*VulkanDeviceMemory) Handle 

func (m *VulkanDeviceMemory) Handle() driver.VkDeviceMemory

func (*VulkanDeviceMemory) InvalidateAll 

func (m *VulkanDeviceMemory) InvalidateAll() (common.VkResult, error)

func (*VulkanDeviceMemory) Map 

func (m *VulkanDeviceMemory) Map(offset int, size int, flags MemoryMapFlags) (unsafe.Pointer, common.VkResult, error)

func (*VulkanDeviceMemory) Unmap 

func (m *VulkanDeviceMemory) Unmap()

type VulkanEvent 

type VulkanEvent struct {
	// contains filtered or unexported fields
}

func (*VulkanEvent) APIVersion 

func (e *VulkanEvent) APIVersion() common.APIVersion

func (*VulkanEvent) Destroy 

func (e *VulkanEvent) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanEvent) DeviceHandle 

func (e *VulkanEvent) DeviceHandle() driver.VkDevice

func (*VulkanEvent) Driver 

func (e *VulkanEvent) Driver() driver.Driver

func (*VulkanEvent) Handle 

func (e *VulkanEvent) Handle() driver.VkEvent

func (*VulkanEvent) Reset 

func (e *VulkanEvent) Reset() (common.VkResult, error)

func (*VulkanEvent) Set 

func (e *VulkanEvent) Set() (common.VkResult, error)

func (*VulkanEvent) Status 

func (e *VulkanEvent) Status() (common.VkResult, error)

type VulkanFence 

type VulkanFence struct {
	// contains filtered or unexported fields
}

func (*VulkanFence) APIVersion 

func (f *VulkanFence) APIVersion() common.APIVersion

func (*VulkanFence) Destroy 

func (f *VulkanFence) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanFence) DeviceHandle 

func (f *VulkanFence) DeviceHandle() driver.VkDevice

func (*VulkanFence) Driver 

func (f *VulkanFence) Driver() driver.Driver

func (*VulkanFence) Handle 

func (f *VulkanFence) Handle() driver.VkFence

func (*VulkanFence) Reset 

func (f *VulkanFence) Reset() (common.VkResult, error)

func (*VulkanFence) Status 

func (f *VulkanFence) Status() (common.VkResult, error)

func (*VulkanFence) Wait 

func (f *VulkanFence) Wait(timeout time.Duration) (common.VkResult, error)

type VulkanFramebuffer 

type VulkanFramebuffer struct {
	// contains filtered or unexported fields
}

func (*VulkanFramebuffer) APIVersion 

func (b *VulkanFramebuffer) APIVersion() common.APIVersion

func (*VulkanFramebuffer) Destroy 

func (b *VulkanFramebuffer) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanFramebuffer) DeviceHandle 

func (b *VulkanFramebuffer) DeviceHandle() driver.VkDevice

func (*VulkanFramebuffer) Driver 

func (b *VulkanFramebuffer) Driver() driver.Driver

func (*VulkanFramebuffer) Handle 

func (b *VulkanFramebuffer) Handle() driver.VkFramebuffer

type VulkanImage 

type VulkanImage struct {
	// contains filtered or unexported fields
}

func (*VulkanImage) APIVersion 

func (i *VulkanImage) APIVersion() common.APIVersion

func (*VulkanImage) BindImageMemory 

func (i *VulkanImage) BindImageMemory(memory DeviceMemory, offset int) (common.VkResult, error)

func (*VulkanImage) Destroy 

func (i *VulkanImage) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanImage) DeviceHandle 

func (i *VulkanImage) DeviceHandle() driver.VkDevice

func (*VulkanImage) Driver 

func (i *VulkanImage) Driver() driver.Driver

func (*VulkanImage) Handle 

func (i *VulkanImage) Handle() driver.VkImage

func (*VulkanImage) MemoryRequirements 

func (i *VulkanImage) MemoryRequirements() *MemoryRequirements

func (*VulkanImage) SparseMemoryRequirements 

func (i *VulkanImage) SparseMemoryRequirements() []SparseImageMemoryRequirements

func (*VulkanImage) SubresourceLayout 

func (i *VulkanImage) SubresourceLayout(subresource *ImageSubresource) *SubresourceLayout

type VulkanImageView 

type VulkanImageView struct {
	// contains filtered or unexported fields
}

func (*VulkanImageView) APIVersion 

func (v *VulkanImageView) APIVersion() common.APIVersion

func (*VulkanImageView) Destroy 

func (v *VulkanImageView) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanImageView) DeviceHandle 

func (v *VulkanImageView) DeviceHandle() driver.VkDevice

func (*VulkanImageView) Driver 

func (v *VulkanImageView) Driver() driver.Driver

func (*VulkanImageView) Handle 

func (v *VulkanImageView) Handle() driver.VkImageView

type VulkanInstance 

type VulkanInstance struct {
	ActiveInstanceExtensions map[string]struct{}
	// contains filtered or unexported fields
}

func (*VulkanInstance) APIVersion 

func (i *VulkanInstance) APIVersion() common.APIVersion

func (*VulkanInstance) Destroy 

func (i *VulkanInstance) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanInstance) Driver 

func (i *VulkanInstance) Driver() driver.Driver

func (*VulkanInstance) EnumeratePhysicalDevices 

func (i *VulkanInstance) EnumeratePhysicalDevices() ([]PhysicalDevice, common.VkResult, error)

func (*VulkanInstance) Handle 

func (i *VulkanInstance) Handle() driver.VkInstance

func (*VulkanInstance) IsInstanceExtensionActive 

func (i *VulkanInstance) IsInstanceExtensionActive(extensionName string) bool

type VulkanPhysicalDevice 

type VulkanPhysicalDevice struct {
	// contains filtered or unexported fields
}

func (*VulkanPhysicalDevice) CreateDevice 

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

func (*VulkanPhysicalDevice) DeviceAPIVersion 

func (d *VulkanPhysicalDevice) DeviceAPIVersion() common.APIVersion

func (*VulkanPhysicalDevice) Driver 

func (d *VulkanPhysicalDevice) Driver() driver.Driver

func (*VulkanPhysicalDevice) EnumerateDeviceExtensionProperties 

func (d *VulkanPhysicalDevice) EnumerateDeviceExtensionProperties() (map[string]*ExtensionProperties, common.VkResult, error)

func (*VulkanPhysicalDevice) EnumerateDeviceExtensionPropertiesForLayer 

func (d *VulkanPhysicalDevice) EnumerateDeviceExtensionPropertiesForLayer(layerName string) (map[string]*ExtensionProperties, common.VkResult, error)

func (*VulkanPhysicalDevice) EnumerateDeviceLayerProperties 

func (d *VulkanPhysicalDevice) EnumerateDeviceLayerProperties() (map[string]*LayerProperties, common.VkResult, error)

func (*VulkanPhysicalDevice) Features 

func (d *VulkanPhysicalDevice) Features() *PhysicalDeviceFeatures

func (*VulkanPhysicalDevice) FormatProperties 

func (d *VulkanPhysicalDevice) FormatProperties(format Format) *FormatProperties

func (*VulkanPhysicalDevice) Handle 

func (d *VulkanPhysicalDevice) Handle() driver.VkPhysicalDevice

func (*VulkanPhysicalDevice) ImageFormatProperties 

func (d *VulkanPhysicalDevice) ImageFormatProperties(format Format, imageType ImageType, tiling ImageTiling, usages ImageUsageFlags, flags ImageCreateFlags) (*ImageFormatProperties, common.VkResult, error)

func (*VulkanPhysicalDevice) InstanceAPIVersion 

func (d *VulkanPhysicalDevice) InstanceAPIVersion() common.APIVersion

func (*VulkanPhysicalDevice) MemoryProperties 

func (d *VulkanPhysicalDevice) MemoryProperties() *PhysicalDeviceMemoryProperties

func (*VulkanPhysicalDevice) Properties 

func (d *VulkanPhysicalDevice) Properties() (*PhysicalDeviceProperties, error)

func (*VulkanPhysicalDevice) QueueFamilyProperties 

func (d *VulkanPhysicalDevice) QueueFamilyProperties() []*QueueFamily

func (*VulkanPhysicalDevice) SparseImageFormatProperties 

func (d *VulkanPhysicalDevice) SparseImageFormatProperties(format Format, imageType ImageType, samples SampleCountFlags, usages ImageUsageFlags, tiling ImageTiling) []SparseImageFormatProperties

type VulkanPipeline 

type VulkanPipeline struct {
	// contains filtered or unexported fields
}

func (*VulkanPipeline) APIVersion 

func (p *VulkanPipeline) APIVersion() common.APIVersion

func (*VulkanPipeline) Destroy 

func (p *VulkanPipeline) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanPipeline) DeviceHandle 

func (p *VulkanPipeline) DeviceHandle() driver.VkDevice

func (*VulkanPipeline) Driver 

func (p *VulkanPipeline) Driver() driver.Driver

func (*VulkanPipeline) Handle 

func (p *VulkanPipeline) Handle() driver.VkPipeline

type VulkanPipelineCache 

type VulkanPipelineCache struct {
	// contains filtered or unexported fields
}

func (*VulkanPipelineCache) APIVersion 

func (c *VulkanPipelineCache) APIVersion() common.APIVersion

func (*VulkanPipelineCache) CacheData 

func (c *VulkanPipelineCache) CacheData() ([]byte, common.VkResult, error)

func (*VulkanPipelineCache) Destroy 

func (c *VulkanPipelineCache) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanPipelineCache) DeviceHandle 

func (c *VulkanPipelineCache) DeviceHandle() driver.VkDevice

func (*VulkanPipelineCache) Driver 

func (c *VulkanPipelineCache) Driver() driver.Driver

func (*VulkanPipelineCache) Handle 

func (c *VulkanPipelineCache) Handle() driver.VkPipelineCache

func (*VulkanPipelineCache) MergePipelineCaches 

func (c *VulkanPipelineCache) MergePipelineCaches(srcCaches []PipelineCache) (common.VkResult, error)

type VulkanPipelineLayout 

type VulkanPipelineLayout struct {
	// contains filtered or unexported fields
}

func (*VulkanPipelineLayout) APIVersion 

func (l *VulkanPipelineLayout) APIVersion() common.APIVersion

func (*VulkanPipelineLayout) Destroy 

func (l *VulkanPipelineLayout) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanPipelineLayout) DeviceHandle 

func (l *VulkanPipelineLayout) DeviceHandle() driver.VkDevice

func (*VulkanPipelineLayout) Driver 

func (l *VulkanPipelineLayout) Driver() driver.Driver

func (*VulkanPipelineLayout) Handle 

func (l *VulkanPipelineLayout) Handle() driver.VkPipelineLayout

type VulkanQueryPool 

type VulkanQueryPool struct {
	// contains filtered or unexported fields
}

func (*VulkanQueryPool) APIVersion 

func (p *VulkanQueryPool) APIVersion() common.APIVersion

func (*VulkanQueryPool) Destroy 

func (p *VulkanQueryPool) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanQueryPool) DeviceHandle 

func (p *VulkanQueryPool) DeviceHandle() driver.VkDevice

func (*VulkanQueryPool) Driver 

func (p *VulkanQueryPool) Driver() driver.Driver

func (*VulkanQueryPool) Handle 

func (p *VulkanQueryPool) Handle() driver.VkQueryPool

func (*VulkanQueryPool) PopulateResults 

func (p *VulkanQueryPool) PopulateResults(firstQuery, queryCount int, results []byte, resultStride int, flags QueryResultFlags) (common.VkResult, error)

type VulkanQueue 

type VulkanQueue struct {
	// contains filtered or unexported fields
}

func (*VulkanQueue) APIVersion 

func (q *VulkanQueue) APIVersion() common.APIVersion

func (*VulkanQueue) BindSparse 

func (q *VulkanQueue) BindSparse(fence Fence, bindInfos []BindSparseOptions) (common.VkResult, error)

func (*VulkanQueue) DeviceHandle 

func (q *VulkanQueue) DeviceHandle() driver.VkDevice

func (*VulkanQueue) Driver 

func (q *VulkanQueue) Driver() driver.Driver

func (*VulkanQueue) Handle 

func (q *VulkanQueue) Handle() driver.VkQueue

func (*VulkanQueue) Submit 

func (q *VulkanQueue) Submit(fence Fence, o []SubmitInfo) (common.VkResult, error)

func (*VulkanQueue) WaitIdle 

func (q *VulkanQueue) WaitIdle() (common.VkResult, error)

type VulkanRenderPass 

type VulkanRenderPass struct {
	// contains filtered or unexported fields
}

func (*VulkanRenderPass) APIVersion 

func (p *VulkanRenderPass) APIVersion() common.APIVersion

func (*VulkanRenderPass) Destroy 

func (p *VulkanRenderPass) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanRenderPass) DeviceHandle 

func (p *VulkanRenderPass) DeviceHandle() driver.VkDevice

func (*VulkanRenderPass) Driver 

func (p *VulkanRenderPass) Driver() driver.Driver

func (*VulkanRenderPass) Handle 

func (p *VulkanRenderPass) Handle() driver.VkRenderPass

func (*VulkanRenderPass) RenderAreaGranularity 

func (p *VulkanRenderPass) RenderAreaGranularity() Extent2D

type VulkanSampler 

type VulkanSampler struct {
	// contains filtered or unexported fields
}

func (*VulkanSampler) APIVersion 

func (s *VulkanSampler) APIVersion() common.APIVersion

func (*VulkanSampler) Destroy 

func (s *VulkanSampler) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanSampler) DeviceHandle 

func (s *VulkanSampler) DeviceHandle() driver.VkDevice

func (*VulkanSampler) Driver 

func (s *VulkanSampler) Driver() driver.Driver

func (*VulkanSampler) Handle 

func (s *VulkanSampler) Handle() driver.VkSampler

type VulkanSemaphore 

type VulkanSemaphore struct {
	// contains filtered or unexported fields
}

func (*VulkanSemaphore) APIVersion 

func (s *VulkanSemaphore) APIVersion() common.APIVersion

func (*VulkanSemaphore) Destroy 

func (s *VulkanSemaphore) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanSemaphore) DeviceHandle 

func (s *VulkanSemaphore) DeviceHandle() driver.VkDevice

func (*VulkanSemaphore) Driver 

func (s *VulkanSemaphore) Driver() driver.Driver

func (*VulkanSemaphore) Handle 

func (s *VulkanSemaphore) Handle() driver.VkSemaphore

type VulkanShaderModule 

type VulkanShaderModule struct {
	// contains filtered or unexported fields
}

func (*VulkanShaderModule) APIVersion 

func (m *VulkanShaderModule) APIVersion() common.APIVersion

func (*VulkanShaderModule) Destroy 

func (m *VulkanShaderModule) Destroy(callbacks *driver.AllocationCallbacks)

func (*VulkanShaderModule) DeviceHandle 

func (m *VulkanShaderModule) DeviceHandle() driver.VkDevice

func (*VulkanShaderModule) Driver 

func (m *VulkanShaderModule) Driver() driver.Driver

func (*VulkanShaderModule) Handle 

func (m *VulkanShaderModule) Handle() driver.VkShaderModule

type WriteDescriptorSet 

type WriteDescriptorSet struct {
	DstSet          DescriptorSet
	DstBinding      int
	DstArrayElement int

	DescriptorType DescriptorType

	ImageInfo       []DescriptorImageInfo
	BufferInfo      []DescriptorBufferInfo
	TexelBufferView []BufferView

	common.NextOptions
}

func (WriteDescriptorSet) PopulateCPointer 

func (o WriteDescriptorSet) PopulateCPointer(allocator *cgoparam.Allocator, preallocatedPointer unsafe.Pointer, next unsafe.Pointer) (unsafe.Pointer, error)

type WriteDescriptorSetExtensionSource 

type WriteDescriptorSetExtensionSource interface {
	WriteDescriptorSetCount() int
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.