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