1/* WARNING: This is auto-generated file. Do not modify, since changes will 2 * be lost! Modify the generating script instead. 3 * This file was generated by /scripts/gen_framework.py 4 */ 5 6 7PFN_vkVoidFunction DeviceDriverSC::getDeviceProcAddr (VkDevice device, const char* pName) const 8{ 9 return m_vk.getDeviceProcAddr(device, pName); 10} 11 12void DeviceDriverSC::destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator) const 13{ 14 std::lock_guard<std::mutex> lock(functionMutex); 15 if (m_normalMode) 16 m_vk.destroyDevice(device, pAllocator); 17 else 18 destroyDeviceHandler(device, pAllocator); 19} 20 21void DeviceDriverSC::getDeviceQueue (VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) const 22{ 23 std::lock_guard<std::mutex> lock(functionMutex); 24 if (m_normalMode) 25 m_vk.getDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 26 else 27 m_vk.getDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 28} 29 30VkResult DeviceDriverSC::queueSubmit (VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const 31{ 32 if (m_normalMode) 33 return m_vk.queueSubmit(queue, submitCount, pSubmits, fence); 34 return VK_SUCCESS; 35} 36 37VkResult DeviceDriverSC::queueWaitIdle (VkQueue queue) const 38{ 39 if (m_normalMode) 40 return m_vk.queueWaitIdle(queue); 41 return VK_SUCCESS; 42} 43 44VkResult DeviceDriverSC::deviceWaitIdle (VkDevice device) const 45{ 46 if (m_normalMode) 47 return m_vk.deviceWaitIdle(device); 48 return VK_SUCCESS; 49} 50 51VkResult DeviceDriverSC::allocateMemory (VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) const 52{ 53 std::lock_guard<std::mutex> lock(functionMutex); 54 if (m_normalMode) 55 return m_vk.allocateMemory(device, pAllocateInfo, pAllocator, pMemory); 56 else 57 { 58 DDSTAT_LOCK(); 59 DDSTAT_HANDLE_CREATE(deviceMemoryRequestCount,1); 60 *pMemory = Handle<HANDLE_TYPE_DEVICE_MEMORY>(m_resourceInterface->incResourceCounter()); 61 } 62 return VK_SUCCESS; 63} 64 65VkResult DeviceDriverSC::mapMemory (VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const 66{ 67 std::lock_guard<std::mutex> lock(functionMutex); 68 if (m_normalMode) 69 return m_vk.mapMemory(device, memory, offset, size, flags, ppData); 70 else 71 { 72 DDSTAT_LOCK(); 73 if(m_falseMemory.size() < (static_cast<std::size_t>(offset+size))) 74 m_falseMemory.resize(static_cast<std::size_t>(offset+size)); 75 *ppData = (void*)m_falseMemory.data(); 76 } 77 return VK_SUCCESS; 78} 79 80void DeviceDriverSC::unmapMemory (VkDevice device, VkDeviceMemory memory) const 81{ 82 if (m_normalMode) 83 m_vk.unmapMemory(device, memory); 84} 85 86VkResult DeviceDriverSC::flushMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const 87{ 88 if (m_normalMode) 89 return m_vk.flushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 90 return VK_SUCCESS; 91} 92 93VkResult DeviceDriverSC::invalidateMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const 94{ 95 if (m_normalMode) 96 return m_vk.invalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 97 return VK_SUCCESS; 98} 99 100void DeviceDriverSC::getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const 101{ 102 if (m_normalMode) 103 m_vk.getDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 104} 105 106VkResult DeviceDriverSC::bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const 107{ 108 if (m_normalMode) 109 return m_vk.bindBufferMemory(device, buffer, memory, memoryOffset); 110 return VK_SUCCESS; 111} 112 113VkResult DeviceDriverSC::bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const 114{ 115 if (m_normalMode) 116 return m_vk.bindImageMemory(device, image, memory, memoryOffset); 117 return VK_SUCCESS; 118} 119 120void DeviceDriverSC::getBufferMemoryRequirements (VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const 121{ 122 std::lock_guard<std::mutex> lock(functionMutex); 123 if (m_normalMode) 124 m_vk.getBufferMemoryRequirements(device, buffer, pMemoryRequirements); 125 else 126 { 127 DDSTAT_LOCK(); 128 pMemoryRequirements->size = 1048576U; 129 pMemoryRequirements->alignment = 1U; 130 pMemoryRequirements->memoryTypeBits = ~0U; 131 } 132} 133 134void DeviceDriverSC::getImageMemoryRequirements (VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) const 135{ 136 std::lock_guard<std::mutex> lock(functionMutex); 137 if (m_normalMode) 138 m_vk.getImageMemoryRequirements(device, image, pMemoryRequirements); 139 else 140 { 141 DDSTAT_LOCK(); 142 pMemoryRequirements->size = 1048576U; 143 pMemoryRequirements->alignment = 1U; 144 pMemoryRequirements->memoryTypeBits = ~0U; 145 } 146} 147 148VkResult DeviceDriverSC::createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const 149{ 150 std::lock_guard<std::mutex> lock(functionMutex); 151 if (m_normalMode) 152 return m_vk.createFence(device, pCreateInfo, pAllocator, pFence); 153 else 154 { 155 DDSTAT_LOCK(); 156 DDSTAT_HANDLE_CREATE(fenceRequestCount,1); 157 *pFence = Handle<HANDLE_TYPE_FENCE>(m_resourceInterface->incResourceCounter()); 158 } 159 return VK_SUCCESS; 160} 161 162void DeviceDriverSC::destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) const 163{ 164 std::lock_guard<std::mutex> lock(functionMutex); 165 if (m_normalMode) 166 m_vk.destroyFence(device, fence, pAllocator); 167 else 168 { 169 DDSTAT_LOCK(); 170 DDSTAT_HANDLE_DESTROY_IF(fence,fenceRequestCount,1); 171 } 172} 173 174VkResult DeviceDriverSC::resetFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences) const 175{ 176 if (m_normalMode) 177 return m_vk.resetFences(device, fenceCount, pFences); 178 return VK_SUCCESS; 179} 180 181VkResult DeviceDriverSC::getFenceStatus (VkDevice device, VkFence fence) const 182{ 183 if (m_normalMode) 184 return m_vk.getFenceStatus(device, fence); 185 return VK_SUCCESS; 186} 187 188VkResult DeviceDriverSC::waitForFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) const 189{ 190 if (m_normalMode) 191 return m_vk.waitForFences(device, fenceCount, pFences, waitAll, timeout); 192 return VK_SUCCESS; 193} 194 195VkResult DeviceDriverSC::createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) const 196{ 197 std::lock_guard<std::mutex> lock(functionMutex); 198 if (m_normalMode) 199 return m_vk.createSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 200 else 201 { 202 DDSTAT_LOCK(); 203 DDSTAT_HANDLE_CREATE(semaphoreRequestCount,1); 204 *pSemaphore = Handle<HANDLE_TYPE_SEMAPHORE>(m_resourceInterface->incResourceCounter()); 205 } 206 return VK_SUCCESS; 207} 208 209void DeviceDriverSC::destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const 210{ 211 std::lock_guard<std::mutex> lock(functionMutex); 212 if (m_normalMode) 213 m_vk.destroySemaphore(device, semaphore, pAllocator); 214 else 215 { 216 DDSTAT_LOCK(); 217 DDSTAT_HANDLE_DESTROY_IF(semaphore,semaphoreRequestCount,1); 218 } 219} 220 221VkResult DeviceDriverSC::createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) const 222{ 223 std::lock_guard<std::mutex> lock(functionMutex); 224 if (m_normalMode) 225 return m_vk.createEvent(device, pCreateInfo, pAllocator, pEvent); 226 else 227 { 228 DDSTAT_LOCK(); 229 DDSTAT_HANDLE_CREATE(eventRequestCount,1); 230 *pEvent = Handle<HANDLE_TYPE_EVENT>(m_resourceInterface->incResourceCounter()); 231 } 232 return VK_SUCCESS; 233} 234 235void DeviceDriverSC::destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) const 236{ 237 std::lock_guard<std::mutex> lock(functionMutex); 238 if (m_normalMode) 239 m_vk.destroyEvent(device, event, pAllocator); 240 else 241 { 242 DDSTAT_LOCK(); 243 DDSTAT_HANDLE_DESTROY_IF(event,eventRequestCount,1); 244 } 245} 246 247VkResult DeviceDriverSC::getEventStatus (VkDevice device, VkEvent event) const 248{ 249 if (m_normalMode) 250 return m_vk.getEventStatus(device, event); 251 return VK_SUCCESS; 252} 253 254VkResult DeviceDriverSC::setEvent (VkDevice device, VkEvent event) const 255{ 256 if (m_normalMode) 257 return m_vk.setEvent(device, event); 258 return VK_SUCCESS; 259} 260 261VkResult DeviceDriverSC::resetEvent (VkDevice device, VkEvent event) const 262{ 263 if (m_normalMode) 264 return m_vk.resetEvent(device, event); 265 return VK_SUCCESS; 266} 267 268VkResult DeviceDriverSC::createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const 269{ 270 std::lock_guard<std::mutex> lock(functionMutex); 271 if (m_normalMode) 272 return m_vk.createQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 273 else 274 createQueryPoolHandler(device, pCreateInfo, pAllocator, pQueryPool); 275 return VK_SUCCESS; 276} 277 278VkResult DeviceDriverSC::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const 279{ 280 if (m_normalMode) 281 return m_vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); 282 return VK_SUCCESS; 283} 284 285VkResult DeviceDriverSC::createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const 286{ 287 std::lock_guard<std::mutex> lock(functionMutex); 288 if (m_normalMode) 289 return m_vk.createBuffer(device, pCreateInfo, pAllocator, pBuffer); 290 else 291 { 292 DDSTAT_LOCK(); 293 DDSTAT_HANDLE_CREATE(bufferRequestCount,1); 294 *pBuffer = Handle<HANDLE_TYPE_BUFFER>(m_resourceInterface->incResourceCounter()); 295 } 296 return VK_SUCCESS; 297} 298 299void DeviceDriverSC::destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const 300{ 301 std::lock_guard<std::mutex> lock(functionMutex); 302 if (m_normalMode) 303 m_vk.destroyBuffer(device, buffer, pAllocator); 304 else 305 { 306 DDSTAT_LOCK(); 307 DDSTAT_HANDLE_DESTROY_IF(buffer,bufferRequestCount,1); 308 } 309} 310 311VkResult DeviceDriverSC::createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const 312{ 313 std::lock_guard<std::mutex> lock(functionMutex); 314 if (m_normalMode) 315 return m_vk.createBufferView(device, pCreateInfo, pAllocator, pView); 316 else 317 { 318 DDSTAT_LOCK(); 319 DDSTAT_HANDLE_CREATE(bufferViewRequestCount,1); 320 *pView = Handle<HANDLE_TYPE_BUFFER_VIEW>(m_resourceInterface->incResourceCounter()); 321 } 322 return VK_SUCCESS; 323} 324 325void DeviceDriverSC::destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const 326{ 327 std::lock_guard<std::mutex> lock(functionMutex); 328 if (m_normalMode) 329 m_vk.destroyBufferView(device, bufferView, pAllocator); 330 else 331 { 332 DDSTAT_LOCK(); 333 DDSTAT_HANDLE_DESTROY_IF(bufferView,bufferViewRequestCount,1); 334 } 335} 336 337VkResult DeviceDriverSC::createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) const 338{ 339 std::lock_guard<std::mutex> lock(functionMutex); 340 if (m_normalMode) 341 return m_vk.createImage(device, pCreateInfo, pAllocator, pImage); 342 else 343 { 344 DDSTAT_LOCK(); 345 DDSTAT_HANDLE_CREATE(imageRequestCount,1); 346 *pImage = Handle<HANDLE_TYPE_IMAGE>(m_resourceInterface->incResourceCounter()); 347 } 348 return VK_SUCCESS; 349} 350 351void DeviceDriverSC::destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) const 352{ 353 std::lock_guard<std::mutex> lock(functionMutex); 354 if (m_normalMode) 355 m_vk.destroyImage(device, image, pAllocator); 356 else 357 { 358 DDSTAT_LOCK(); 359 DDSTAT_HANDLE_DESTROY_IF(image,imageRequestCount,1); 360 } 361} 362 363void DeviceDriverSC::getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const 364{ 365 std::lock_guard<std::mutex> lock(functionMutex); 366 if (m_normalMode) 367 m_vk.getImageSubresourceLayout(device, image, pSubresource, pLayout); 368 else 369 { 370 DDSTAT_LOCK(); 371 pLayout->offset = 0U; 372 pLayout->size = 1048576U; 373 pLayout->rowPitch = 0U; 374 pLayout->arrayPitch = 0U; 375 pLayout->depthPitch = 0U; 376 } 377} 378 379VkResult DeviceDriverSC::createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) const 380{ 381 std::lock_guard<std::mutex> lock(functionMutex); 382 if (m_normalMode) 383 return m_vk.createImageView(device, pCreateInfo, pAllocator, pView); 384 else 385 createImageViewHandler(device, pCreateInfo, pAllocator, pView); 386 return VK_SUCCESS; 387} 388 389void DeviceDriverSC::destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) const 390{ 391 std::lock_guard<std::mutex> lock(functionMutex); 392 if (m_normalMode) 393 m_vk.destroyImageView(device, imageView, pAllocator); 394 else 395 destroyImageViewHandler(device, imageView, pAllocator); 396} 397 398VkResult DeviceDriverSC::createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) const 399{ 400 std::lock_guard<std::mutex> lock(functionMutex); 401 if (m_normalMode) 402 return m_vk.createPipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 403 else 404 { 405 DDSTAT_LOCK(); 406 DDSTAT_HANDLE_CREATE(pipelineCacheRequestCount,1); 407 *pPipelineCache = Handle<HANDLE_TYPE_PIPELINE_CACHE>(m_resourceInterface->incResourceCounter()); 408 } 409 return VK_SUCCESS; 410} 411 412void DeviceDriverSC::destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const 413{ 414 std::lock_guard<std::mutex> lock(functionMutex); 415 if (m_normalMode) 416 m_vk.destroyPipelineCache(device, pipelineCache, pAllocator); 417 else 418 { 419 DDSTAT_LOCK(); 420 DDSTAT_HANDLE_DESTROY_IF(pipelineCache,pipelineCacheRequestCount,1); 421 } 422} 423 424VkResult DeviceDriverSC::createGraphicsPipelines (VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const 425{ 426 std::lock_guard<std::mutex> lock(functionMutex); 427 if (m_normalMode) 428 return createGraphicsPipelinesHandlerNorm(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 429 else 430 createGraphicsPipelinesHandlerStat(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 431 return VK_SUCCESS; 432} 433 434VkResult DeviceDriverSC::createComputePipelines (VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const 435{ 436 std::lock_guard<std::mutex> lock(functionMutex); 437 if (m_normalMode) 438 return createComputePipelinesHandlerNorm(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 439 else 440 createComputePipelinesHandlerStat(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 441 return VK_SUCCESS; 442} 443 444void DeviceDriverSC::destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const 445{ 446 std::lock_guard<std::mutex> lock(functionMutex); 447 if (m_normalMode) 448 m_vk.destroyPipeline(device, pipeline, pAllocator); 449 else 450 destroyPipelineHandler(device, pipeline, pAllocator); 451} 452 453VkResult DeviceDriverSC::createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) const 454{ 455 std::lock_guard<std::mutex> lock(functionMutex); 456 if (m_normalMode) 457 return createPipelineLayoutHandlerNorm(device, pCreateInfo, pAllocator, pPipelineLayout); 458 else 459 createPipelineLayoutHandlerStat(device, pCreateInfo, pAllocator, pPipelineLayout); 460 return VK_SUCCESS; 461} 462 463void DeviceDriverSC::destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const 464{ 465 std::lock_guard<std::mutex> lock(functionMutex); 466 if (m_normalMode) 467 m_vk.destroyPipelineLayout(device, pipelineLayout, pAllocator); 468 else 469 { 470 DDSTAT_LOCK(); 471 DDSTAT_HANDLE_DESTROY_IF(pipelineLayout,pipelineLayoutRequestCount,1); 472 } 473} 474 475VkResult DeviceDriverSC::createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) const 476{ 477 std::lock_guard<std::mutex> lock(functionMutex); 478 if (m_normalMode) 479 return createSamplerHandlerNorm(device, pCreateInfo, pAllocator, pSampler); 480 else 481 createSamplerHandlerStat(device, pCreateInfo, pAllocator, pSampler); 482 return VK_SUCCESS; 483} 484 485void DeviceDriverSC::destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) const 486{ 487 std::lock_guard<std::mutex> lock(functionMutex); 488 if (m_normalMode) 489 m_vk.destroySampler(device, sampler, pAllocator); 490 else 491 { 492 DDSTAT_LOCK(); 493 DDSTAT_HANDLE_DESTROY_IF(sampler,samplerRequestCount,1); 494 } 495} 496 497VkResult DeviceDriverSC::createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) const 498{ 499 std::lock_guard<std::mutex> lock(functionMutex); 500 if (m_normalMode) 501 return createDescriptorSetLayoutHandlerNorm(device, pCreateInfo, pAllocator, pSetLayout); 502 else 503 createDescriptorSetLayoutHandlerStat(device, pCreateInfo, pAllocator, pSetLayout); 504 return VK_SUCCESS; 505} 506 507void DeviceDriverSC::destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) const 508{ 509 std::lock_guard<std::mutex> lock(functionMutex); 510 if (m_normalMode) 511 m_vk.destroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 512 else 513 destroyDescriptorSetLayoutHandler(device, descriptorSetLayout, pAllocator); 514} 515 516VkResult DeviceDriverSC::createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) const 517{ 518 std::lock_guard<std::mutex> lock(functionMutex); 519 if (m_normalMode) 520 return m_vk.createDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 521 else 522 { 523 DDSTAT_LOCK(); 524 DDSTAT_HANDLE_CREATE(descriptorPoolRequestCount,1); 525 *pDescriptorPool = Handle<HANDLE_TYPE_DESCRIPTOR_POOL>(m_resourceInterface->incResourceCounter()); 526 } 527 return VK_SUCCESS; 528} 529 530VkResult DeviceDriverSC::resetDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const 531{ 532 std::lock_guard<std::mutex> lock(functionMutex); 533 if (m_normalMode) 534 return m_vk.resetDescriptorPool(device, descriptorPool, flags); 535 else 536 resetDescriptorPoolHandlerStat(device, descriptorPool, flags); 537 return VK_SUCCESS; 538} 539 540VkResult DeviceDriverSC::allocateDescriptorSets (VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) const 541{ 542 std::lock_guard<std::mutex> lock(functionMutex); 543 if (m_normalMode) 544 return m_vk.allocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 545 else 546 allocateDescriptorSetsHandlerStat(device, pAllocateInfo, pDescriptorSets); 547 return VK_SUCCESS; 548} 549 550VkResult DeviceDriverSC::freeDescriptorSets (VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) const 551{ 552 std::lock_guard<std::mutex> lock(functionMutex); 553 if (m_normalMode) 554 return m_vk.freeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 555 else 556 freeDescriptorSetsHandlerStat(device, descriptorPool, descriptorSetCount, pDescriptorSets); 557 return VK_SUCCESS; 558} 559 560void DeviceDriverSC::updateDescriptorSets (VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) const 561{ 562 if (m_normalMode) 563 m_vk.updateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 564} 565 566VkResult DeviceDriverSC::createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) const 567{ 568 std::lock_guard<std::mutex> lock(functionMutex); 569 if (m_normalMode) 570 return createFramebufferHandlerNorm(device, pCreateInfo, pAllocator, pFramebuffer); 571 else 572 createFramebufferHandlerStat(device, pCreateInfo, pAllocator, pFramebuffer); 573 return VK_SUCCESS; 574} 575 576void DeviceDriverSC::destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const 577{ 578 std::lock_guard<std::mutex> lock(functionMutex); 579 if (m_normalMode) 580 m_vk.destroyFramebuffer(device, framebuffer, pAllocator); 581 else 582 { 583 DDSTAT_LOCK(); 584 DDSTAT_HANDLE_DESTROY_IF(framebuffer,framebufferRequestCount,1); 585 } 586} 587 588VkResult DeviceDriverSC::createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const 589{ 590 std::lock_guard<std::mutex> lock(functionMutex); 591 if (m_normalMode) 592 return createRenderPassHandlerNorm(device, pCreateInfo, pAllocator, pRenderPass); 593 else 594 createRenderPassHandlerStat(device, pCreateInfo, pAllocator, pRenderPass); 595 return VK_SUCCESS; 596} 597 598void DeviceDriverSC::destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const 599{ 600 std::lock_guard<std::mutex> lock(functionMutex); 601 if (m_normalMode) 602 m_vk.destroyRenderPass(device, renderPass, pAllocator); 603 else 604 destroyRenderPassHandler(device, renderPass, pAllocator); 605} 606 607void DeviceDriverSC::getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) const 608{ 609 if (m_normalMode) 610 m_vk.getRenderAreaGranularity(device, renderPass, pGranularity); 611} 612 613VkResult DeviceDriverSC::createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) const 614{ 615 std::lock_guard<std::mutex> lock(functionMutex); 616 if (m_normalMode) 617 return createCommandPoolHandlerNorm(device, pCreateInfo, pAllocator, pCommandPool); 618 else 619 createCommandPoolHandlerStat(device, pCreateInfo, pAllocator, pCommandPool); 620 return VK_SUCCESS; 621} 622 623VkResult DeviceDriverSC::resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const 624{ 625 std::lock_guard<std::mutex> lock(functionMutex); 626 if (m_normalMode) 627 return resetCommandPoolHandlerNorm(device, commandPool, flags); 628 else 629 resetCommandPoolHandlerStat(device, commandPool, flags); 630 return VK_SUCCESS; 631} 632 633VkResult DeviceDriverSC::allocateCommandBuffers (VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) const 634{ 635 std::lock_guard<std::mutex> lock(functionMutex); 636 if (m_normalMode) 637 return m_vk.allocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 638 else 639 allocateCommandBuffersHandler(device, pAllocateInfo, pCommandBuffers); 640 return VK_SUCCESS; 641} 642 643void DeviceDriverSC::freeCommandBuffers (VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const 644{ 645 std::lock_guard<std::mutex> lock(functionMutex); 646 if (m_normalMode) 647 m_vk.freeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 648 else 649 freeCommandBuffersHandler(device, commandPool, commandBufferCount, pCommandBuffers); 650} 651 652VkResult DeviceDriverSC::beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) const 653{ 654 if (m_normalMode) 655 return m_vk.beginCommandBuffer(commandBuffer, pBeginInfo); 656 return VK_SUCCESS; 657} 658 659VkResult DeviceDriverSC::endCommandBuffer (VkCommandBuffer commandBuffer) const 660{ 661 if (m_normalMode) 662 return m_vk.endCommandBuffer(commandBuffer); 663 return VK_SUCCESS; 664} 665 666VkResult DeviceDriverSC::resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const 667{ 668 if (m_normalMode) 669 return m_vk.resetCommandBuffer(commandBuffer, flags); 670 return VK_SUCCESS; 671} 672 673void DeviceDriverSC::cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const 674{ 675 if (m_normalMode) 676 m_vk.cmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 677 else 678 increaseCommandBufferSize(commandBuffer, 0u); 679} 680 681void DeviceDriverSC::cmdSetViewport (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) const 682{ 683 if (m_normalMode) 684 m_vk.cmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); 685 else 686 increaseCommandBufferSize(commandBuffer, 0u); 687} 688 689void DeviceDriverSC::cmdSetScissor (VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) const 690{ 691 if (m_normalMode) 692 m_vk.cmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 693 else 694 increaseCommandBufferSize(commandBuffer, 0u); 695} 696 697void DeviceDriverSC::cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) const 698{ 699 if (m_normalMode) 700 m_vk.cmdSetLineWidth(commandBuffer, lineWidth); 701 else 702 increaseCommandBufferSize(commandBuffer, 0u); 703} 704 705void DeviceDriverSC::cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const 706{ 707 if (m_normalMode) 708 m_vk.cmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 709 else 710 increaseCommandBufferSize(commandBuffer, 0u); 711} 712 713void DeviceDriverSC::cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4]) const 714{ 715 if (m_normalMode) 716 m_vk.cmdSetBlendConstants(commandBuffer, blendConstants); 717 else 718 increaseCommandBufferSize(commandBuffer, 0u); 719} 720 721void DeviceDriverSC::cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const 722{ 723 if (m_normalMode) 724 m_vk.cmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 725 else 726 increaseCommandBufferSize(commandBuffer, 0u); 727} 728 729void DeviceDriverSC::cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const 730{ 731 if (m_normalMode) 732 m_vk.cmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 733 else 734 increaseCommandBufferSize(commandBuffer, 0u); 735} 736 737void DeviceDriverSC::cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const 738{ 739 if (m_normalMode) 740 m_vk.cmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 741 else 742 increaseCommandBufferSize(commandBuffer, 0u); 743} 744 745void DeviceDriverSC::cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const 746{ 747 if (m_normalMode) 748 m_vk.cmdSetStencilReference(commandBuffer, faceMask, reference); 749 else 750 increaseCommandBufferSize(commandBuffer, 0u); 751} 752 753void DeviceDriverSC::cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) const 754{ 755 if (m_normalMode) 756 m_vk.cmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 757 else 758 increaseCommandBufferSize(commandBuffer, 0u); 759} 760 761void DeviceDriverSC::cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const 762{ 763 if (m_normalMode) 764 m_vk.cmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 765 else 766 increaseCommandBufferSize(commandBuffer, 0u); 767} 768 769void DeviceDriverSC::cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const 770{ 771 if (m_normalMode) 772 m_vk.cmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); 773 else 774 increaseCommandBufferSize(commandBuffer, 0u); 775} 776 777void DeviceDriverSC::cmdDraw (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const 778{ 779 if (m_normalMode) 780 m_vk.cmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 781 else 782 increaseCommandBufferSize(commandBuffer, 0u); 783} 784 785void DeviceDriverSC::cmdDrawIndexed (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const 786{ 787 if (m_normalMode) 788 m_vk.cmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 789 else 790 increaseCommandBufferSize(commandBuffer, 0u); 791} 792 793void DeviceDriverSC::cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const 794{ 795 if (m_normalMode) 796 m_vk.cmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 797 else 798 increaseCommandBufferSize(commandBuffer, 0u); 799} 800 801void DeviceDriverSC::cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const 802{ 803 if (m_normalMode) 804 m_vk.cmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 805 else 806 increaseCommandBufferSize(commandBuffer, 0u); 807} 808 809void DeviceDriverSC::cmdDispatch (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const 810{ 811 if (m_normalMode) 812 m_vk.cmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); 813 else 814 increaseCommandBufferSize(commandBuffer, 0u); 815} 816 817void DeviceDriverSC::cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const 818{ 819 if (m_normalMode) 820 m_vk.cmdDispatchIndirect(commandBuffer, buffer, offset); 821 else 822 increaseCommandBufferSize(commandBuffer, 0u); 823} 824 825void DeviceDriverSC::cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) const 826{ 827 if (m_normalMode) 828 m_vk.cmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 829 else 830 increaseCommandBufferSize(commandBuffer, 0u); 831} 832 833void DeviceDriverSC::cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) const 834{ 835 if (m_normalMode) 836 m_vk.cmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 837 else 838 increaseCommandBufferSize(commandBuffer, 0u); 839} 840 841void DeviceDriverSC::cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) const 842{ 843 if (m_normalMode) 844 m_vk.cmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 845 else 846 increaseCommandBufferSize(commandBuffer, 0u); 847} 848 849void DeviceDriverSC::cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) const 850{ 851 if (m_normalMode) 852 m_vk.cmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 853 else 854 increaseCommandBufferSize(commandBuffer, 0u); 855} 856 857void DeviceDriverSC::cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) const 858{ 859 if (m_normalMode) 860 m_vk.cmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 861 else 862 increaseCommandBufferSize(commandBuffer, 0u); 863} 864 865void DeviceDriverSC::cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) const 866{ 867 std::lock_guard<std::mutex> lock(functionMutex); 868 if (m_normalMode) 869 m_vk.cmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 870 else 871 increaseCommandBufferSize(commandBuffer, dataSize); 872} 873 874void DeviceDriverSC::cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const 875{ 876 if (m_normalMode) 877 m_vk.cmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 878 else 879 increaseCommandBufferSize(commandBuffer, 0u); 880} 881 882void DeviceDriverSC::cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const 883{ 884 if (m_normalMode) 885 m_vk.cmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 886 else 887 increaseCommandBufferSize(commandBuffer, 0u); 888} 889 890void DeviceDriverSC::cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const 891{ 892 if (m_normalMode) 893 m_vk.cmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 894 else 895 increaseCommandBufferSize(commandBuffer, 0u); 896} 897 898void DeviceDriverSC::cmdClearAttachments (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) const 899{ 900 if (m_normalMode) 901 m_vk.cmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 902 else 903 increaseCommandBufferSize(commandBuffer, 0u); 904} 905 906void DeviceDriverSC::cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) const 907{ 908 if (m_normalMode) 909 m_vk.cmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 910 else 911 increaseCommandBufferSize(commandBuffer, 0u); 912} 913 914void DeviceDriverSC::cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const 915{ 916 if (m_normalMode) 917 m_vk.cmdSetEvent(commandBuffer, event, stageMask); 918 else 919 increaseCommandBufferSize(commandBuffer, 0u); 920} 921 922void DeviceDriverSC::cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const 923{ 924 if (m_normalMode) 925 m_vk.cmdResetEvent(commandBuffer, event, stageMask); 926 else 927 increaseCommandBufferSize(commandBuffer, 0u); 928} 929 930void DeviceDriverSC::cmdWaitEvents (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const 931{ 932 if (m_normalMode) 933 m_vk.cmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 934 else 935 increaseCommandBufferSize(commandBuffer, 0u); 936} 937 938void DeviceDriverSC::cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const 939{ 940 if (m_normalMode) 941 m_vk.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 942 else 943 increaseCommandBufferSize(commandBuffer, 0u); 944} 945 946void DeviceDriverSC::cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const 947{ 948 if (m_normalMode) 949 m_vk.cmdBeginQuery(commandBuffer, queryPool, query, flags); 950 else 951 increaseCommandBufferSize(commandBuffer, 0u); 952} 953 954void DeviceDriverSC::cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const 955{ 956 if (m_normalMode) 957 m_vk.cmdEndQuery(commandBuffer, queryPool, query); 958 else 959 increaseCommandBufferSize(commandBuffer, 0u); 960} 961 962void DeviceDriverSC::cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const 963{ 964 if (m_normalMode) 965 m_vk.cmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 966 else 967 increaseCommandBufferSize(commandBuffer, 0u); 968} 969 970void DeviceDriverSC::cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const 971{ 972 if (m_normalMode) 973 m_vk.cmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); 974 else 975 increaseCommandBufferSize(commandBuffer, 0u); 976} 977 978void DeviceDriverSC::cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const 979{ 980 if (m_normalMode) 981 m_vk.cmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); 982 else 983 increaseCommandBufferSize(commandBuffer, 0u); 984} 985 986void DeviceDriverSC::cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) const 987{ 988 if (m_normalMode) 989 m_vk.cmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 990 else 991 increaseCommandBufferSize(commandBuffer, 0u); 992} 993 994void DeviceDriverSC::cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const 995{ 996 if (m_normalMode) 997 m_vk.cmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 998 else 999 increaseCommandBufferSize(commandBuffer, 0u); 1000} 1001 1002void DeviceDriverSC::cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) const 1003{ 1004 if (m_normalMode) 1005 m_vk.cmdNextSubpass(commandBuffer, contents); 1006 else 1007 increaseCommandBufferSize(commandBuffer, 0u); 1008} 1009 1010void DeviceDriverSC::cmdEndRenderPass (VkCommandBuffer commandBuffer) const 1011{ 1012 if (m_normalMode) 1013 m_vk.cmdEndRenderPass(commandBuffer); 1014 else 1015 increaseCommandBufferSize(commandBuffer, 0u); 1016} 1017 1018void DeviceDriverSC::cmdExecuteCommands (VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const 1019{ 1020 if (m_normalMode) 1021 m_vk.cmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); 1022 else 1023 increaseCommandBufferSize(commandBuffer, 0u); 1024} 1025 1026VkResult DeviceDriverSC::bindBufferMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const 1027{ 1028 if (m_normalMode) 1029 return m_vk.bindBufferMemory2(device, bindInfoCount, pBindInfos); 1030 return VK_SUCCESS; 1031} 1032 1033VkResult DeviceDriverSC::bindImageMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const 1034{ 1035 if (m_normalMode) 1036 return m_vk.bindImageMemory2(device, bindInfoCount, pBindInfos); 1037 return VK_SUCCESS; 1038} 1039 1040void DeviceDriverSC::getDeviceGroupPeerMemoryFeatures (VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const 1041{ 1042 if (m_normalMode) 1043 m_vk.getDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); 1044} 1045 1046void DeviceDriverSC::cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint32_t deviceMask) const 1047{ 1048 if (m_normalMode) 1049 m_vk.cmdSetDeviceMask(commandBuffer, deviceMask); 1050 else 1051 increaseCommandBufferSize(commandBuffer, 0u); 1052} 1053 1054void DeviceDriverSC::cmdDispatchBase (VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const 1055{ 1056 if (m_normalMode) 1057 m_vk.cmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); 1058 else 1059 increaseCommandBufferSize(commandBuffer, 0u); 1060} 1061 1062void DeviceDriverSC::getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const 1063{ 1064 std::lock_guard<std::mutex> lock(functionMutex); 1065 if (m_normalMode) 1066 m_vk.getImageMemoryRequirements2(device, pInfo, pMemoryRequirements); 1067 else 1068 { 1069 DDSTAT_LOCK(); 1070 pMemoryRequirements->memoryRequirements.size = 1048576U; 1071 pMemoryRequirements->memoryRequirements.alignment = 1U; 1072 pMemoryRequirements->memoryRequirements.memoryTypeBits = ~0U; 1073 } 1074} 1075 1076void DeviceDriverSC::getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const 1077{ 1078 std::lock_guard<std::mutex> lock(functionMutex); 1079 if (m_normalMode) 1080 m_vk.getBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); 1081 else 1082 { 1083 DDSTAT_LOCK(); 1084 pMemoryRequirements->memoryRequirements.size = 1048576U; 1085 pMemoryRequirements->memoryRequirements.alignment = 1U; 1086 pMemoryRequirements->memoryRequirements.memoryTypeBits = ~0U; 1087 } 1088} 1089 1090void DeviceDriverSC::getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const 1091{ 1092 if (m_normalMode) 1093 m_vk.getDeviceQueue2(device, pQueueInfo, pQueue); 1094} 1095 1096VkResult DeviceDriverSC::createSamplerYcbcrConversion (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const 1097{ 1098 std::lock_guard<std::mutex> lock(functionMutex); 1099 if (m_normalMode) 1100 return createSamplerYcbcrConversionHandlerNorm(device, pCreateInfo, pAllocator, pYcbcrConversion); 1101 else 1102 createSamplerYcbcrConversionHandlerStat(device, pCreateInfo, pAllocator, pYcbcrConversion); 1103 return VK_SUCCESS; 1104} 1105 1106void DeviceDriverSC::destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const 1107{ 1108 std::lock_guard<std::mutex> lock(functionMutex); 1109 if (m_normalMode) 1110 m_vk.destroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); 1111 else 1112 { 1113 DDSTAT_LOCK(); 1114 DDSTAT_HANDLE_DESTROY_IF(ycbcrConversion,samplerYcbcrConversionRequestCount,1); 1115 } 1116} 1117 1118void DeviceDriverSC::getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const 1119{ 1120 std::lock_guard<std::mutex> lock(functionMutex); 1121 if (m_normalMode) 1122 m_vk.getDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); 1123 else 1124 getDescriptorSetLayoutSupportHandler(device, pCreateInfo, pSupport); 1125} 1126 1127void DeviceDriverSC::cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const 1128{ 1129 if (m_normalMode) 1130 m_vk.cmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); 1131 else 1132 increaseCommandBufferSize(commandBuffer, 0u); 1133} 1134 1135void DeviceDriverSC::cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const 1136{ 1137 if (m_normalMode) 1138 m_vk.cmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); 1139 else 1140 increaseCommandBufferSize(commandBuffer, 0u); 1141} 1142 1143VkResult DeviceDriverSC::createRenderPass2 (VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const 1144{ 1145 std::lock_guard<std::mutex> lock(functionMutex); 1146 if (m_normalMode) 1147 return createRenderPass2HandlerNorm(device, pCreateInfo, pAllocator, pRenderPass); 1148 else 1149 createRenderPass2HandlerStat(device, pCreateInfo, pAllocator, pRenderPass); 1150 return VK_SUCCESS; 1151} 1152 1153void DeviceDriverSC::cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) const 1154{ 1155 if (m_normalMode) 1156 m_vk.cmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); 1157 else 1158 increaseCommandBufferSize(commandBuffer, 0u); 1159} 1160 1161void DeviceDriverSC::cmdNextSubpass2 (VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) const 1162{ 1163 if (m_normalMode) 1164 m_vk.cmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); 1165 else 1166 increaseCommandBufferSize(commandBuffer, 0u); 1167} 1168 1169void DeviceDriverSC::cmdEndRenderPass2 (VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) const 1170{ 1171 if (m_normalMode) 1172 m_vk.cmdEndRenderPass2(commandBuffer, pSubpassEndInfo); 1173 else 1174 increaseCommandBufferSize(commandBuffer, 0u); 1175} 1176 1177void DeviceDriverSC::resetQueryPool (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const 1178{ 1179 if (m_normalMode) 1180 m_vk.resetQueryPool(device, queryPool, firstQuery, queryCount); 1181} 1182 1183VkResult DeviceDriverSC::getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, uint64_t* pValue) const 1184{ 1185 if (m_normalMode) 1186 return m_vk.getSemaphoreCounterValue(device, semaphore, pValue); 1187 return VK_SUCCESS; 1188} 1189 1190VkResult DeviceDriverSC::waitSemaphores (VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) const 1191{ 1192 if (m_normalMode) 1193 return m_vk.waitSemaphores(device, pWaitInfo, timeout); 1194 return VK_SUCCESS; 1195} 1196 1197VkResult DeviceDriverSC::signalSemaphore (VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) const 1198{ 1199 if (m_normalMode) 1200 return m_vk.signalSemaphore(device, pSignalInfo); 1201 return VK_SUCCESS; 1202} 1203 1204VkDeviceAddress DeviceDriverSC::getBufferDeviceAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const 1205{ 1206 if (m_normalMode) 1207 return m_vk.getBufferDeviceAddress(device, pInfo); 1208 return 0u; 1209} 1210 1211uint64_t DeviceDriverSC::getBufferOpaqueCaptureAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo) const 1212{ 1213 if (m_normalMode) 1214 return m_vk.getBufferOpaqueCaptureAddress(device, pInfo); 1215 return 0u; 1216} 1217 1218uint64_t DeviceDriverSC::getDeviceMemoryOpaqueCaptureAddress (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) const 1219{ 1220 if (m_normalMode) 1221 return m_vk.getDeviceMemoryOpaqueCaptureAddress(device, pInfo); 1222 return 0u; 1223} 1224 1225void DeviceDriverSC::getCommandPoolMemoryConsumption (VkDevice device, VkCommandPool commandPool, VkCommandBuffer commandBuffer, VkCommandPoolMemoryConsumption* pConsumption) const 1226{ 1227 if (m_normalMode) 1228 m_vk.getCommandPoolMemoryConsumption(device, commandPool, commandBuffer, pConsumption); 1229} 1230 1231VkResult DeviceDriverSC::getFaultData (VkDevice device, VkFaultQueryBehavior faultQueryBehavior, VkBool32* pUnrecordedFaults, uint32_t* pFaultCount, VkFaultData* pFaults) const 1232{ 1233 if (m_normalMode) 1234 return m_vk.getFaultData(device, faultQueryBehavior, pUnrecordedFaults, pFaultCount, pFaults); 1235 return VK_SUCCESS; 1236} 1237 1238VkResult DeviceDriverSC::createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) const 1239{ 1240 if (m_normalMode) 1241 return m_vk.createSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 1242 return VK_SUCCESS; 1243} 1244 1245VkResult DeviceDriverSC::getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) const 1246{ 1247 if (m_normalMode) 1248 return m_vk.getSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 1249 return VK_SUCCESS; 1250} 1251 1252VkResult DeviceDriverSC::acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) const 1253{ 1254 if (m_normalMode) 1255 return m_vk.acquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 1256 return VK_SUCCESS; 1257} 1258 1259VkResult DeviceDriverSC::queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const 1260{ 1261 if (m_normalMode) 1262 return m_vk.queuePresentKHR(queue, pPresentInfo); 1263 return VK_SUCCESS; 1264} 1265 1266VkResult DeviceDriverSC::getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const 1267{ 1268 if (m_normalMode) 1269 return m_vk.getDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); 1270 return VK_SUCCESS; 1271} 1272 1273VkResult DeviceDriverSC::getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) const 1274{ 1275 if (m_normalMode) 1276 return m_vk.getDeviceGroupSurfacePresentModesKHR(device, surface, pModes); 1277 return VK_SUCCESS; 1278} 1279 1280VkResult DeviceDriverSC::acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) const 1281{ 1282 if (m_normalMode) 1283 return m_vk.acquireNextImage2KHR(device, pAcquireInfo, pImageIndex); 1284 return VK_SUCCESS; 1285} 1286 1287VkResult DeviceDriverSC::createSharedSwapchainsKHR (VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const 1288{ 1289 if (m_normalMode) 1290 return m_vk.createSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); 1291 return VK_SUCCESS; 1292} 1293 1294VkResult DeviceDriverSC::getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const 1295{ 1296 if (m_normalMode) 1297 return m_vk.getMemoryFdKHR(device, pGetFdInfo, pFd); 1298 return VK_SUCCESS; 1299} 1300 1301VkResult DeviceDriverSC::getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) const 1302{ 1303 if (m_normalMode) 1304 return m_vk.getMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); 1305 return VK_SUCCESS; 1306} 1307 1308VkResult DeviceDriverSC::importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const 1309{ 1310 if (m_normalMode) 1311 return m_vk.importSemaphoreFdKHR(device, pImportSemaphoreFdInfo); 1312 return VK_SUCCESS; 1313} 1314 1315VkResult DeviceDriverSC::getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const 1316{ 1317 if (m_normalMode) 1318 return m_vk.getSemaphoreFdKHR(device, pGetFdInfo, pFd); 1319 return VK_SUCCESS; 1320} 1321 1322VkResult DeviceDriverSC::getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const 1323{ 1324 if (m_normalMode) 1325 return m_vk.getSwapchainStatusKHR(device, swapchain); 1326 return VK_SUCCESS; 1327} 1328 1329VkResult DeviceDriverSC::importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const 1330{ 1331 if (m_normalMode) 1332 return m_vk.importFenceFdKHR(device, pImportFenceFdInfo); 1333 return VK_SUCCESS; 1334} 1335 1336VkResult DeviceDriverSC::getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const 1337{ 1338 if (m_normalMode) 1339 return m_vk.getFenceFdKHR(device, pGetFdInfo, pFd); 1340 return VK_SUCCESS; 1341} 1342 1343VkResult DeviceDriverSC::acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) const 1344{ 1345 if (m_normalMode) 1346 return m_vk.acquireProfilingLockKHR(device, pInfo); 1347 return VK_SUCCESS; 1348} 1349 1350void DeviceDriverSC::releaseProfilingLockKHR (VkDevice device) const 1351{ 1352 if (m_normalMode) 1353 m_vk.releaseProfilingLockKHR(device); 1354} 1355 1356void DeviceDriverSC::cmdSetFragmentShadingRateKHR (VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const 1357{ 1358 if (m_normalMode) 1359 m_vk.cmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); 1360 else 1361 increaseCommandBufferSize(commandBuffer, 0u); 1362} 1363 1364void DeviceDriverSC::cmdRefreshObjectsKHR (VkCommandBuffer commandBuffer, const VkRefreshObjectListKHR* pRefreshObjects) const 1365{ 1366 if (m_normalMode) 1367 m_vk.cmdRefreshObjectsKHR(commandBuffer, pRefreshObjects); 1368 else 1369 increaseCommandBufferSize(commandBuffer, 0u); 1370} 1371 1372void DeviceDriverSC::cmdSetEvent2KHR (VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) const 1373{ 1374 if (m_normalMode) 1375 m_vk.cmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); 1376 else 1377 increaseCommandBufferSize(commandBuffer, 0u); 1378} 1379 1380void DeviceDriverSC::cmdResetEvent2KHR (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask) const 1381{ 1382 if (m_normalMode) 1383 m_vk.cmdResetEvent2KHR(commandBuffer, event, stageMask); 1384 else 1385 increaseCommandBufferSize(commandBuffer, 0u); 1386} 1387 1388void DeviceDriverSC::cmdWaitEvents2KHR (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos) const 1389{ 1390 if (m_normalMode) 1391 m_vk.cmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); 1392 else 1393 increaseCommandBufferSize(commandBuffer, 0u); 1394} 1395 1396void DeviceDriverSC::cmdPipelineBarrier2KHR (VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) const 1397{ 1398 if (m_normalMode) 1399 m_vk.cmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); 1400 else 1401 increaseCommandBufferSize(commandBuffer, 0u); 1402} 1403 1404void DeviceDriverSC::cmdWriteTimestamp2KHR (VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query) const 1405{ 1406 if (m_normalMode) 1407 m_vk.cmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); 1408 else 1409 increaseCommandBufferSize(commandBuffer, 0u); 1410} 1411 1412VkResult DeviceDriverSC::queueSubmit2KHR (VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) const 1413{ 1414 if (m_normalMode) 1415 return m_vk.queueSubmit2KHR(queue, submitCount, pSubmits, fence); 1416 return VK_SUCCESS; 1417} 1418 1419void DeviceDriverSC::cmdWriteBufferMarker2AMD (VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const 1420{ 1421 if (m_normalMode) 1422 m_vk.cmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); 1423 else 1424 increaseCommandBufferSize(commandBuffer, 0u); 1425} 1426 1427void DeviceDriverSC::getQueueCheckpointData2NV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) const 1428{ 1429 if (m_normalMode) 1430 m_vk.getQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); 1431} 1432 1433void DeviceDriverSC::cmdCopyBuffer2KHR (VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo) const 1434{ 1435 if (m_normalMode) 1436 m_vk.cmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); 1437 else 1438 increaseCommandBufferSize(commandBuffer, 0u); 1439} 1440 1441void DeviceDriverSC::cmdCopyImage2KHR (VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo) const 1442{ 1443 if (m_normalMode) 1444 m_vk.cmdCopyImage2KHR(commandBuffer, pCopyImageInfo); 1445 else 1446 increaseCommandBufferSize(commandBuffer, 0u); 1447} 1448 1449void DeviceDriverSC::cmdCopyBufferToImage2KHR (VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) const 1450{ 1451 if (m_normalMode) 1452 m_vk.cmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); 1453 else 1454 increaseCommandBufferSize(commandBuffer, 0u); 1455} 1456 1457void DeviceDriverSC::cmdCopyImageToBuffer2KHR (VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) const 1458{ 1459 if (m_normalMode) 1460 m_vk.cmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); 1461 else 1462 increaseCommandBufferSize(commandBuffer, 0u); 1463} 1464 1465void DeviceDriverSC::cmdBlitImage2KHR (VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo) const 1466{ 1467 if (m_normalMode) 1468 m_vk.cmdBlitImage2KHR(commandBuffer, pBlitImageInfo); 1469 else 1470 increaseCommandBufferSize(commandBuffer, 0u); 1471} 1472 1473void DeviceDriverSC::cmdResolveImage2KHR (VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo) const 1474{ 1475 if (m_normalMode) 1476 m_vk.cmdResolveImage2KHR(commandBuffer, pResolveImageInfo); 1477 else 1478 increaseCommandBufferSize(commandBuffer, 0u); 1479} 1480 1481VkResult DeviceDriverSC::displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const 1482{ 1483 if (m_normalMode) 1484 return m_vk.displayPowerControlEXT(device, display, pDisplayPowerInfo); 1485 return VK_SUCCESS; 1486} 1487 1488VkResult DeviceDriverSC::registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const 1489{ 1490 if (m_normalMode) 1491 return m_vk.registerDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); 1492 return VK_SUCCESS; 1493} 1494 1495VkResult DeviceDriverSC::registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const 1496{ 1497 if (m_normalMode) 1498 return m_vk.registerDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); 1499 return VK_SUCCESS; 1500} 1501 1502VkResult DeviceDriverSC::getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) const 1503{ 1504 if (m_normalMode) 1505 return m_vk.getSwapchainCounterEXT(device, swapchain, counter, pCounterValue); 1506 return VK_SUCCESS; 1507} 1508 1509void DeviceDriverSC::cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) const 1510{ 1511 if (m_normalMode) 1512 m_vk.cmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); 1513 else 1514 increaseCommandBufferSize(commandBuffer, 0u); 1515} 1516 1517void DeviceDriverSC::setHdrMetadataEXT (VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) const 1518{ 1519 if (m_normalMode) 1520 m_vk.setHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); 1521} 1522 1523VkResult DeviceDriverSC::setDebugUtilsObjectNameEXT (VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) const 1524{ 1525 if (m_normalMode) 1526 return m_vk.setDebugUtilsObjectNameEXT(device, pNameInfo); 1527 return VK_SUCCESS; 1528} 1529 1530VkResult DeviceDriverSC::setDebugUtilsObjectTagEXT (VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) const 1531{ 1532 if (m_normalMode) 1533 return m_vk.setDebugUtilsObjectTagEXT(device, pTagInfo); 1534 return VK_SUCCESS; 1535} 1536 1537void DeviceDriverSC::queueBeginDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const 1538{ 1539 if (m_normalMode) 1540 m_vk.queueBeginDebugUtilsLabelEXT(queue, pLabelInfo); 1541} 1542 1543void DeviceDriverSC::queueEndDebugUtilsLabelEXT (VkQueue queue) const 1544{ 1545 if (m_normalMode) 1546 m_vk.queueEndDebugUtilsLabelEXT(queue); 1547} 1548 1549void DeviceDriverSC::queueInsertDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const 1550{ 1551 if (m_normalMode) 1552 m_vk.queueInsertDebugUtilsLabelEXT(queue, pLabelInfo); 1553} 1554 1555void DeviceDriverSC::cmdBeginDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const 1556{ 1557 if (m_normalMode) 1558 m_vk.cmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); 1559 else 1560 increaseCommandBufferSize(commandBuffer, 0u); 1561} 1562 1563void DeviceDriverSC::cmdEndDebugUtilsLabelEXT (VkCommandBuffer commandBuffer) const 1564{ 1565 if (m_normalMode) 1566 m_vk.cmdEndDebugUtilsLabelEXT(commandBuffer); 1567 else 1568 increaseCommandBufferSize(commandBuffer, 0u); 1569} 1570 1571void DeviceDriverSC::cmdInsertDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const 1572{ 1573 if (m_normalMode) 1574 m_vk.cmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); 1575 else 1576 increaseCommandBufferSize(commandBuffer, 0u); 1577} 1578 1579void DeviceDriverSC::cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const 1580{ 1581 if (m_normalMode) 1582 m_vk.cmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); 1583 else 1584 increaseCommandBufferSize(commandBuffer, 0u); 1585} 1586 1587VkResult DeviceDriverSC::getImageDrmFormatModifierPropertiesEXT (VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) const 1588{ 1589 if (m_normalMode) 1590 return m_vk.getImageDrmFormatModifierPropertiesEXT(device, image, pProperties); 1591 return VK_SUCCESS; 1592} 1593 1594VkResult DeviceDriverSC::getMemoryHostPointerPropertiesEXT (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const 1595{ 1596 if (m_normalMode) 1597 return m_vk.getMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); 1598 return VK_SUCCESS; 1599} 1600 1601VkResult DeviceDriverSC::getCalibratedTimestampsEXT (VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const 1602{ 1603 if (m_normalMode) 1604 return m_vk.getCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); 1605 return VK_SUCCESS; 1606} 1607 1608void DeviceDriverSC::cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const 1609{ 1610 if (m_normalMode) 1611 m_vk.cmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); 1612 else 1613 increaseCommandBufferSize(commandBuffer, 0u); 1614} 1615 1616void DeviceDriverSC::cmdSetCullModeEXT (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const 1617{ 1618 if (m_normalMode) 1619 m_vk.cmdSetCullModeEXT(commandBuffer, cullMode); 1620 else 1621 increaseCommandBufferSize(commandBuffer, 0u); 1622} 1623 1624void DeviceDriverSC::cmdSetFrontFaceEXT (VkCommandBuffer commandBuffer, VkFrontFace frontFace) const 1625{ 1626 if (m_normalMode) 1627 m_vk.cmdSetFrontFaceEXT(commandBuffer, frontFace); 1628 else 1629 increaseCommandBufferSize(commandBuffer, 0u); 1630} 1631 1632void DeviceDriverSC::cmdSetPrimitiveTopologyEXT (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const 1633{ 1634 if (m_normalMode) 1635 m_vk.cmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); 1636 else 1637 increaseCommandBufferSize(commandBuffer, 0u); 1638} 1639 1640void DeviceDriverSC::cmdSetViewportWithCountEXT (VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const 1641{ 1642 if (m_normalMode) 1643 m_vk.cmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); 1644 else 1645 increaseCommandBufferSize(commandBuffer, 0u); 1646} 1647 1648void DeviceDriverSC::cmdSetScissorWithCountEXT (VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const 1649{ 1650 if (m_normalMode) 1651 m_vk.cmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); 1652 else 1653 increaseCommandBufferSize(commandBuffer, 0u); 1654} 1655 1656void DeviceDriverSC::cmdBindVertexBuffers2EXT (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const 1657{ 1658 if (m_normalMode) 1659 m_vk.cmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); 1660 else 1661 increaseCommandBufferSize(commandBuffer, 0u); 1662} 1663 1664void DeviceDriverSC::cmdSetDepthTestEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const 1665{ 1666 if (m_normalMode) 1667 m_vk.cmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); 1668 else 1669 increaseCommandBufferSize(commandBuffer, 0u); 1670} 1671 1672void DeviceDriverSC::cmdSetDepthWriteEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const 1673{ 1674 if (m_normalMode) 1675 m_vk.cmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); 1676 else 1677 increaseCommandBufferSize(commandBuffer, 0u); 1678} 1679 1680void DeviceDriverSC::cmdSetDepthCompareOpEXT (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const 1681{ 1682 if (m_normalMode) 1683 m_vk.cmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); 1684 else 1685 increaseCommandBufferSize(commandBuffer, 0u); 1686} 1687 1688void DeviceDriverSC::cmdSetDepthBoundsTestEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const 1689{ 1690 if (m_normalMode) 1691 m_vk.cmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); 1692 else 1693 increaseCommandBufferSize(commandBuffer, 0u); 1694} 1695 1696void DeviceDriverSC::cmdSetStencilTestEnableEXT (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const 1697{ 1698 if (m_normalMode) 1699 m_vk.cmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); 1700 else 1701 increaseCommandBufferSize(commandBuffer, 0u); 1702} 1703 1704void DeviceDriverSC::cmdSetStencilOpEXT (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const 1705{ 1706 if (m_normalMode) 1707 m_vk.cmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); 1708 else 1709 increaseCommandBufferSize(commandBuffer, 0u); 1710} 1711 1712void DeviceDriverSC::cmdSetVertexInputEXT (VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) const 1713{ 1714 if (m_normalMode) 1715 m_vk.cmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); 1716 else 1717 increaseCommandBufferSize(commandBuffer, 0u); 1718} 1719 1720void DeviceDriverSC::cmdSetPatchControlPointsEXT (VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const 1721{ 1722 if (m_normalMode) 1723 m_vk.cmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); 1724 else 1725 increaseCommandBufferSize(commandBuffer, 0u); 1726} 1727 1728void DeviceDriverSC::cmdSetRasterizerDiscardEnableEXT (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const 1729{ 1730 if (m_normalMode) 1731 m_vk.cmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); 1732 else 1733 increaseCommandBufferSize(commandBuffer, 0u); 1734} 1735 1736void DeviceDriverSC::cmdSetDepthBiasEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const 1737{ 1738 if (m_normalMode) 1739 m_vk.cmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); 1740 else 1741 increaseCommandBufferSize(commandBuffer, 0u); 1742} 1743 1744void DeviceDriverSC::cmdSetLogicOpEXT (VkCommandBuffer commandBuffer, VkLogicOp logicOp) const 1745{ 1746 if (m_normalMode) 1747 m_vk.cmdSetLogicOpEXT(commandBuffer, logicOp); 1748 else 1749 increaseCommandBufferSize(commandBuffer, 0u); 1750} 1751 1752void DeviceDriverSC::cmdSetPrimitiveRestartEnableEXT (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const 1753{ 1754 if (m_normalMode) 1755 m_vk.cmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); 1756 else 1757 increaseCommandBufferSize(commandBuffer, 0u); 1758} 1759 1760void DeviceDriverSC::cmdSetColorWriteEnableEXT (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) const 1761{ 1762 if (m_normalMode) 1763 m_vk.cmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); 1764 else 1765 increaseCommandBufferSize(commandBuffer, 0u); 1766} 1767