/////////////////
/// Queue capabilities
-bitfield VkQueueFlags {
+type VkFlags VkQueueFlags
+bitfield VkQueueFlagBits {
VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations
VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
}
/// Memory properties passed into vkAllocMemory().
-bitfield VkMemoryPropertyFlags {
+type VkFlags VkMemoryPropertyFlags
+bitfield VkMemoryPropertyFlagBits {
VK_MEMORY_PROPERTY_DEVICE_ONLY = 0x00000000, /// If otherwise stated, then allocate memory on device
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001, /// Memory should be mappable by host
VK_MEMORY_PROPERTY_HOST_NON_COHERENT_BIT = 0x00000002, /// Memory may not have i/o coherency so vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges must be used flush/invalidate host cache
}
/// Memory heap flags
-bitfield VkMemoryHeapFlags {
+type VkFlags VkMemoryHeapFlags
+bitfield VkMemoryHeapFlagBits {
VK_MEMORY_HEAP_HOST_LOCAL_BIT = 0x00000001, /// If set, heap represents host memory
}
/// Memory output flags passed to resource transition commands
-bitfield VkMemoryOutputFlags {
+type VkFlags VkMemoryOutputFlags
+bitfield VkMemoryOutputFlagBits {
VK_MEMORY_OUTPUT_HOST_WRITE_BIT = 0x00000001, /// Controls output coherency of host writes
VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, /// Controls output coherency of generic shader writes
VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, /// Controls output coherency of color attachment writes
}
/// Memory input flags passed to resource transition commands
-bitfield VkMemoryInputFlags {
+type VkFlags VkMemoryInputFlags
+bitfield VkMemoryInputFlagBits {
VK_MEMORY_INPUT_HOST_READ_BIT = 0x00000001, /// Controls input coherency of host reads
VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, /// Controls input coherency of indirect command reads
VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, /// Controls input coherency of index fetches
}
/// Buffer usage flags
-bitfield VkBufferUsageFlags {
+type VkFlags VkBufferUsageFlags
+bitfield VkBufferUsageFlagBits {
VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO
}
/// Buffer creation flags
-bitfield VkBufferCreateFlags {
+type VkFlags VkBufferCreateFlags
+bitfield VkBufferCreateFlagBits {
VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Buffer should support sparse backing
VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Buffer should support sparse backing with partial residency
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Buffer should support constent data access to physical memory blocks mapped into multiple locations of sparse buffers
}
/// Shader stage flags
-bitfield VkShaderStageFlags {
+type VkFlags VkShaderStageFlags
+bitfield VkShaderStageFlagBits {
VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
}
/// Descriptor pool create flags
-bitfield VkDescriptorPoolCreateFlags {
+type VkFlags VkDescriptorPoolCreateFlags
+bitfield VkDescriptorPoolCreateFlagBits {
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
}
/// Descriptor pool reset flags
-bitfield VkDescriptorPoolResetFlags {
+type VkFlags VkDescriptorPoolResetFlags
+bitfield VkDescriptorPoolResetFlagBits {
}
/// Image usage flags
-bitfield VkImageUsageFlags {
+type VkFlags VkImageUsageFlags
+bitfield VkImageUsageFlagBits {
VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
}
/// Image creation flags
-bitfield VkImageCreateFlags {
+type VkFlags VkImageCreateFlags
+bitfield VkImageCreateFlagBits {
VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, /// Image should support sparse backing
VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, /// Image should support sparse backing with partial residency
VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, /// Image should support constent data access to physical memory blocks mapped into multiple locations of sparse images
}
/// Framebuffer attachment view creation flags
-bitfield VkImageViewCreateFlags {
+type VkFlags VkImageViewCreateFlags
+bitfield VkImageViewCreateFlagBits {
VK_IMAGE_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
VK_IMAGE_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
}
/// Pipeline creation flags
-bitfield VkPipelineCreateFlags {
+type VkFlags VkPipelineCreateFlags
+bitfield VkPipelineCreateFlagBits {
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
}
/// Channel flags
-bitfield VkChannelFlags {
+type VkFlags VkChannelFlags
+bitfield VkChannelFlagBits {
VK_CHANNEL_R_BIT = 0x00000001,
VK_CHANNEL_G_BIT = 0x00000002,
VK_CHANNEL_B_BIT = 0x00000004,
}
/// Fence creation flags
-bitfield VkFenceCreateFlags {
+type VkFlags VkFenceCreateFlags
+bitfield VkFenceCreateFlagBits {
VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
}
/// Semaphore creation flags
-bitfield VkSemaphoreCreateFlags {
+type VkFlags VkSemaphoreCreateFlags
+bitfield VkSemaphoreCreateFlagBits {
}
/// Format capability flags
-bitfield VkFormatFeatureFlags {
+type VkFlags VkFormatFeatureFlags
+bitfield VkFormatFeatureFlagBits {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, /// Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, /// Format can be used for storage images (STORAGE_IMAGE descriptor type)
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, /// Format supports atomic operations in case it's used for storage images
}
/// Query control flags
-bitfield VkQueryControlFlags {
+type VkFlags VkQueryControlFlags
+bitfield VkQueryControlFlagBits {
VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, /// Allow conservative results to be collected by the query
}
/// Query result flags
-bitfield VkQueryResultFlags {
+type VkFlags VkQueryResultFlags
+bitfield VkQueryResultFlagBits {
VK_QUERY_RESULT_DEFAULT = 0x00000000, /// Results of the queries are immediately written to the destination buffer as 32-bit values
VK_QUERY_RESULT_64_BIT = 0x00000001, /// Results of the queries are written to the destination buffer as 64-bit values
VK_QUERY_RESULT_WAIT_BIT = 0x00000002, /// Results of the queries are waited on before proceeding with the result copy
}
/// Shader module creation flags
-bitfield VkShaderModuleCreateFlags {
+type VkFlags VkShaderModuleCreateFlags
+bitfield VkShaderModuleCreateFlagBits {
}
/// Shader creation flags
-bitfield VkShaderCreateFlags {
+type VkFlags VkShaderCreateFlags
+bitfield VkShaderCreateFlagBits {
}
/// Event creation flags
-bitfield VkEventCreateFlags {
+type VkFlags VkEventCreateFlags
+bitfield VkEventCreateFlagBits {
}
/// Command buffer usage flags
-bitfield VkCmdBufferUsageFlags {
+type VkFlags VkCmdBufferUsageFlags
+bitfield VkCmdBufferUsageFlagBits {
VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
}
/// Pipeline statistics flags
-bitfield VkQueryPipelineStatisticFlags {
+type VkFlags VkQueryPipelineStatisticFlags
+bitfield VkQueryPipelineStatisticFlagBits {
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, /// Optional
VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, /// Optional
VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, /// Optional
}
/// Memory mapping flags
-bitfield VkMemoryMapFlags {
+type VkFlags VkMemoryMapFlags
+bitfield VkMemoryMapFlagBits {
}
/// Bitfield of image aspects
-bitfield VkImageAspectFlags {
+type VkFlags VkImageAspectFlags
+bitfield VkImageAspectFlagBits {
VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
}
/// Sparse memory bind flags
-bitfield VkSparseMemoryBindFlags {
+type VkFlags VkSparseMemoryBindFlags
+bitfield VkSparseMemoryBindFlagBits {
VK_SPARSE_MEMORY_BIND_REPLICATE_BLOCK_BIT = 0x00000001,
}
/// Sparse image memory requirements flags
-bitfield VkSparseImageFormatFlags {
+type VkFlags VkSparseImageFormatFlags
+bitfield VkSparseImageFormatFlagBits {
VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001, /// Image uses a single miptail region for all array slices
VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002, /// Image requires mip levels to be an exact multiple of the sparse iamge block size for non-mip-tail levels.
VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004, /// Image uses a non-standard sparse block size
}
/// Pipeline stages
-bitfield VkPipelineStageFlags {
+type VkFlags VkPipelineStageFlags
+bitfield VkPipelineStageFlagBits {
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, /// Before subsequent commands are processed
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, /// Draw/DispatchIndirect command fetch
VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, /// Vertex/index fetch
}
/// Render pass attachment description flags
-bitfield VkAttachmentDescriptionFlags {
+type VkFlags VkAttachmentDescriptionFlags
+bitfield VkAttachmentDescriptionFlagBits {
VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, /// The attachment may alias physical memory of another attachment in the same renderpass
}
/// Subpass description flags
-bitfield VkSubpassDescriptionFlags {
+type VkFlags VkSubpassDescriptionFlags
+bitfield VkSubpassDescriptionFlagBits {
}
/// Command pool creation flags
-bitfield VkCmdPoolCreateFlags {
+type VkFlags VkCmdPoolCreateFlags
+bitfield VkCmdPoolCreateFlagBits {
VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
}
/// Command pool reset flags
-bitfield VkCmdPoolResetFlags {
+type VkFlags VkCmdPoolResetFlags
+bitfield VkCmdPoolResetFlagBits {
VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
}
-bitfield VkCmdBufferResetFlags {
+type VkFlags VkCmdBufferResetFlags
+bitfield VkCmdBufferResetFlagBits {
VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
}
-bitfield VkSampleCountFlags {
+type VkFlags VkSampleCountFlags
+bitfield VkSampleCountFlagBits {
VK_SAMPLE_COUNT_1_BIT = 0x00000001,
VK_SAMPLE_COUNT_2_BIT = 0x00000002,
VK_SAMPLE_COUNT_4_BIT = 0x00000004,
VK_SAMPLE_COUNT_64_BIT = 0x00000040,
}
-bitfield VkStencilFaceFlags {
+type VkFlags VkStencilFaceFlags
+bitfield VkStencilFaceFlagBits {
VK_STENCIL_FACE_NONE = 0x00000000, /// No faces
VK_STENCIL_FACE_FRONT_BIT = 0x00000001, /// Front face
VK_STENCIL_FACE_BACK_BIT = 0x00000002, /// Back face
}
@extension("VK_EXT_KHR_swapchain")
-bitfield VkSurfaceTransformFlagsKHR {
+type VkFlags VkSurfaceTransformFlagsKHR
+@extension("VK_EXT_KHR_swapchain")
+bitfield VkSurfaceTransformFlagBitsKHR {
VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
VK_SURFACE_TRANSFORM_ROT90_BIT_KHR = 0x00000002,
VK_SURFACE_TRANSFORM_ROT180_BIT_KHR = 0x00000004,
}
@extension("VK_EXT_KHR_display")
-bitfield VkDisplayPlaneAlphaFlagsKHR {
+type VkFlags VkDisplayPlaneAlphaFlagsKHR
+@extension("VK_EXT_KHR_display")
+bitfield VkDisplayPlaneAlphaFlagBitsKHR {
VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000001,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000002,
VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000004,
}
class VkSparseImageFormatProperties {
- VkImageAspectFlags aspect
+ VkImageAspectFlagBits aspect
VkExtent3D imageGranularity
VkSparseImageFormatFlags flags
}
}
class VkImageSubresource {
- VkImageAspectFlags aspect
+ VkImageAspectFlagBits aspect
u32 mipLevel
u32 arrayLayer
}
VkShaderModule module /// Module containing entry point
const char* pName /// Null-terminated entry point name
VkShaderCreateFlags flags /// Reserved
- VkShaderStageFlags stage
+ VkShaderStageFlagBits stage
}
class VkDescriptorSetLayoutBinding {
fence := ?
pFence[0] = fence
State.Fences[fence] = new!FenceObject(
- device: device, signaled: (pCreateInfo.flags == VK_FENCE_CREATE_SIGNALED_BIT))
+ device: device, signaled: (pCreateInfo.flags == as!VkFenceCreateFlags(VK_FENCE_CREATE_SIGNALED_BIT)))
return ?
}
pipelineObject := GetPipeline(pipeline)
assert(cmdBufferObject.device == pipelineObject.device)
- queueFlags := cmdBufferObject.queueFlags | switch (pipelineBindPoint) {
+ queue := switch (pipelineBindPoint) {
case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
}
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
}
@threadSafety("app")
u32 viewportCount,
const VkViewport* pViewports) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
u32 scissorCount,
const VkRect2D* pScissors) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
VkCmdBuffer cmdBuffer,
f32 lineWidth) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
f32 depthBiasClamp,
f32 depthBiasSlopeFactor) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
// having to modify the AST and semantic model.
@readonly f32[4] blendConst) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
f32 minDepthBounds,
f32 maxDepthBounds) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
VkStencilFaceFlags faceMask,
u32 stencilCompareMask) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
VkStencilFaceFlags faceMask,
u32 stencilWriteMask) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
VkStencilFaceFlags faceMask,
u32 stencilReference) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
dynamicOffset := dynamicOffsets[i]
}
- queueFlags := cmdBufferObject.queueFlags | switch (pipelineBindPoint) {
+ queue := switch (pipelineBindPoint) {
case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
}
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
}
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
u32 firstInstance) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
u32 firstInstance) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
u32 z) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_COMPUTE_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_COMPUTE_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
destBufferObject := GetBuffer(destBuffer)
assert(cmdBufferObject.device == destBufferObject.device)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_DMA_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, image, imageObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, image, imageObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
rect := rects[i]
}
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
assert(cmdBufferObject.device == renderPassObject.device)
assert(cmdBufferObject.device == framebufferObject.device)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
cmd void vkCmdNextSubpass(
VkCmdBuffer cmdBuffer) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- queueFlags := cmdBufferObject.queueFlags | VK_QUEUE_GRAPHICS_BIT
- cmdBufferObject.queueFlags = queueFlags
+ cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
cmd void vkCmdExecuteCommands(
assert(swapchain in State.Swapchains)
return State.Swapchains[swapchain]
}
+
+macro VkQueueFlags AddQueueFlag(VkQueueFlags flags, VkQueueFlagBits bit) {
+ return as!VkQueueFlags(as!u32(flags) | as!u32(bit))
+}