// API version (major.minor.patch)
define VERSION_MAJOR 0
-define VERSION_MINOR 185
+define VERSION_MINOR 186
define VERSION_PATCH 0
// API limits
enum VkQueryType {
VK_QUERY_TYPE_OCCLUSION = 0x00000000,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001, /// Optional
+ VK_QUERY_TYPE_TIMESTAMP = 0x00000002,
}
enum VkBorderColor {
VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
- VK_QUEUE_EXTENDED_BIT = 0x40000000, /// Extended queue
}
/// Memory properties passed into vkAllocMemory().
cmd void vkCmdWriteTimestamp(
VkCmdBuffer cmdBuffer,
VkPipelineStageFlagBits pipelineStage,
- VkBuffer destBuffer,
- VkDeviceSize destOffset) {
+ VkQueryPool queryPool,
+ u32 slot) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
- destBufferObject := GetBuffer(destBuffer)
- assert(cmdBufferObject.device == destBufferObject.device)
+ queryPoolObject := GetQueryPool(queryPool)
+ assert(cmdBufferObject.device == queryPoolObject.device)
}
@threadSafety("app")
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 185, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 186, 0)
-#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
- #define VK_NULL_HANDLE nullptr
-#else
- #define VK_NULL_HANDLE 0
-#endif
+#define VK_NULL_HANDLE 0
+
#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
-#if defined(__cplusplus)
- #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
- // The bool operator only works if there are no implicit conversions from an obj to
- // a bool-compatible type, which can then be used to unintentionally violate type safety.
- // C++11 and above supports the "explicit" keyword on conversion operators to stop this
- // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating
- // the object handle as a bool in expressions like:
- // if (obj) vkDestroy(obj);
- #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; }
- #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
- explicit obj(uint64_t x) : handle(x) { } \
- obj(decltype(nullptr)) : handle(0) { }
- #else
- #define VK_NONDISP_HANDLE_OPERATOR_BOOL()
- #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
- obj(uint64_t x) : handle(x) { }
- #endif
- #define VK_DEFINE_NONDISP_HANDLE(obj) \
- struct obj { \
- obj() : handle(0) { } \
- VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
- obj& operator =(uint64_t x) { handle = x; return *this; } \
- bool operator==(const obj& other) const { return handle == other.handle; } \
- bool operator!=(const obj& other) const { return handle != other.handle; } \
- bool operator!() const { return !handle; } \
- VK_NONDISP_HANDLE_OPERATOR_BOOL() \
- uint64_t handle; \
- };
+#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
#else
- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj;
+ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
#endif
typedef enum {
VK_QUERY_TYPE_OCCLUSION = 0,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
+ VK_QUERY_TYPE_TIMESTAMP = 2,
VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
- VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS,
- VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_PIPELINE_STATISTICS - VK_QUERY_TYPE_OCCLUSION + 1),
+ VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
+ VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkQueryType;
VK_QUEUE_COMPUTE_BIT = 0x00000002,
VK_QUEUE_DMA_BIT = 0x00000004,
VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
- VK_QUEUE_EXTENDED_BIT = 0x40000000,
} VkQueueFlagBits;
typedef VkFlags VkQueueFlags;
typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset);
+typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
void VKAPI vkCmdWriteTimestamp(
VkCmdBuffer cmdBuffer,
VkPipelineStageFlagBits pipelineStage,
- VkBuffer destBuffer,
- VkDeviceSize destOffset);
+ VkQueryPool queryPool,
+ uint32_t slot);
void VKAPI vkCmdCopyQueryPoolResults(
VkCmdBuffer cmdBuffer,
}
__attribute__((visibility("default")))
-void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset) {
- GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, destBuffer, destOffset);
+void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+ GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
}
__attribute__((visibility("default")))
}
Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
- return reinterpret_cast<Surface*>(handle.handle);
+ return reinterpret_cast<Surface*>(handle);
}
struct Swapchain {
}
Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
- return reinterpret_cast<Swapchain*>(handle.handle);
+ return reinterpret_cast<Swapchain*>(handle);
}
} // anonymous namespace
namespace null_driver {
-template <typename HandleT>
-struct HandleTraits {};
-
-template <typename HandleT>
-typename HandleTraits<HandleT>::PointerType GetObjectFromHandle(
- const HandleT& h) {
- return reinterpret_cast<typename HandleTraits<HandleT>::PointerType>(
- uintptr_t(h.handle));
-}
-
-template <typename T>
-typename T::HandleType GetHandleToObject(const T* obj) {
- return typename T::HandleType(reinterpret_cast<uintptr_t>(obj));
-}
+#define DEFINE_OBJECT_HANDLE_CONVERSION(T) \
+ T* Get##T##FromHandle(Vk##T h); \
+ T* Get##T##FromHandle(Vk##T h) { \
+ return reinterpret_cast<T*>(uintptr_t(h)); \
+ } \
+ Vk##T GetHandleTo##T(const T* obj); \
+ Vk##T GetHandleTo##T(const T* obj) { \
+ return Vk##T(reinterpret_cast<uintptr_t>(obj)); \
+ }
// -----------------------------------------------------------------------------
// Global
VkDeviceSize size;
alignas(16) uint8_t data[0];
};
-template <>
-struct HandleTraits<VkDeviceMemory> {
- typedef DeviceMemory* PointerType;
-};
+DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
VkResult AllocMemory(VkDevice device,
const VkMemoryAllocInfo* alloc_info,
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
mem->size = size;
- *mem_handle = GetHandleToObject(mem);
+ *mem_handle = GetHandleToDeviceMemory(mem);
return VK_SUCCESS;
}
void FreeMemory(VkDevice device, VkDeviceMemory mem_handle) {
const VkAllocCallbacks* alloc = device->instance->alloc;
- DeviceMemory* mem = GetObjectFromHandle(mem_handle);
+ DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
alloc->pfnFree(alloc->pUserData, mem);
}
VkDeviceSize,
VkMemoryMapFlags,
void** out_ptr) {
- DeviceMemory* mem = GetObjectFromHandle(mem_handle);
+ DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
*out_ptr = &mem->data[0] + offset;
return VK_SUCCESS;
}
typedef VkBuffer HandleType;
VkDeviceSize size;
};
-template <>
-struct HandleTraits<VkBuffer> {
- typedef Buffer* PointerType;
-};
+DEFINE_OBJECT_HANDLE_CONVERSION(Buffer)
VkResult CreateBuffer(VkDevice device,
const VkBufferCreateInfo* create_info,
if (!buffer)
return VK_ERROR_OUT_OF_HOST_MEMORY;
buffer->size = create_info->size;
- *buffer_handle = GetHandleToObject(buffer);
+ *buffer_handle = GetHandleToBuffer(buffer);
return VK_SUCCESS;
}
void GetBufferMemoryRequirements(VkDevice,
VkBuffer buffer_handle,
VkMemoryRequirements* requirements) {
- Buffer* buffer = GetObjectFromHandle(buffer_handle);
+ Buffer* buffer = GetBufferFromHandle(buffer_handle);
requirements->size = buffer->size;
requirements->alignment = 16; // allow fast Neon/SSE memcpy
requirements->memoryTypeBits = 0x1;
void DestroyBuffer(VkDevice device, VkBuffer buffer_handle) {
const VkAllocCallbacks* alloc = device->instance->alloc;
- Buffer* buffer = GetObjectFromHandle(buffer_handle);
+ Buffer* buffer = GetBufferFromHandle(buffer_handle);
alloc->pfnFree(alloc->pUserData, buffer);
}
typedef VkImage HandleType;
VkDeviceSize size;
};
-template <>
-struct HandleTraits<VkImage> {
- typedef Image* PointerType;
-};
+DEFINE_OBJECT_HANDLE_CONVERSION(Image)
VkResult CreateImage(VkDevice device,
const VkImageCreateInfo* create_info,
if (!image)
return VK_ERROR_OUT_OF_HOST_MEMORY;
image->size = size;
- *image_handle = GetHandleToObject(image);
+ *image_handle = GetHandleToImage(image);
return VK_SUCCESS;
}
void GetImageMemoryRequirements(VkDevice,
VkImage image_handle,
VkMemoryRequirements* requirements) {
- Image* image = GetObjectFromHandle(image_handle);
+ Image* image = GetImageFromHandle(image_handle);
requirements->size = image->size;
requirements->alignment = 16; // allow fast Neon/SSE memcpy
requirements->memoryTypeBits = 0x1;
void DestroyImage(VkDevice device, VkImage image_handle) {
const VkAllocCallbacks* alloc = device->instance->alloc;
- Image* image = GetObjectFromHandle(image_handle);
+ Image* image = GetImageFromHandle(image_handle);
alloc->pfnFree(alloc->pUserData, image);
}
void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
}
-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset) {
+void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
}
void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer destBuffer, VkDeviceSize destOffset);
+void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
return "DMA";
case VK_QUEUE_SPARSE_MEMMGR_BIT:
return "SPARSE";
- case VK_QUEUE_EXTENDED_BIT:
- return "EXT";
}
}
OSDN Git Service
