You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1459 lines
59 KiB
1459 lines
59 KiB
" ""VK API description""" |
|
|
|
# Copyright (c) 2015-2016 The Khronos Group Inc. |
|
# Copyright (c) 2015-2016 Valve Corporation |
|
# Copyright (c) 2015-2016 LunarG, Inc. |
|
# Copyright (c) 2015-2016 Google Inc. |
|
# |
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
|
# you may not use this file except in compliance with the License. |
|
# You may obtain a copy of the License at |
|
# |
|
# http://www.apache.org/licenses/LICENSE-2.0 |
|
# |
|
# Unless required by applicable law or agreed to in writing, software |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
# See the License for the specific language governing permissions and |
|
# limitations under the License. |
|
# |
|
# Author: Chia-I Wu <olv@lunarg.com> |
|
# Author: Jon Ashburn <jon@lunarg.com> |
|
# Author: Courtney Goeltzenleuchter <courtney@LunarG.com> |
|
# Author: Tobin Ehlis <tobin@lunarg.com> |
|
# Author: Tony Barbour <tony@LunarG.com> |
|
# Author: Gwan-gyeong Mun <kk.moon@samsung.com> |
|
|
|
class Param(object): |
|
"""A function parameter.""" |
|
|
|
def __init__(self, ty, name): |
|
self.ty = ty |
|
self.name = name |
|
|
|
def c(self): |
|
"""Return the parameter in C.""" |
|
idx = self.ty.find("[") |
|
|
|
# arrays have a different syntax |
|
if idx >= 0: |
|
return "%s %s%s" % (self.ty[:idx], self.name, self.ty[idx:]) |
|
else: |
|
return "%s %s" % (self.ty, self.name) |
|
|
|
def indirection_level(self): |
|
"""Return the level of indirection.""" |
|
return self.ty.count("*") + self.ty.count("[") |
|
|
|
def dereferenced_type(self, level=0): |
|
"""Return the type after dereferencing.""" |
|
if not level: |
|
level = self.indirection_level() |
|
|
|
deref = self.ty if level else "" |
|
while level > 0: |
|
idx = deref.rfind("[") |
|
if idx < 0: |
|
idx = deref.rfind("*") |
|
if idx < 0: |
|
deref = "" |
|
break |
|
deref = deref[:idx] |
|
level -= 1; |
|
|
|
return deref.rstrip() |
|
|
|
class Proto(object): |
|
"""A function prototype.""" |
|
|
|
def __init__(self, ret, name, params=[]): |
|
# the proto has only a param |
|
if not isinstance(params, list): |
|
params = [params] |
|
|
|
self.ret = ret |
|
self.name = name |
|
self.params = params |
|
|
|
def c_params(self, need_type=True, need_name=True): |
|
"""Return the parameter list in C.""" |
|
if self.params and (need_type or need_name): |
|
if need_type and need_name: |
|
return ", ".join([param.c() for param in self.params]) |
|
elif need_type: |
|
return ", ".join([param.ty for param in self.params]) |
|
else: |
|
return ", ".join([param.name for param in self.params]) |
|
else: |
|
return "void" if need_type else "" |
|
|
|
def c_decl(self, name, attr="", typed=False, need_param_names=True): |
|
"""Return a named declaration in C.""" |
|
if typed: |
|
return "%s (%s*%s)(%s)" % ( |
|
self.ret, |
|
attr + "_PTR " if attr else "", |
|
name, |
|
self.c_params(need_name=need_param_names)) |
|
else: |
|
return "%s%s %s%s(%s)" % ( |
|
attr + "_ATTR " if attr else "", |
|
self.ret, |
|
attr + "_CALL " if attr else "", |
|
name, |
|
self.c_params(need_name=need_param_names)) |
|
|
|
def c_pretty_decl(self, name, attr=""): |
|
"""Return a named declaration in C, with vulkan.h formatting.""" |
|
plist = [] |
|
for param in self.params: |
|
idx = param.ty.find("[") |
|
if idx < 0: |
|
idx = len(param.ty) |
|
|
|
pad = 44 - idx |
|
if pad <= 0: |
|
pad = 1 |
|
|
|
plist.append(" %s%s%s%s" % (param.ty[:idx], |
|
" " * pad, param.name, param.ty[idx:])) |
|
|
|
return "%s%s %s%s(\n%s)" % ( |
|
attr + "_ATTR " if attr else "", |
|
self.ret, |
|
attr + "_CALL " if attr else "", |
|
name, |
|
",\n".join(plist)) |
|
|
|
def c_func(self, prefix="", attr=""): |
|
"""Return the prototype in C.""" |
|
return self.c_decl(prefix + self.name, attr=attr, typed=False) |
|
|
|
def c_call(self): |
|
"""Return a call to the prototype in C.""" |
|
return "%s(%s)" % (self.name, self.c_params(need_type=False)) |
|
|
|
def object_in_params(self): |
|
"""Return the params that are simple VK objects and are inputs.""" |
|
return [param for param in self.params if param.ty in objects] |
|
|
|
def object_out_params(self): |
|
"""Return the params that are simple VK objects and are outputs.""" |
|
return [param for param in self.params |
|
if param.dereferenced_type() in objects] |
|
|
|
def __repr__(self): |
|
param_strs = [] |
|
for param in self.params: |
|
param_strs.append(str(param)) |
|
param_str = " [%s]" % (",\n ".join(param_strs)) |
|
|
|
return "Proto(\"%s\", \"%s\",\n%s)" % \ |
|
(self.ret, self.name, param_str) |
|
|
|
class Extension(object): |
|
def __init__(self, name, headers, objects, protos, ifdef = None): |
|
self.name = name |
|
self.headers = headers |
|
self.objects = objects |
|
self.protos = protos |
|
self.ifdef = ifdef |
|
|
|
# VK core API |
|
core = Extension( |
|
name="VK_CORE", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[ |
|
"VkInstance", |
|
"VkPhysicalDevice", |
|
"VkDevice", |
|
"VkQueue", |
|
"VkSemaphore", |
|
"VkCommandBuffer", |
|
"VkFence", |
|
"VkDeviceMemory", |
|
"VkBuffer", |
|
"VkImage", |
|
"VkEvent", |
|
"VkQueryPool", |
|
"VkBufferView", |
|
"VkImageView", |
|
"VkShaderModule", |
|
"VkPipelineCache", |
|
"VkPipelineLayout", |
|
"VkRenderPass", |
|
"VkPipeline", |
|
"VkDescriptorSetLayout", |
|
"VkSampler", |
|
"VkDescriptorPool", |
|
"VkDescriptorSet", |
|
"VkFramebuffer", |
|
"VkCommandPool", |
|
], |
|
protos=[ |
|
Proto("VkResult", "CreateInstance", |
|
[Param("const VkInstanceCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkInstance*", "pInstance")]), |
|
|
|
Proto("void", "DestroyInstance", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "EnumeratePhysicalDevices", |
|
[Param("VkInstance", "instance"), |
|
Param("uint32_t*", "pPhysicalDeviceCount"), |
|
Param("VkPhysicalDevice*", "pPhysicalDevices")]), |
|
|
|
Proto("void", "GetPhysicalDeviceFeatures", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkPhysicalDeviceFeatures*", "pFeatures")]), |
|
|
|
Proto("void", "GetPhysicalDeviceFormatProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkFormat", "format"), |
|
Param("VkFormatProperties*", "pFormatProperties")]), |
|
|
|
Proto("VkResult", "GetPhysicalDeviceImageFormatProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkFormat", "format"), |
|
Param("VkImageType", "type"), |
|
Param("VkImageTiling", "tiling"), |
|
Param("VkImageUsageFlags", "usage"), |
|
Param("VkImageCreateFlags", "flags"), |
|
Param("VkImageFormatProperties*", "pImageFormatProperties")]), |
|
|
|
Proto("void", "GetPhysicalDeviceProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkPhysicalDeviceProperties*", "pProperties")]), |
|
|
|
Proto("void", "GetPhysicalDeviceQueueFamilyProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t*", "pQueueFamilyPropertyCount"), |
|
Param("VkQueueFamilyProperties*", "pQueueFamilyProperties")]), |
|
|
|
Proto("void", "GetPhysicalDeviceMemoryProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkPhysicalDeviceMemoryProperties*", "pMemoryProperties")]), |
|
|
|
Proto("PFN_vkVoidFunction", "GetInstanceProcAddr", |
|
[Param("VkInstance", "instance"), |
|
Param("const char*", "pName")]), |
|
|
|
Proto("PFN_vkVoidFunction", "GetDeviceProcAddr", |
|
[Param("VkDevice", "device"), |
|
Param("const char*", "pName")]), |
|
|
|
Proto("VkResult", "CreateDevice", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("const VkDeviceCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkDevice*", "pDevice")]), |
|
|
|
Proto("void", "DestroyDevice", |
|
[Param("VkDevice", "device"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "EnumerateInstanceExtensionProperties", |
|
[Param("const char*", "pLayerName"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkExtensionProperties*", "pProperties")]), |
|
|
|
Proto("VkResult", "EnumerateDeviceExtensionProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("const char*", "pLayerName"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkExtensionProperties*", "pProperties")]), |
|
|
|
Proto("VkResult", "EnumerateInstanceLayerProperties", |
|
[Param("uint32_t*", "pPropertyCount"), |
|
Param("VkLayerProperties*", "pProperties")]), |
|
|
|
Proto("VkResult", "EnumerateDeviceLayerProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkLayerProperties*", "pProperties")]), |
|
|
|
Proto("void", "GetDeviceQueue", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "queueFamilyIndex"), |
|
Param("uint32_t", "queueIndex"), |
|
Param("VkQueue*", "pQueue")]), |
|
|
|
Proto("VkResult", "QueueSubmit", |
|
[Param("VkQueue", "queue"), |
|
Param("uint32_t", "submitCount"), |
|
Param("const VkSubmitInfo*", "pSubmits"), |
|
Param("VkFence", "fence")]), |
|
|
|
Proto("VkResult", "QueueWaitIdle", |
|
[Param("VkQueue", "queue")]), |
|
|
|
Proto("VkResult", "DeviceWaitIdle", |
|
[Param("VkDevice", "device")]), |
|
|
|
Proto("VkResult", "AllocateMemory", |
|
[Param("VkDevice", "device"), |
|
Param("const VkMemoryAllocateInfo*", "pAllocateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkDeviceMemory*", "pMemory")]), |
|
|
|
Proto("void", "FreeMemory", |
|
[Param("VkDevice", "device"), |
|
Param("VkDeviceMemory", "memory"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "MapMemory", |
|
[Param("VkDevice", "device"), |
|
Param("VkDeviceMemory", "memory"), |
|
Param("VkDeviceSize", "offset"), |
|
Param("VkDeviceSize", "size"), |
|
Param("VkMemoryMapFlags", "flags"), |
|
Param("void**", "ppData")]), |
|
|
|
Proto("void", "UnmapMemory", |
|
[Param("VkDevice", "device"), |
|
Param("VkDeviceMemory", "memory")]), |
|
|
|
Proto("VkResult", "FlushMappedMemoryRanges", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "memoryRangeCount"), |
|
Param("const VkMappedMemoryRange*", "pMemoryRanges")]), |
|
|
|
Proto("VkResult", "InvalidateMappedMemoryRanges", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "memoryRangeCount"), |
|
Param("const VkMappedMemoryRange*", "pMemoryRanges")]), |
|
|
|
Proto("void", "GetDeviceMemoryCommitment", |
|
[Param("VkDevice", "device"), |
|
Param("VkDeviceMemory", "memory"), |
|
Param("VkDeviceSize*", "pCommittedMemoryInBytes")]), |
|
|
|
Proto("VkResult", "BindBufferMemory", |
|
[Param("VkDevice", "device"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceMemory", "memory"), |
|
Param("VkDeviceSize", "memoryOffset")]), |
|
|
|
Proto("VkResult", "BindImageMemory", |
|
[Param("VkDevice", "device"), |
|
Param("VkImage", "image"), |
|
Param("VkDeviceMemory", "memory"), |
|
Param("VkDeviceSize", "memoryOffset")]), |
|
|
|
Proto("void", "GetBufferMemoryRequirements", |
|
[Param("VkDevice", "device"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkMemoryRequirements*", "pMemoryRequirements")]), |
|
|
|
Proto("void", "GetImageMemoryRequirements", |
|
[Param("VkDevice", "device"), |
|
Param("VkImage", "image"), |
|
Param("VkMemoryRequirements*", "pMemoryRequirements")]), |
|
|
|
Proto("void", "GetImageSparseMemoryRequirements", |
|
[Param("VkDevice", "device"), |
|
Param("VkImage", "image"), |
|
Param("uint32_t*", "pSparseMemoryRequirementCount"), |
|
Param("VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements")]), |
|
|
|
Proto("void", "GetPhysicalDeviceSparseImageFormatProperties", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkFormat", "format"), |
|
Param("VkImageType", "type"), |
|
Param("VkSampleCountFlagBits", "samples"), |
|
Param("VkImageUsageFlags", "usage"), |
|
Param("VkImageTiling", "tiling"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkSparseImageFormatProperties*", "pProperties")]), |
|
|
|
Proto("VkResult", "QueueBindSparse", |
|
[Param("VkQueue", "queue"), |
|
Param("uint32_t", "bindInfoCount"), |
|
Param("const VkBindSparseInfo*", "pBindInfo"), |
|
Param("VkFence", "fence")]), |
|
|
|
Proto("VkResult", "CreateFence", |
|
[Param("VkDevice", "device"), |
|
Param("const VkFenceCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkFence*", "pFence")]), |
|
|
|
Proto("void", "DestroyFence", |
|
[Param("VkDevice", "device"), |
|
Param("VkFence", "fence"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "ResetFences", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "fenceCount"), |
|
Param("const VkFence*", "pFences")]), |
|
|
|
Proto("VkResult", "GetFenceStatus", |
|
[Param("VkDevice", "device"), |
|
Param("VkFence", "fence")]), |
|
|
|
Proto("VkResult", "WaitForFences", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "fenceCount"), |
|
Param("const VkFence*", "pFences"), |
|
Param("VkBool32", "waitAll"), |
|
Param("uint64_t", "timeout")]), |
|
|
|
Proto("VkResult", "CreateSemaphore", |
|
[Param("VkDevice", "device"), |
|
Param("const VkSemaphoreCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSemaphore*", "pSemaphore")]), |
|
|
|
Proto("void", "DestroySemaphore", |
|
[Param("VkDevice", "device"), |
|
Param("VkSemaphore", "semaphore"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateEvent", |
|
[Param("VkDevice", "device"), |
|
Param("const VkEventCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkEvent*", "pEvent")]), |
|
|
|
Proto("void", "DestroyEvent", |
|
[Param("VkDevice", "device"), |
|
Param("VkEvent", "event"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "GetEventStatus", |
|
[Param("VkDevice", "device"), |
|
Param("VkEvent", "event")]), |
|
|
|
Proto("VkResult", "SetEvent", |
|
[Param("VkDevice", "device"), |
|
Param("VkEvent", "event")]), |
|
|
|
Proto("VkResult", "ResetEvent", |
|
[Param("VkDevice", "device"), |
|
Param("VkEvent", "event")]), |
|
|
|
Proto("VkResult", "CreateQueryPool", |
|
[Param("VkDevice", "device"), |
|
Param("const VkQueryPoolCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkQueryPool*", "pQueryPool")]), |
|
|
|
Proto("void", "DestroyQueryPool", |
|
[Param("VkDevice", "device"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "GetQueryPoolResults", |
|
[Param("VkDevice", "device"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("uint32_t", "firstQuery"), |
|
Param("uint32_t", "queryCount"), |
|
Param("size_t", "dataSize"), |
|
Param("void*", "pData"), |
|
Param("VkDeviceSize", "stride"), |
|
Param("VkQueryResultFlags", "flags")]), |
|
|
|
Proto("VkResult", "CreateBuffer", |
|
[Param("VkDevice", "device"), |
|
Param("const VkBufferCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkBuffer*", "pBuffer")]), |
|
|
|
Proto("void", "DestroyBuffer", |
|
[Param("VkDevice", "device"), |
|
Param("VkBuffer", "buffer"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateBufferView", |
|
[Param("VkDevice", "device"), |
|
Param("const VkBufferViewCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkBufferView*", "pView")]), |
|
|
|
Proto("void", "DestroyBufferView", |
|
[Param("VkDevice", "device"), |
|
Param("VkBufferView", "bufferView"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateImage", |
|
[Param("VkDevice", "device"), |
|
Param("const VkImageCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkImage*", "pImage")]), |
|
|
|
Proto("void", "DestroyImage", |
|
[Param("VkDevice", "device"), |
|
Param("VkImage", "image"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("void", "GetImageSubresourceLayout", |
|
[Param("VkDevice", "device"), |
|
Param("VkImage", "image"), |
|
Param("const VkImageSubresource*", "pSubresource"), |
|
Param("VkSubresourceLayout*", "pLayout")]), |
|
|
|
Proto("VkResult", "CreateImageView", |
|
[Param("VkDevice", "device"), |
|
Param("const VkImageViewCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkImageView*", "pView")]), |
|
|
|
Proto("void", "DestroyImageView", |
|
[Param("VkDevice", "device"), |
|
Param("VkImageView", "imageView"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateShaderModule", |
|
[Param("VkDevice", "device"), |
|
Param("const VkShaderModuleCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkShaderModule*", "pShaderModule")]), |
|
|
|
Proto("void", "DestroyShaderModule", |
|
[Param("VkDevice", "device"), |
|
Param("VkShaderModule", "shaderModule"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreatePipelineCache", |
|
[Param("VkDevice", "device"), |
|
Param("const VkPipelineCacheCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkPipelineCache*", "pPipelineCache")]), |
|
|
|
Proto("void", "DestroyPipelineCache", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipelineCache", "pipelineCache"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "GetPipelineCacheData", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipelineCache", "pipelineCache"), |
|
Param("size_t*", "pDataSize"), |
|
Param("void*", "pData")]), |
|
|
|
Proto("VkResult", "MergePipelineCaches", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipelineCache", "dstCache"), |
|
Param("uint32_t", "srcCacheCount"), |
|
Param("const VkPipelineCache*", "pSrcCaches")]), |
|
|
|
Proto("VkResult", "CreateGraphicsPipelines", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipelineCache", "pipelineCache"), |
|
Param("uint32_t", "createInfoCount"), |
|
Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfos"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkPipeline*", "pPipelines")]), |
|
|
|
Proto("VkResult", "CreateComputePipelines", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipelineCache", "pipelineCache"), |
|
Param("uint32_t", "createInfoCount"), |
|
Param("const VkComputePipelineCreateInfo*", "pCreateInfos"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkPipeline*", "pPipelines")]), |
|
|
|
Proto("void", "DestroyPipeline", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipeline", "pipeline"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreatePipelineLayout", |
|
[Param("VkDevice", "device"), |
|
Param("const VkPipelineLayoutCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkPipelineLayout*", "pPipelineLayout")]), |
|
|
|
Proto("void", "DestroyPipelineLayout", |
|
[Param("VkDevice", "device"), |
|
Param("VkPipelineLayout", "pipelineLayout"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateSampler", |
|
[Param("VkDevice", "device"), |
|
Param("const VkSamplerCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSampler*", "pSampler")]), |
|
|
|
Proto("void", "DestroySampler", |
|
[Param("VkDevice", "device"), |
|
Param("VkSampler", "sampler"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateDescriptorSetLayout", |
|
[Param("VkDevice", "device"), |
|
Param("const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkDescriptorSetLayout*", "pSetLayout")]), |
|
|
|
Proto("void", "DestroyDescriptorSetLayout", |
|
[Param("VkDevice", "device"), |
|
Param("VkDescriptorSetLayout", "descriptorSetLayout"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateDescriptorPool", |
|
[Param("VkDevice", "device"), |
|
Param("const VkDescriptorPoolCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkDescriptorPool*", "pDescriptorPool")]), |
|
|
|
Proto("void", "DestroyDescriptorPool", |
|
[Param("VkDevice", "device"), |
|
Param("VkDescriptorPool", "descriptorPool"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "ResetDescriptorPool", |
|
[Param("VkDevice", "device"), |
|
Param("VkDescriptorPool", "descriptorPool"), |
|
Param("VkDescriptorPoolResetFlags", "flags")]), |
|
|
|
Proto("VkResult", "AllocateDescriptorSets", |
|
[Param("VkDevice", "device"), |
|
Param("const VkDescriptorSetAllocateInfo*", "pAllocateInfo"), |
|
Param("VkDescriptorSet*", "pDescriptorSets")]), |
|
|
|
Proto("VkResult", "FreeDescriptorSets", |
|
[Param("VkDevice", "device"), |
|
Param("VkDescriptorPool", "descriptorPool"), |
|
Param("uint32_t", "descriptorSetCount"), |
|
Param("const VkDescriptorSet*", "pDescriptorSets")]), |
|
|
|
Proto("void", "UpdateDescriptorSets", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "descriptorWriteCount"), |
|
Param("const VkWriteDescriptorSet*", "pDescriptorWrites"), |
|
Param("uint32_t", "descriptorCopyCount"), |
|
Param("const VkCopyDescriptorSet*", "pDescriptorCopies")]), |
|
|
|
Proto("VkResult", "CreateFramebuffer", |
|
[Param("VkDevice", "device"), |
|
Param("const VkFramebufferCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkFramebuffer*", "pFramebuffer")]), |
|
|
|
Proto("void", "DestroyFramebuffer", |
|
[Param("VkDevice", "device"), |
|
Param("VkFramebuffer", "framebuffer"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "CreateRenderPass", |
|
[Param("VkDevice", "device"), |
|
Param("const VkRenderPassCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkRenderPass*", "pRenderPass")]), |
|
|
|
Proto("void", "DestroyRenderPass", |
|
[Param("VkDevice", "device"), |
|
Param("VkRenderPass", "renderPass"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("void", "GetRenderAreaGranularity", |
|
[Param("VkDevice", "device"), |
|
Param("VkRenderPass", "renderPass"), |
|
Param("VkExtent2D*", "pGranularity")]), |
|
|
|
Proto("VkResult", "CreateCommandPool", |
|
[Param("VkDevice", "device"), |
|
Param("const VkCommandPoolCreateInfo*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkCommandPool*", "pCommandPool")]), |
|
|
|
Proto("void", "DestroyCommandPool", |
|
[Param("VkDevice", "device"), |
|
Param("VkCommandPool", "commandPool"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "ResetCommandPool", |
|
[Param("VkDevice", "device"), |
|
Param("VkCommandPool", "commandPool"), |
|
Param("VkCommandPoolResetFlags", "flags")]), |
|
|
|
Proto("VkResult", "AllocateCommandBuffers", |
|
[Param("VkDevice", "device"), |
|
Param("const VkCommandBufferAllocateInfo*", "pAllocateInfo"), |
|
Param("VkCommandBuffer*", "pCommandBuffers")]), |
|
|
|
Proto("void", "FreeCommandBuffers", |
|
[Param("VkDevice", "device"), |
|
Param("VkCommandPool", "commandPool"), |
|
Param("uint32_t", "commandBufferCount"), |
|
Param("const VkCommandBuffer*", "pCommandBuffers")]), |
|
|
|
Proto("VkResult", "BeginCommandBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("const VkCommandBufferBeginInfo*", "pBeginInfo")]), |
|
|
|
Proto("VkResult", "EndCommandBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer")]), |
|
|
|
Proto("VkResult", "ResetCommandBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkCommandBufferResetFlags", "flags")]), |
|
|
|
Proto("void", "CmdBindPipeline", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkPipelineBindPoint", "pipelineBindPoint"), |
|
Param("VkPipeline", "pipeline")]), |
|
|
|
Proto("void", "CmdSetViewport", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "firstViewport"), |
|
Param("uint32_t", "viewportCount"), |
|
Param("const VkViewport*", "pViewports")]), |
|
|
|
Proto("void", "CmdSetScissor", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "firstScissor"), |
|
Param("uint32_t", "scissorCount"), |
|
Param("const VkRect2D*", "pScissors")]), |
|
|
|
Proto("void", "CmdSetLineWidth", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("float", "lineWidth")]), |
|
|
|
Proto("void", "CmdSetDepthBias", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("float", "depthBiasConstantFactor"), |
|
Param("float", "depthBiasClamp"), |
|
Param("float", "depthBiasSlopeFactor")]), |
|
|
|
Proto("void", "CmdSetBlendConstants", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("const float[4]", "blendConstants")]), |
|
|
|
Proto("void", "CmdSetDepthBounds", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("float", "minDepthBounds"), |
|
Param("float", "maxDepthBounds")]), |
|
|
|
Proto("void", "CmdSetStencilCompareMask", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkStencilFaceFlags", "faceMask"), |
|
Param("uint32_t", "compareMask")]), |
|
|
|
Proto("void", "CmdSetStencilWriteMask", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkStencilFaceFlags", "faceMask"), |
|
Param("uint32_t", "writeMask")]), |
|
|
|
Proto("void", "CmdSetStencilReference", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkStencilFaceFlags", "faceMask"), |
|
Param("uint32_t", "reference")]), |
|
|
|
Proto("void", "CmdBindDescriptorSets", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkPipelineBindPoint", "pipelineBindPoint"), |
|
Param("VkPipelineLayout", "layout"), |
|
Param("uint32_t", "firstSet"), |
|
Param("uint32_t", "descriptorSetCount"), |
|
Param("const VkDescriptorSet*", "pDescriptorSets"), |
|
Param("uint32_t", "dynamicOffsetCount"), |
|
Param("const uint32_t*", "pDynamicOffsets")]), |
|
|
|
Proto("void", "CmdBindIndexBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceSize", "offset"), |
|
Param("VkIndexType", "indexType")]), |
|
|
|
Proto("void", "CmdBindVertexBuffers", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "firstBinding"), |
|
Param("uint32_t", "bindingCount"), |
|
Param("const VkBuffer*", "pBuffers"), |
|
Param("const VkDeviceSize*", "pOffsets")]), |
|
|
|
Proto("void", "CmdDraw", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "vertexCount"), |
|
Param("uint32_t", "instanceCount"), |
|
Param("uint32_t", "firstVertex"), |
|
Param("uint32_t", "firstInstance")]), |
|
|
|
Proto("void", "CmdDrawIndexed", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "indexCount"), |
|
Param("uint32_t", "instanceCount"), |
|
Param("uint32_t", "firstIndex"), |
|
Param("int32_t", "vertexOffset"), |
|
Param("uint32_t", "firstInstance")]), |
|
|
|
Proto("void", "CmdDrawIndirect", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceSize", "offset"), |
|
Param("uint32_t", "drawCount"), |
|
Param("uint32_t", "stride")]), |
|
|
|
Proto("void", "CmdDrawIndexedIndirect", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceSize", "offset"), |
|
Param("uint32_t", "drawCount"), |
|
Param("uint32_t", "stride")]), |
|
|
|
Proto("void", "CmdDispatch", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "x"), |
|
Param("uint32_t", "y"), |
|
Param("uint32_t", "z")]), |
|
|
|
Proto("void", "CmdDispatchIndirect", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceSize", "offset")]), |
|
|
|
Proto("void", "CmdCopyBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "srcBuffer"), |
|
Param("VkBuffer", "dstBuffer"), |
|
Param("uint32_t", "regionCount"), |
|
Param("const VkBufferCopy*", "pRegions")]), |
|
|
|
Proto("void", "CmdCopyImage", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkImage", "srcImage"), |
|
Param("VkImageLayout", "srcImageLayout"), |
|
Param("VkImage", "dstImage"), |
|
Param("VkImageLayout", "dstImageLayout"), |
|
Param("uint32_t", "regionCount"), |
|
Param("const VkImageCopy*", "pRegions")]), |
|
|
|
Proto("void", "CmdBlitImage", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkImage", "srcImage"), |
|
Param("VkImageLayout", "srcImageLayout"), |
|
Param("VkImage", "dstImage"), |
|
Param("VkImageLayout", "dstImageLayout"), |
|
Param("uint32_t", "regionCount"), |
|
Param("const VkImageBlit*", "pRegions"), |
|
Param("VkFilter", "filter")]), |
|
|
|
Proto("void", "CmdCopyBufferToImage", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "srcBuffer"), |
|
Param("VkImage", "dstImage"), |
|
Param("VkImageLayout", "dstImageLayout"), |
|
Param("uint32_t", "regionCount"), |
|
Param("const VkBufferImageCopy*", "pRegions")]), |
|
|
|
Proto("void", "CmdCopyImageToBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkImage", "srcImage"), |
|
Param("VkImageLayout", "srcImageLayout"), |
|
Param("VkBuffer", "dstBuffer"), |
|
Param("uint32_t", "regionCount"), |
|
Param("const VkBufferImageCopy*", "pRegions")]), |
|
|
|
Proto("void", "CmdUpdateBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "dstBuffer"), |
|
Param("VkDeviceSize", "dstOffset"), |
|
Param("VkDeviceSize", "dataSize"), |
|
Param("const void*", "pData")]), |
|
|
|
Proto("void", "CmdFillBuffer", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "dstBuffer"), |
|
Param("VkDeviceSize", "dstOffset"), |
|
Param("VkDeviceSize", "size"), |
|
Param("uint32_t", "data")]), |
|
|
|
Proto("void", "CmdClearColorImage", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkImage", "image"), |
|
Param("VkImageLayout", "imageLayout"), |
|
Param("const VkClearColorValue*", "pColor"), |
|
Param("uint32_t", "rangeCount"), |
|
Param("const VkImageSubresourceRange*", "pRanges")]), |
|
|
|
Proto("void", "CmdClearDepthStencilImage", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkImage", "image"), |
|
Param("VkImageLayout", "imageLayout"), |
|
Param("const VkClearDepthStencilValue*", "pDepthStencil"), |
|
Param("uint32_t", "rangeCount"), |
|
Param("const VkImageSubresourceRange*", "pRanges")]), |
|
|
|
Proto("void", "CmdClearAttachments", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "attachmentCount"), |
|
Param("const VkClearAttachment*", "pAttachments"), |
|
Param("uint32_t", "rectCount"), |
|
Param("const VkClearRect*", "pRects")]), |
|
|
|
Proto("void", "CmdResolveImage", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkImage", "srcImage"), |
|
Param("VkImageLayout", "srcImageLayout"), |
|
Param("VkImage", "dstImage"), |
|
Param("VkImageLayout", "dstImageLayout"), |
|
Param("uint32_t", "regionCount"), |
|
Param("const VkImageResolve*", "pRegions")]), |
|
|
|
Proto("void", "CmdSetEvent", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkEvent", "event"), |
|
Param("VkPipelineStageFlags", "stageMask")]), |
|
|
|
Proto("void", "CmdResetEvent", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkEvent", "event"), |
|
Param("VkPipelineStageFlags", "stageMask")]), |
|
|
|
Proto("void", "CmdWaitEvents", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "eventCount"), |
|
Param("const VkEvent*", "pEvents"), |
|
Param("VkPipelineStageFlags", "srcStageMask"), |
|
Param("VkPipelineStageFlags", "dstStageMask"), |
|
Param("uint32_t", "memoryBarrierCount"), |
|
Param("const VkMemoryBarrier*", "pMemoryBarriers"), |
|
Param("uint32_t", "bufferMemoryBarrierCount"), |
|
Param("const VkBufferMemoryBarrier*", "pBufferMemoryBarriers"), |
|
Param("uint32_t", "imageMemoryBarrierCount"), |
|
Param("const VkImageMemoryBarrier*", "pImageMemoryBarriers")]), |
|
|
|
Proto("void", "CmdPipelineBarrier", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkPipelineStageFlags", "srcStageMask"), |
|
Param("VkPipelineStageFlags", "dstStageMask"), |
|
Param("VkDependencyFlags", "dependencyFlags"), |
|
Param("uint32_t", "memoryBarrierCount"), |
|
Param("const VkMemoryBarrier*", "pMemoryBarriers"), |
|
Param("uint32_t", "bufferMemoryBarrierCount"), |
|
Param("const VkBufferMemoryBarrier*", "pBufferMemoryBarriers"), |
|
Param("uint32_t", "imageMemoryBarrierCount"), |
|
Param("const VkImageMemoryBarrier*", "pImageMemoryBarriers")]), |
|
|
|
Proto("void", "CmdBeginQuery", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("uint32_t", "query"), |
|
Param("VkQueryControlFlags", "flags")]), |
|
|
|
Proto("void", "CmdEndQuery", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("uint32_t", "query")]), |
|
|
|
Proto("void", "CmdResetQueryPool", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("uint32_t", "firstQuery"), |
|
Param("uint32_t", "queryCount")]), |
|
|
|
Proto("void", "CmdWriteTimestamp", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkPipelineStageFlagBits", "pipelineStage"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("uint32_t", "query")]), |
|
|
|
Proto("void", "CmdCopyQueryPoolResults", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkQueryPool", "queryPool"), |
|
Param("uint32_t", "firstQuery"), |
|
Param("uint32_t", "queryCount"), |
|
Param("VkBuffer", "dstBuffer"), |
|
Param("VkDeviceSize", "dstOffset"), |
|
Param("VkDeviceSize", "stride"), |
|
Param("VkQueryResultFlags", "flags")]), |
|
|
|
Proto("void", "CmdPushConstants", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkPipelineLayout", "layout"), |
|
Param("VkShaderStageFlags", "stageFlags"), |
|
Param("uint32_t", "offset"), |
|
Param("uint32_t", "size"), |
|
Param("const void*", "pValues")]), |
|
|
|
Proto("void", "CmdBeginRenderPass", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("const VkRenderPassBeginInfo*", "pRenderPassBegin"), |
|
Param("VkSubpassContents", "contents")]), |
|
|
|
Proto("void", "CmdNextSubpass", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkSubpassContents", "contents")]), |
|
|
|
Proto("void", "CmdEndRenderPass", |
|
[Param("VkCommandBuffer", "commandBuffer")]), |
|
|
|
Proto("void", "CmdExecuteCommands", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("uint32_t", "commandBufferCount"), |
|
Param("const VkCommandBuffer*", "pCommandBuffers")]), |
|
], |
|
) |
|
|
|
ext_amd_draw_indirect_count = Extension( |
|
name="VK_AMD_draw_indirect_count", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("void", "CmdDrawIndirectCountAMD", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceSize", "offset"), |
|
Param("VkBuffer", "countBuffer"), |
|
Param("VkDeviceSize", "countBufferOffset"), |
|
Param("uint32_t", "maxDrawCount"), |
|
Param("uint32_t", "stride")]), |
|
|
|
Proto("void", "CmdDrawIndexedIndirectCountAMD", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkBuffer", "buffer"), |
|
Param("VkDeviceSize", "offset"), |
|
Param("VkBuffer", "countBuffer"), |
|
Param("VkDeviceSize", "countBufferOffset"), |
|
Param("uint32_t", "maxDrawCount"), |
|
Param("uint32_t", "stride")]), |
|
], |
|
) |
|
|
|
ext_nv_external_memory_capabilities = Extension( |
|
name="VK_NV_external_memory_capabilities", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("VkResult", "GetPhysicalDeviceExternalImageFormatPropertiesNV", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkFormat", "format"), |
|
Param("VkImageType", "type"), |
|
Param("VkImageTiling", "tiling"), |
|
Param("VkImageUsageFlags", "usage"), |
|
Param("VkImageCreateFlags", "flags"), |
|
Param("VkExternalMemoryHandleTypeFlagsNV", "externalHandleType"), |
|
Param("VkExternalImageFormatPropertiesNV*", "pExternalImageFormatProperties")]), |
|
], |
|
) |
|
|
|
ext_nv_external_memory_win32 = Extension( |
|
name="VK_NV_external_memory_win32", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
ifdef="VK_USE_PLATFORM_WIN32_KHR", |
|
protos=[ |
|
Proto("VkResult", "GetMemoryWin32HandleNV", |
|
[Param("VkDevice", "device"), |
|
Param("VkDeviceMemory", "memory"), |
|
Param("VkExternalMemoryHandleTypeFlagsNV", "handleType"), |
|
Param("HANDLE*", "pHandle")]), |
|
], |
|
) |
|
|
|
ext_khr_surface = Extension( |
|
name="VK_KHR_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=["vkSurfaceKHR"], |
|
protos=[ |
|
Proto("void", "DestroySurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("VkSurfaceKHR", "surface"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "GetPhysicalDeviceSurfaceSupportKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "queueFamilyIndex"), |
|
Param("VkSurfaceKHR", "surface"), |
|
Param("VkBool32*", "pSupported")]), |
|
|
|
Proto("VkResult", "GetPhysicalDeviceSurfaceCapabilitiesKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkSurfaceKHR", "surface"), |
|
Param("VkSurfaceCapabilitiesKHR*", "pSurfaceCapabilities")]), |
|
|
|
Proto("VkResult", "GetPhysicalDeviceSurfaceFormatsKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkSurfaceKHR", "surface"), |
|
Param("uint32_t*", "pSurfaceFormatCount"), |
|
Param("VkSurfaceFormatKHR*", "pSurfaceFormats")]), |
|
|
|
Proto("VkResult", "GetPhysicalDeviceSurfacePresentModesKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkSurfaceKHR", "surface"), |
|
Param("uint32_t*", "pPresentModeCount"), |
|
Param("VkPresentModeKHR*", "pPresentModes")]), |
|
], |
|
) |
|
|
|
ext_khr_display = Extension( |
|
name="VK_KHR_display", |
|
headers=["vulkan/vulkan.h"], |
|
objects=['VkSurfaceKHR', 'VkDisplayModeKHR'], |
|
protos=[ |
|
Proto("VkResult", "GetPhysicalDeviceDisplayPropertiesKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkDisplayPropertiesKHR*", "pProperties")]), |
|
|
|
Proto("VkResult", "GetPhysicalDeviceDisplayPlanePropertiesKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkDisplayPlanePropertiesKHR*", "pProperties")]), |
|
|
|
Proto("VkResult", "GetDisplayPlaneSupportedDisplaysKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "planeIndex"), |
|
Param("uint32_t*", "pDisplayCount"), |
|
Param("VkDisplayKHR*", "pDisplays")]), |
|
|
|
Proto("VkResult", "GetDisplayModePropertiesKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkDisplayKHR", "display"), |
|
Param("uint32_t*", "pPropertyCount"), |
|
Param("VkDisplayModePropertiesKHR*", "pProperties")]), |
|
|
|
Proto("VkResult", "CreateDisplayModeKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkDisplayKHR", "display"), |
|
Param("const VkDisplayModeCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkDisplayModeKHR*", "pMode")]), |
|
|
|
Proto("VkResult", "GetDisplayPlaneCapabilitiesKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("VkDisplayModeKHR", "mode"), |
|
Param("uint32_t", "planeIndex"), |
|
Param("VkDisplayPlaneCapabilitiesKHR*", "pCapabilities")]), |
|
|
|
Proto("VkResult", "CreateDisplayPlaneSurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkDisplaySurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
], |
|
) |
|
|
|
ext_khr_device_swapchain = Extension( |
|
name="VK_KHR_swapchain", |
|
headers=["vulkan/vulkan.h"], |
|
objects=["VkSwapchainKHR"], |
|
protos=[ |
|
Proto("VkResult", "CreateSwapchainKHR", |
|
[Param("VkDevice", "device"), |
|
Param("const VkSwapchainCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSwapchainKHR*", "pSwapchain")]), |
|
|
|
Proto("void", "DestroySwapchainKHR", |
|
[Param("VkDevice", "device"), |
|
Param("VkSwapchainKHR", "swapchain"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("VkResult", "GetSwapchainImagesKHR", |
|
[Param("VkDevice", "device"), |
|
Param("VkSwapchainKHR", "swapchain"), |
|
Param("uint32_t*", "pSwapchainImageCount"), |
|
Param("VkImage*", "pSwapchainImages")]), |
|
|
|
Proto("VkResult", "AcquireNextImageKHR", |
|
[Param("VkDevice", "device"), |
|
Param("VkSwapchainKHR", "swapchain"), |
|
Param("uint64_t", "timeout"), |
|
Param("VkSemaphore", "semaphore"), |
|
Param("VkFence", "fence"), |
|
Param("uint32_t*", "pImageIndex")]), |
|
|
|
Proto("VkResult", "QueuePresentKHR", |
|
[Param("VkQueue", "queue"), |
|
Param("const VkPresentInfoKHR*", "pPresentInfo")]), |
|
], |
|
) |
|
|
|
ext_khr_display_swapchain = Extension( |
|
name="VK_KHR_display_swapchain", |
|
headers=["vulkan/vulkan.h"], |
|
objects=["VkDisplayPresentInfoKHR"], |
|
protos=[ |
|
Proto("VkResult", "CreateSharedSwapchainsKHR", |
|
[Param("VkDevice", "device"), |
|
Param("uint32_t", "swapchainCount"), |
|
Param("const VkSwapchainCreateInfoKHR*", "pCreateInfos"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSwapchainKHR*", "pSwapchains")]), |
|
], |
|
) |
|
|
|
ext_khr_xcb_surface = Extension( |
|
name="VK_KHR_xcb_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("VkResult", "CreateXcbSurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkXcbSurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
|
|
Proto("VkBool32", "GetPhysicalDeviceXcbPresentationSupportKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "queueFamilyIndex"), |
|
Param("xcb_connection_t*", "connection"), |
|
Param("xcb_visualid_t", "visual_id")]), |
|
], |
|
) |
|
ext_khr_xlib_surface = Extension( |
|
name="VK_KHR_xlib_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
ifdef="VK_USE_PLATFORM_XLIB_KHR", |
|
protos=[ |
|
Proto("VkResult", "CreateXlibSurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkXlibSurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
|
|
Proto("VkBool32", "GetPhysicalDeviceXlibPresentationSupportKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "queueFamilyIndex"), |
|
Param("Display*", "dpy"), |
|
Param("VisualID", "visualID")]), |
|
], |
|
) |
|
ext_khr_wayland_surface = Extension( |
|
name="VK_KHR_wayland_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("VkResult", "CreateWaylandSurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkWaylandSurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
|
|
Proto("VkBool32", "GetPhysicalDeviceWaylandPresentationSupportKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "queueFamilyIndex"), |
|
Param("struct wl_display*", "display")]), |
|
], |
|
) |
|
ext_khr_mir_surface = Extension( |
|
name="VK_KHR_mir_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("VkResult", "CreateMirSurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkMirSurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
|
|
Proto("VkBool32", "GetPhysicalDeviceMirPresentationSupportKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "queueFamilyIndex"), |
|
Param("MirConnection*", "connection")]), |
|
], |
|
) |
|
ext_khr_android_surface = Extension( |
|
name="VK_KHR_android_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("VkResult", "CreateAndroidSurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkAndroidSurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
], |
|
) |
|
ext_khr_win32_surface = Extension( |
|
name="VK_KHR_win32_surface", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[], |
|
protos=[ |
|
Proto("VkResult", "CreateWin32SurfaceKHR", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkWin32SurfaceCreateInfoKHR*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkSurfaceKHR*", "pSurface")]), |
|
|
|
Proto("VkBool32", "GetPhysicalDeviceWin32PresentationSupportKHR", |
|
[Param("VkPhysicalDevice", "physicalDevice"), |
|
Param("uint32_t", "queueFamilyIndex")]), |
|
], |
|
) |
|
ext_debug_report = Extension( |
|
name="VK_EXT_debug_report", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[ |
|
"VkDebugReportCallbackEXT", |
|
], |
|
protos=[ |
|
Proto("VkResult", "CreateDebugReportCallbackEXT", |
|
[Param("VkInstance", "instance"), |
|
Param("const VkDebugReportCallbackCreateInfoEXT*", "pCreateInfo"), |
|
Param("const VkAllocationCallbacks*", "pAllocator"), |
|
Param("VkDebugReportCallbackEXT*", "pCallback")]), |
|
|
|
Proto("void", "DestroyDebugReportCallbackEXT", |
|
[Param("VkInstance", "instance"), |
|
Param("VkDebugReportCallbackEXT", "callback"), |
|
Param("const VkAllocationCallbacks*", "pAllocator")]), |
|
|
|
Proto("void", "DebugReportMessageEXT", |
|
[Param("VkInstance", "instance"), |
|
Param("VkDebugReportFlagsEXT", "flags"), |
|
Param("VkDebugReportObjectTypeEXT", "objType"), |
|
Param("uint64_t", "object"), |
|
Param("size_t", "location"), |
|
Param("int32_t", "msgCode"), |
|
Param("const char *", "pLayerPrefix"), |
|
Param("const char *", "pMsg")]), |
|
], |
|
) |
|
ext_debug_marker = Extension( |
|
name="VK_EXT_debug_marker", |
|
headers=["vulkan/vulkan.h"], |
|
objects=[ |
|
"VkDebugMarkerObjectNameInfoEXT", |
|
"VkDebugMarkerObjectTagInfoEXT", |
|
"VkDebugMarkerMarkerInfoEXT" |
|
], |
|
protos=[ |
|
Proto("VkResult", "DebugMarkerSetObjectTagEXT", |
|
[Param("VkDevice", "device"), |
|
Param("VkDebugMarkerObjectTagInfoEXT*", "pTagInfo")]), |
|
|
|
Proto("VkResult", "DebugMarkerSetObjectNameEXT", |
|
[Param("VkDevice", "device"), |
|
Param("VkDebugMarkerObjectNameInfoEXT*", "pNameInfo")]), |
|
|
|
Proto("void", "CmdDebugMarkerBeginEXT", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo")]), |
|
|
|
Proto("void", "CmdDebugMarkerEndEXT", |
|
[Param("VkCommandBuffer", "commandBuffer")]), |
|
|
|
Proto("void", "CmdDebugMarkerInsertEXT", |
|
[Param("VkCommandBuffer", "commandBuffer"), |
|
Param("VkDebugMarkerMarkerInfoEXT*", "pMarkerInfo")]), |
|
], |
|
) |
|
|
|
import sys |
|
|
|
if sys.argv[1] == 'AllPlatforms': |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_win32_surface, ext_khr_xcb_surface, |
|
ext_khr_xlib_surface, ext_khr_wayland_surface, ext_khr_mir_surface, ext_khr_display, |
|
ext_khr_android_surface, ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_win32_surface, |
|
ext_khr_xcb_surface, ext_khr_xlib_surface, ext_khr_wayland_surface, ext_khr_mir_surface, |
|
ext_khr_display, ext_khr_android_surface, ext_amd_draw_indirect_count, |
|
ext_nv_external_memory_capabilities, ext_nv_external_memory_win32, |
|
ext_khr_display_swapchain, ext_debug_report, ext_debug_marker] |
|
else : |
|
if len(sys.argv) > 3: |
|
if (sys.platform.startswith('win32') or sys.platform.startswith('msys')) and sys.argv[1] != 'Android': |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_win32_surface, |
|
ext_khr_display, ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_win32_surface, |
|
ext_khr_display, ext_amd_draw_indirect_count, |
|
ext_nv_external_memory_capabilities, ext_nv_external_memory_win32, |
|
ext_khr_display_swapchain, ext_debug_report, ext_debug_marker] |
|
elif sys.platform.startswith('linux') and sys.argv[1] != 'Android': |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_xcb_surface, |
|
ext_khr_xlib_surface, ext_khr_wayland_surface, ext_khr_mir_surface, ext_khr_display, |
|
ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_xcb_surface, |
|
ext_khr_xlib_surface, ext_khr_wayland_surface, ext_khr_mir_surface, |
|
ext_khr_display, ext_amd_draw_indirect_count, |
|
ext_nv_external_memory_capabilities, ext_khr_display_swapchain, |
|
ext_debug_report, ext_debug_marker] |
|
else: # android |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_android_surface, |
|
ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_android_surface, |
|
ext_amd_draw_indirect_count, ext_nv_external_memory_capabilities, |
|
ext_khr_display_swapchain, ext_debug_report, ext_debug_marker] |
|
else : |
|
if sys.argv[1] == 'Win32' or sys.argv[1] == 'msys': |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_win32_surface, |
|
ext_khr_display, ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_win32_surface, |
|
ext_khr_display, ext_amd_draw_indirect_count, |
|
ext_nv_external_memory_capabilities, ext_nv_external_memory_win32, |
|
ext_khr_display_swapchain, ext_debug_report, ext_debug_marker] |
|
elif sys.argv[1] == 'Android': |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_android_surface, |
|
ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_android_surface, |
|
ext_amd_draw_indirect_count, ext_nv_external_memory_capabilities, |
|
ext_khr_display_swapchain, ext_debug_report, ext_debug_marker] |
|
elif sys.argv[1] == 'Xcb' or sys.argv[1] == 'Xlib' or sys.argv[1] == 'Wayland' or sys.argv[1] == 'Mir' or sys.argv[1] == 'Display': |
|
extensions = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_xcb_surface, |
|
ext_khr_xlib_surface, ext_khr_wayland_surface, ext_khr_mir_surface, |
|
ext_khr_display, ext_khr_display_swapchain] |
|
extensions_all = [core, ext_khr_surface, ext_khr_device_swapchain, ext_khr_xcb_surface, |
|
ext_khr_xlib_surface, ext_khr_wayland_surface, ext_khr_mir_surface, |
|
ext_khr_display, ext_amd_draw_indirect_count, |
|
ext_nv_external_memory_capabilities, ext_khr_display_swapchain, |
|
ext_debug_report, ext_debug_marker] |
|
else: |
|
print('Error: Undefined DisplayServer') |
|
extensions = [] |
|
extensions_all = [] |
|
|
|
object_dispatch_list = [ |
|
"VkInstance", |
|
"VkPhysicalDevice", |
|
"VkDevice", |
|
"VkQueue", |
|
"VkCommandBuffer", |
|
] |
|
|
|
object_non_dispatch_list = [ |
|
"VkCommandPool", |
|
"VkFence", |
|
"VkDeviceMemory", |
|
"VkBuffer", |
|
"VkImage", |
|
"VkSemaphore", |
|
"VkEvent", |
|
"VkQueryPool", |
|
"VkBufferView", |
|
"VkImageView", |
|
"VkShaderModule", |
|
"VkPipelineCache", |
|
"VkPipelineLayout", |
|
"VkPipeline", |
|
"VkDescriptorSetLayout", |
|
"VkSampler", |
|
"VkDescriptorPool", |
|
"VkDescriptorSet", |
|
"VkRenderPass", |
|
"VkFramebuffer", |
|
"VkSwapchainKHR", |
|
"VkSurfaceKHR", |
|
"VkDebugReportCallbackEXT", |
|
"VkDisplayKHR", |
|
"VkDisplayModeKHR", |
|
] |
|
|
|
object_type_list = object_dispatch_list + object_non_dispatch_list |
|
|
|
headers = [] |
|
objects = [] |
|
protos = [] |
|
for ext in extensions: |
|
headers.extend(ext.headers) |
|
objects.extend(ext.objects) |
|
protos.extend(ext.protos) |
|
|
|
proto_names = [proto.name for proto in protos] |
|
|
|
headers_all = [] |
|
objects_all = [] |
|
protos_all = [] |
|
for ext in extensions_all: |
|
headers_all.extend(ext.headers) |
|
objects_all.extend(ext.objects) |
|
protos_all.extend(ext.protos) |
|
|
|
proto_all_names = [proto.name for proto in protos_all]
|
|
|