// API version (major.minor.patch)
define VERSION_MAJOR 0
-define VERSION_MINOR 177
+define VERSION_MINOR 179
define VERSION_PATCH 0
// API limits
VK_ERROR_MEMORY_MAP_FAILED = 0xFFFFFFFB,
VK_ERROR_LAYER_NOT_PRESENT = 0xFFFFFFFA,
VK_ERROR_EXTENSION_NOT_PRESENT = 0xFFFFFFF9,
- VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF8,
+ VK_ERROR_FEATURE_NOT_PRESENT = 0xFFFFFFF8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = 0xFFFFFFF7,
}
enum VkDynamicState {
return ?
}
-cmd VkResult vkGetPhysicalDeviceProperties(
+cmd void vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties) {
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
properties := ?
pProperties[0] = properties
-
- return ?
}
-cmd VkResult vkGetPhysicalDeviceQueueFamilyProperties(
+cmd void vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
u32* pCount,
VkQueueFamilyProperties* pQueueFamilyProperties) {
// count := ?
// pCount[0] = count
// }
- return ?
}
-cmd VkResult vkGetPhysicalDeviceMemoryProperties(
+cmd void vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
memoryProperties := ?
pMemoryProperties[0] = memoryProperties
-
- return ?
}
-cmd VkResult vkGetPhysicalDeviceFeatures(
+cmd void vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures) {
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
features := ?
pFeatures[0] = features
-
- return ?
}
-cmd VkResult vkGetPhysicalDeviceFormatProperties(
+cmd void vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties) {
formatProperties := ?
pFormatProperties[0] = formatProperties
-
- return ?
}
-cmd VkResult vkGetPhysicalDeviceImageFormatProperties(
+cmd void vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
imageFormatProperties := ?
pImageFormatProperties[0] = imageFormatProperties
-
- return ?
}
// Queue functions
@threadSafety("system")
-cmd VkResult vkGetDeviceQueue(
+cmd void vkGetDeviceQueue(
VkDevice device,
u32 queueFamilyIndex,
u32 queueIndex,
if !(queue in State.Queues) {
State.Queues[queue] = new!QueueObject(device: device)
}
-
- return ?
}
@threadSafety("app")
// Memory management API functions
-cmd VkResult vkGetDeviceMemoryCommitment(
+cmd void vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes) {
committedMemoryInBytes := ?
pCommittedMemoryInBytes[0] = committedMemoryInBytes
-
- return ?
}
-cmd VkResult vkGetBufferMemoryRequirements(
+cmd void vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements) {
deviceObject := GetDevice(device)
bufferObject := GetBuffer(buffer)
assert(bufferObject.device == device)
-
- return ?
}
cmd VkResult vkBindBufferMemory(
return ?
}
-cmd VkResult vkGetImageMemoryRequirements(
+cmd void vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements) {
deviceObject := GetDevice(device)
imageObject := GetImage(image)
assert(imageObject.device == device)
-
- return ?
}
cmd VkResult vkBindImageMemory(
return ?
}
-cmd VkResult vkGetImageSparseMemoryRequirements(
+cmd void vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
u32* pNumRequirements,
deviceObject := GetDevice(device)
imageObject := GetImage(image)
assert(imageObject.device == device)
-
- return ?
}
-cmd VkResult vkGetPhysicalDeviceSparseImageFormatProperties(
+cmd void vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
u32* pNumProperties,
VkSparseImageFormatProperties* pProperties) {
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
-
- return ?
}
cmd VkResult vkQueueBindSparseBufferMemory(
State.Images[image] = null
}
-cmd VkResult vkGetImageSubresourceLayout(
+cmd void vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
deviceObject := GetDevice(device)
imageObject := GetImage(image)
assert(imageObject.device == device)
-
- return ?
}
cmd VkResult vkGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
+ platform.size_t dataSize,
void* pData) {
deviceObject := GetDevice(device)
pipelineCacheObject := GetPipelineCache(pipelineCache)
State.RenderPasses[renderPass] = null
}
-cmd VkResult vkGetRenderAreaGranularity(
+cmd void vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity) {
granularity := ?
pGranularity[0] = granularity
-
- return ?
}
// Command pool functions
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 177, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 179, 0)
#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
VK_ERROR_MEMORY_MAP_FAILED = -5,
VK_ERROR_LAYER_NOT_PRESENT = -6,
VK_ERROR_EXTENSION_NOT_PRESENT = -7,
- VK_ERROR_INCOMPATIBLE_DRIVER = -8,
+ VK_ERROR_FEATURE_NOT_PRESENT = -8,
+ VK_ERROR_INCOMPATIBLE_DRIVER = -9,
VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
VK_RESULT_END_RANGE = VK_INCOMPLETE,
VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
-typedef VkResult (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
-typedef VkResult (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
typedef size_t (VKAPI *PFN_vkGetPipelineCacheSize)(VkDevice device, VkPipelineCache pipelineCache);
-typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, void* pData);
+typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
-typedef VkResult (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices);
-VkResult VKAPI vkGetPhysicalDeviceFeatures(
+void VKAPI vkGetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures);
-VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+void VKAPI vkGetPhysicalDeviceFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties);
-VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(
+void VKAPI vkGetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties);
-VkResult VKAPI vkGetPhysicalDeviceProperties(
+void VKAPI vkGetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties);
-VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
+void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkQueueFamilyProperties* pQueueFamilyProperties);
-VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+void VKAPI vkGetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties);
uint32_t* pCount,
VkLayerProperties* pProperties);
-VkResult VKAPI vkGetDeviceQueue(
+void VKAPI vkGetDeviceQueue(
VkDevice device,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
uint32_t memRangeCount,
const VkMappedMemoryRange* pMemRanges);
-VkResult VKAPI vkGetDeviceMemoryCommitment(
+void VKAPI vkGetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes);
VkDeviceMemory mem,
VkDeviceSize memOffset);
-VkResult VKAPI vkGetBufferMemoryRequirements(
+void VKAPI vkGetBufferMemoryRequirements(
VkDevice device,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements);
-VkResult VKAPI vkGetImageMemoryRequirements(
+void VKAPI vkGetImageMemoryRequirements(
VkDevice device,
VkImage image,
VkMemoryRequirements* pMemoryRequirements);
-VkResult VKAPI vkGetImageSparseMemoryRequirements(
+void VKAPI vkGetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pNumRequirements,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkDevice device,
VkImage image);
-VkResult VKAPI vkGetImageSubresourceLayout(
+void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
VkImage image,
const VkImageSubresource* pSubresource,
VkResult VKAPI vkGetPipelineCacheData(
VkDevice device,
VkPipelineCache pipelineCache,
+ size_t dataSize,
void* pData);
VkResult VKAPI vkMergePipelineCaches(
VkDevice device,
VkRenderPass renderPass);
-VkResult VKAPI vkGetRenderAreaGranularity(
+void VKAPI vkGetRenderAreaGranularity(
VkDevice device,
VkRenderPass renderPass,
VkExtent2D* pGranularity);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
+void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceProperties(physicalDevice, pProperties);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
+void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
+void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
+void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
+void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+void vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
- return vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
+void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {
+ vulkan::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
- return GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
+void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+ GetVtbl(device).GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
}
__attribute__((visibility("default")))
-VkResult vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
- return GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
+ GetVtbl(device).GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
- return GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
+void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
+ GetVtbl(device).GetImageMemoryRequirements(device, image, pMemoryRequirements);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
- return GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+ GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
}
__attribute__((visibility("default")))
-VkResult vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
- return GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
- return GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
+void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+ GetVtbl(device).GetImageSubresourceLayout(device, image, pSubresource, pLayout);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
- return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, pData);
+VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
+ return GetVtbl(device).GetPipelineCacheData(device, pipelineCache, dataSize, pData);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VkResult vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
- return GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
+void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+ GetVtbl(device).GetRenderAreaGranularity(device, renderPass, pGranularity);
}
__attribute__((visibility("default")))
return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
- VkPhysicalDeviceFeatures* features) {
- return GetVtbl(pdev)
- ->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
+void GetPhysicalDeviceFeaturesBottom(VkPhysicalDevice pdev,
+ VkPhysicalDeviceFeatures* features) {
+ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFeatures(pdev, features);
}
-VkResult GetPhysicalDeviceFormatPropertiesBottom(
- VkPhysicalDevice pdev,
- VkFormat format,
- VkFormatProperties* properties) {
- return GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
+void GetPhysicalDeviceFormatPropertiesBottom(VkPhysicalDevice pdev,
+ VkFormat format,
+ VkFormatProperties* properties) {
+ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceFormatProperties(
pdev, format, properties);
}
-VkResult GetPhysicalDeviceImageFormatPropertiesBottom(
+void GetPhysicalDeviceImageFormatPropertiesBottom(
VkPhysicalDevice pdev,
VkFormat format,
VkImageType type,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkImageFormatProperties* properties) {
- return GetVtbl(pdev)
- ->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
- pdev, format, type, tiling, usage, flags, properties);
+ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceImageFormatProperties(
+ pdev, format, type, tiling, usage, flags, properties);
}
-VkResult GetPhysicalDevicePropertiesBottom(
- VkPhysicalDevice pdev,
- VkPhysicalDeviceProperties* properties) {
- return GetVtbl(pdev)
+void GetPhysicalDevicePropertiesBottom(VkPhysicalDevice pdev,
+ VkPhysicalDeviceProperties* properties) {
+ GetVtbl(pdev)
->instance->drv.vtbl.GetPhysicalDeviceProperties(pdev, properties);
}
-VkResult GetPhysicalDeviceQueueFamilyPropertiesBottom(
+void GetPhysicalDeviceQueueFamilyPropertiesBottom(
VkPhysicalDevice pdev,
uint32_t* pCount,
VkQueueFamilyProperties* properties) {
- return GetVtbl(pdev)
- ->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
- pdev, pCount, properties);
+ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceQueueFamilyProperties(
+ pdev, pCount, properties);
}
-VkResult GetPhysicalDeviceMemoryPropertiesBottom(
+void GetPhysicalDeviceMemoryPropertiesBottom(
VkPhysicalDevice pdev,
VkPhysicalDeviceMemoryProperties* properties) {
- return GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
+ GetVtbl(pdev)->instance->drv.vtbl.GetPhysicalDeviceMemoryProperties(
pdev, properties);
}
pdev, properties_count, properties);
}
-VkResult GetPhysicalDeviceSparseImageFormatPropertiesBottom(
+void GetPhysicalDeviceSparseImageFormatPropertiesBottom(
VkPhysicalDevice pdev,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
uint32_t* properties_count,
VkSparseImageFormatProperties* properties) {
- return GetVtbl(pdev)
+ GetVtbl(pdev)
->instance->drv.vtbl.GetPhysicalDeviceSparseImageFormatProperties(
pdev, format, type, samples, usage, tiling, properties_count,
properties);
return GetSpecificDeviceProcAddr(GetVtbl(device), name);
}
-VkResult GetDeviceQueue(VkDevice drv_device,
- uint32_t family,
- uint32_t index,
- VkQueue* out_queue) {
+void GetDeviceQueue(VkDevice drv_device,
+ uint32_t family,
+ uint32_t index,
+ VkQueue* out_queue) {
VkResult result;
VkQueue queue;
const DeviceVtbl* vtbl = GetVtbl(drv_device);
- result = vtbl->GetDeviceQueue(drv_device, family, index, &queue);
- if (result != VK_SUCCESS)
- return result;
+ vtbl->GetDeviceQueue(drv_device, family, index, &queue);
hwvulkan_dispatch_t* dispatch =
reinterpret_cast<hwvulkan_dispatch_t*>(queue);
- if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != vtbl) {
+ if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != vtbl)
ALOGE("invalid VkQueue dispatch magic: 0x%" PRIxPTR, dispatch->magic);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
dispatch->vtbl = vtbl;
*out_queue = queue;
- return VK_SUCCESS;
}
VkResult CreateCommandBuffer(VkDevice drv_device,
VkInstance* instance);
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
-VkResult GetDeviceQueue(VkDevice drv_device,
- uint32_t family,
- uint32_t index,
- VkQueue* out_queue);
+void GetDeviceQueue(VkDevice drv_device,
+ uint32_t family,
+ uint32_t index,
+ VkQueue* out_queue);
VkResult CreateCommandBuffer(VkDevice device,
const VkCmdBufferCreateInfo* create_info,
VkCmdBuffer* out_cmdbuf);
std::shared_ptr<ANativeWindow> window = InitSharedPtr(
device, static_cast<ANativeWindow*>(
reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(
- create_info->pSurfaceDescription)
- ->pPlatformWindow));
+ create_info->pSurfaceDescription)->pPlatformWindow));
// TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
err = native_window_api_connect(window.get(), NATIVE_WINDOW_API_EGL);
return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceProperties(VkPhysicalDevice,
- VkPhysicalDeviceProperties* properties) {
+void GetPhysicalDeviceProperties(VkPhysicalDevice,
+ VkPhysicalDeviceProperties* properties) {
properties->apiVersion = VK_API_VERSION;
properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
properties->vendorId = 0;
strcpy(properties->deviceName, "Android Vulkan Null Driver");
memset(properties->pipelineCacheUUID, 0,
sizeof(properties->pipelineCacheUUID));
- return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceQueueFamilyProperties(
+void GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice,
uint32_t* count,
VkQueueFamilyProperties* properties) {
if (properties) {
- if (*count < 1)
- return VK_INCOMPLETE;
properties->queueFlags =
VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT;
properties->queueCount = 1;
properties->timestampValidBits = 64;
}
*count = 1;
- return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceMemoryProperties(
+void GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice,
VkPhysicalDeviceMemoryProperties* properties) {
properties->memoryTypeCount = 1;
properties->memoryHeapCount = 1;
properties->memoryHeaps[0].size = kMaxDeviceMemory;
properties->memoryHeaps[0].flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT;
- return VK_SUCCESS;
}
// -----------------------------------------------------------------------------
alloc->pfnFree(alloc->pUserData, device);
}
-VkResult GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
+void GetDeviceQueue(VkDevice device, uint32_t, uint32_t, VkQueue* queue) {
*queue = &device->queue;
- return VK_SUCCESS;
}
// -----------------------------------------------------------------------------
return VK_SUCCESS;
}
-VkResult GetBufferMemoryRequirements(VkDevice,
- VkBuffer buffer_handle,
- VkMemoryRequirements* requirements) {
+void GetBufferMemoryRequirements(VkDevice,
+ VkBuffer buffer_handle,
+ VkMemoryRequirements* requirements) {
Buffer* buffer = GetObjectFromHandle(buffer_handle);
requirements->size = buffer->size;
requirements->alignment = 16; // allow fast Neon/SSE memcpy
requirements->memoryTypeBits = 0x1;
- return VK_SUCCESS;
}
void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
return VK_SUCCESS;
}
-VkResult GetImageMemoryRequirements(VkDevice,
- VkImage image_handle,
- VkMemoryRequirements* requirements) {
+void GetImageMemoryRequirements(VkDevice,
+ VkImage image_handle,
+ VkMemoryRequirements* requirements) {
Image* image = GetObjectFromHandle(image_handle);
requirements->size = image->size;
requirements->alignment = 16; // allow fast Neon/SSE memcpy
requirements->memoryTypeBits = 0x1;
- return VK_SUCCESS;
}
void DestroyImage(VkDevice device, VkImage image_handle) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
-VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
+void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
+void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
+void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
return VK_SUCCESS;
}
-VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
+void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
return VK_SUCCESS;
}
-VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
-VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
+void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
void DestroyBufferView(VkDevice device, VkBufferView bufferView) {
}
-VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
+void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
void DestroyImageView(VkDevice device, VkImageView imageView) {
return VK_SUCCESS;
}
-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData) {
+VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData) {
ALOGV("TODO: vk%s", __FUNCTION__);
return VK_SUCCESS;
}
void DestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
}
-VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
+void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
ALOGV("TODO: vk%s", __FUNCTION__);
- return VK_SUCCESS;
}
void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
// clang-format off
void DestroyInstance(VkInstance instance);
VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
-VkResult GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
-VkResult GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
-VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
-VkResult GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-VkResult GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
-VkResult GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+void GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
-VkResult GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
VkResult QueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
VkResult QueueWaitIdle(VkQueue queue);
VkResult DeviceWaitIdle(VkDevice device);
void UnmapMemory(VkDevice device, VkDeviceMemory mem);
VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
-VkResult GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
-VkResult GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-VkResult GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-VkResult GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-VkResult GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
VkResult QueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
VkResult QueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
VkResult QueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
void DestroyBufferView(VkDevice device, VkBufferView bufferView);
VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
void DestroyImage(VkDevice device, VkImage image);
-VkResult GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
void DestroyImageView(VkDevice device, VkImageView imageView);
VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache);
size_t GetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache);
-VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData);
+VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t dataSize, void* pData);
VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer);
VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
void DestroyRenderPass(VkDevice device, VkRenderPass renderPass);
-VkResult GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool);
VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
};
template <size_t N>
-PFN_vkVoidFunction LookupProcAddr(const NameProcEntry (&table)[N],
+PFN_vkVoidFunction LookupProcAddr(const NameProcEntry(&table)[N],
const char* name) {
auto entry = std::lower_bound(table, table + N, name,
[](const NameProcEntry& e, const char* n) {
std::ostringstream strbuf;
VkPhysicalDeviceProperties props;
- result = vkGetPhysicalDeviceProperties(pdev, &props);
- if (result != VK_SUCCESS)
- die("vkGetPhysicalDeviceProperties", result);
+ vkGetPhysicalDeviceProperties(pdev, &props);
printf(" %u: \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", idx,
props.deviceName, VkPhysicalDeviceTypeStr(props.deviceType),
(props.apiVersion >> 22) & 0x3FF, (props.apiVersion >> 12) & 0x3FF,
props.deviceId);
VkPhysicalDeviceMemoryProperties mem_props;
- result = vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
- if (result != VK_SUCCESS)
- die("vkGetPhysicalDeviceMemoryProperties", result);
+ vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
for (uint32_t heap = 0; heap < mem_props.memoryHeapCount; heap++) {
if ((mem_props.memoryHeaps[heap].flags &
VK_MEMORY_HEAP_HOST_LOCAL_BIT) != 0)
}
uint32_t num_queue_families;
- result = vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
- nullptr);
- if (result != VK_SUCCESS)
- die("vkGetPhysicalDeviceQueueFamilyProperties (count)", result);
+ vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
+ nullptr);
std::vector<VkQueueFamilyProperties> queue_family_properties(
num_queue_families);
- result = vkGetPhysicalDeviceQueueFamilyProperties(
- pdev, &num_queue_families, queue_family_properties.data());
- if (result != VK_SUCCESS)
- die("vkGetPhysicalDeviceQueueFamilyProperties (values)", result);
+ vkGetPhysicalDeviceQueueFamilyProperties(pdev, &num_queue_families,
+ queue_family_properties.data());
for (uint32_t family = 0; family < num_queue_families; family++) {
const VkQueueFamilyProperties& qprops = queue_family_properties[family];
const char* sep = "";
OSDN Git Service
