cc/gapii/vulkan_device_exports.cpp

/*
 * Copyright 2015, The Android Open Source Project
 *
 * 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.
 *
 * THIS FILE WAS GENERATED BY apic. DO NOT EDIT.
 */


#include "vulkan_types.h"
#include "vulkan_spy.h"
#include "vulkan_exports.h"
#include "spy.h"

#include <gapic/get_gfx_proc_address.h>
#include <gapic/lock.h>
#include <gapic/log.h>
#include <gapic/target.h> // STDCALL

#include <memory>

#include <cstring>

using namespace gapii;

namespace gapii {
    VKAPI_ATTR uint32_t VKAPI_CALL vkGetSwapchainGrallocUsageANDROID(VkDevice device, uint32_t format, VkImageUsageFlags imageUsage, int* grallocUsage) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetSwapchainGrallocUsageANDROID");
        auto _result_ = s->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkAcquireImageANDROID");
        auto _result_ = s->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDeviceWaitIdle");
        auto _result_ = s->vkDeviceWaitIdle(device);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkAllocateMemory(VkDevice device, VkMemoryAllocateInfo* pAllocateInfo, VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkAllocateMemory");
        auto _result_ = s->vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkFreeMemory");
        s->vkFreeMemory(device, memory, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkMapMemory");
        auto _result_ = s->vkMapMemory(device, memory, offset, size, flags, ppData);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkUnmapMemory");
        s->vkUnmapMemory(device, memory);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange* pMemoryRanges) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkFlushMappedMemoryRanges");
        auto _result_ = s->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, VkMappedMemoryRange* pMemoryRanges) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkInvalidateMappedMemoryRanges");
        auto _result_ = s->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetDeviceMemoryCommitment");
        s->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkBindBufferMemory");
        auto _result_ = s->vkBindBufferMemory(device, buffer, memory, memoryOffset);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkBindImageMemory");
        auto _result_ = s->vkBindImageMemory(device, image, memory, memoryOffset);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetBufferMemoryRequirements");
        s->vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetImageMemoryRequirements");
        s->vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetImageSparseMemoryRequirements");
        s->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateFence(VkDevice device, VkFenceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkFence* pFence) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateFence");
        auto _result_ = s->vkCreateFence(device, pCreateInfo, pAllocator, pFence);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyFence");
        s->vkDestroyFence(device, fence, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkResetFences");
        auto _result_ = s->vkResetFences(device, fenceCount, pFences);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetFenceStatus");
        auto _result_ = s->vkGetFenceStatus(device, fence);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkWaitForFences");
        auto _result_ = s->vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateSemaphore(VkDevice device, VkSemaphoreCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateSemaphore");
        auto _result_ = s->vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroySemaphore");
        s->vkDestroySemaphore(device, semaphore, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateEvent(VkDevice device, VkEventCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateEvent");
        auto _result_ = s->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyEvent");
        s->vkDestroyEvent(device, event, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetEventStatus");
        auto _result_ = s->vkGetEventStatus(device, event);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkSetEvent");
        auto _result_ = s->vkSetEvent(device, event);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkResetEvent");
        auto _result_ = s->vkResetEvent(device, event);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateQueryPool(VkDevice device, VkQueryPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateQueryPool");
        auto _result_ = s->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyQueryPool");
        s->vkDestroyQueryPool(device, queryPool, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetQueryPoolResults");
        auto _result_ = s->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateBuffer(VkDevice device, VkBufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateBuffer");
        auto _result_ = s->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyBuffer");
        s->vkDestroyBuffer(device, buffer, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateBufferView(VkDevice device, VkBufferViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateBufferView");
        auto _result_ = s->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyBufferView");
        s->vkDestroyBufferView(device, bufferView, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateImage(VkDevice device, VkImageCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkImage* pImage) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateImage");
        auto _result_ = s->vkCreateImage(device, pCreateInfo, pAllocator, pImage);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyImage");
        s->vkDestroyImage(device, image, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetImageSubresourceLayout");
        s->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateImageView(VkDevice device, VkImageViewCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkImageView* pView) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateImageView");
        auto _result_ = s->vkCreateImageView(device, pCreateInfo, pAllocator, pView);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyImageView");
        s->vkDestroyImageView(device, imageView, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateShaderModule(VkDevice device, VkShaderModuleCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateShaderModule");
        auto _result_ = s->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyShaderModule");
        s->vkDestroyShaderModule(device, shaderModule, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreatePipelineCache(VkDevice device, VkPipelineCacheCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreatePipelineCache");
        auto _result_ = s->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyPipelineCache");
        s->vkDestroyPipelineCache(device, pipelineCache, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetPipelineCacheData");
        auto _result_ = s->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, VkPipelineCache* pSrcCaches) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkMergePipelineCaches");
        auto _result_ = s->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkGraphicsPipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateGraphicsPipelines");
        auto _result_ = s->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, VkComputePipelineCreateInfo* pCreateInfos, VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateComputePipelines");
        auto _result_ = s->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyPipeline");
        s->vkDestroyPipeline(device, pipeline, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreatePipelineLayout(VkDevice device, VkPipelineLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreatePipelineLayout");
        auto _result_ = s->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyPipelineLayout");
        s->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateSampler(VkDevice device, VkSamplerCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateSampler");
        auto _result_ = s->vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroySampler");
        s->vkDestroySampler(device, sampler, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateDescriptorSetLayout");
        auto _result_ = s->vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyDescriptorSetLayout");
        s->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateDescriptorPool");
        auto _result_ = s->vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyDescriptorPool");
        s->vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkResetDescriptorPool");
        auto _result_ = s->vkResetDescriptorPool(device, descriptorPool, flags);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkAllocateDescriptorSets");
        auto _result_ = s->vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, VkDescriptorSet* pDescriptorSets) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkFreeDescriptorSets");
        auto _result_ = s->vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, VkCopyDescriptorSet* pDescriptorCopies) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkUpdateDescriptorSets");
        s->vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateFramebuffer(VkDevice device, VkFramebufferCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateFramebuffer");
        auto _result_ = s->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyFramebuffer");
        s->vkDestroyFramebuffer(device, framebuffer, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateRenderPass(VkDevice device, VkRenderPassCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateRenderPass");
        auto _result_ = s->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyRenderPass");
        s->vkDestroyRenderPass(device, renderPass, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetRenderAreaGranularity");
        s->vkGetRenderAreaGranularity(device, renderPass, pGranularity);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateCommandPool(VkDevice device, VkCommandPoolCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateCommandPool");
        auto _result_ = s->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroyCommandPool");
        s->vkDestroyCommandPool(device, commandPool, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkResetCommandPool");
        auto _result_ = s->vkResetCommandPool(device, commandPool, flags);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, VkCommandBuffer* pCommandBuffers) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkFreeCommandBuffers");
        s->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, VkSwapchainCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateSwapchainKHR");
        auto _result_ = s->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, VkAllocationCallbacks* pAllocator) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkDestroySwapchainKHR");
        s->vkDestroySwapchainKHR(device, swapchain, pAllocator);
        s->VulkanSpy::exit();
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkGetSwapchainImagesKHR");
        auto _result_ = s->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkAcquireNextImageKHR");
        auto _result_ = s->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
        s->VulkanSpy::exit();
        return _result_;
    }
    VKAPI_ATTR uint32_t VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, VkSwapchainCreateInfoKHR* pCreateInfos, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
        Spy* s = Spy::get();
        s->VulkanSpy::enter("vkCreateSharedSwapchainsKHR");
        auto _result_ = s->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
        s->VulkanSpy::exit();
        return _result_;
    }
}