VulkanRaytracingCycles 0.0.0
Cycles Render Engine With VulkanRaytracingShaderModules. ( Experiment , in progress)
Classes | Public Member Functions | Public Attributes | List of all members
DeviceMasterVk< Q > Struct Template Reference

#include <Context1Vk.h>

Classes

struct  _ShaderProp
 

Public Member Functions

void configuration ()
 
bool setupPhysicalDevice (VkInstance _instance)
 
VkResult createLogicalDevice (VkApplicationInfo &app, bool useSwapChain=true, VkQueueFlags requestedQueueTypes=VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT)
 
VkResult createCommandPool (VkCommandPoolCreateFlags createFlags=VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
 
void destroyLogicalDevice ()
 
void destroyCommandPool ()
 
bool shutdown ()
 
bool extensionSupported (std::string extension)
 
std::vector< VkExtensionProperties > getDeviceExtensions ()
 
uint32_t getQueueFamilyIndex (VkQueueFlagBits queueFlags)
 

Public Attributes

VkInstance instance
 
VulkanFeatures vulkanFeatures
 
VkPhysicalDevice physical
 
VkDevice logical
 
Q Qvillage
 
struct DeviceMasterVk::_ShaderProp ShaderProp
 
VkPhysicalDeviceMemoryProperties memoryProperties
 
VkPhysicalDeviceProperties properties
 
VkPhysicalDeviceFeatures features
 
VkPhysicalDeviceFeatures enabledFeatures {}
 
std::vector< ExtensionEntry > requireDeviceExtensions
 
std::vector< const char * > enabledDeviceExtensions
 
std::vector< std::string > supportedExtensions
 
_Vkformat format
 
std::vector< VkQueueFamilyProperties > queueFamilyProperties
 
queueFamilyIndices queueFamilyIndices
 
VkCommandPool commandPool = VK_NULL_HANDLE
 
bool enableDebugMarkers
 

Detailed Description

template<class Q>
struct DeviceMasterVk< Q >

Definition at line 246 of file Context1Vk.h.

Member Function Documentation

◆ configuration()

template<class Q >
void DeviceMasterVk< Q >::configuration ( )
inline

TODO disappier Nv version

requireDeviceExtensions.emplace_back(VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME,false, &bufaddrFeatures);

Definition at line 282 of file Context1Vk.h.

282 {
283
284#ifdef ENABLED_VULKAN_OVR
285 uint64_t pHMDPhysicalDevice = 0;
286 GetVulkanDeviceExtensionsRequired(physical, requireDeviceExtensions);
287 vr::VRSystem()->GetOutputDevice(&pHMDPhysicalDevice, vr::TextureType_Vulkan, (VkInstance_T*)instance);
288 log_ctx("OVR physical device %u ", pHMDPhysicalDevice);
289#endif
290
291#ifndef ENABLED_VULKAN_HEADLESS
292 requireDeviceExtensions.emplace_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
293
294#endif
295
296#ifdef ENABLED_VULKAN_DEBUG
297
298 if (extensionSupported(VK_EXT_DEBUG_MARKER_EXTENSION_NAME))
299 {
300 requireDeviceExtensions.emplace_back(VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
301 enableDebugMarkers = true;
302 };
303
304#endif
305
306
307#ifdef ENABLED_VULKAN_OPENCL
308
309
310 static VkPhysicalDevice8BitStorageFeaturesKHR PD8bitstorage = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR };
311 PD8bitstorage.storageBuffer8BitAccess = VK_TRUE;
312 PD8bitstorage.storagePushConstant8 = VK_TRUE;
313 PD8bitstorage.uniformAndStorageBuffer8BitAccess = VK_TRUE;
314 requireDeviceExtensions.emplace_back(VK_KHR_8BIT_STORAGE_EXTENSION_NAME, false, &PD8bitstorage);
315 requireDeviceExtensions.emplace_back(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME);
316
317
318#endif
319
320
321
322
323
324 static VkPhysicalDeviceDescriptorIndexingFeaturesEXT physicalDeviceDescriptorIndexingFeatures = { };
325 physicalDeviceDescriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;
326 physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing = VK_TRUE;
327 physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray = VK_TRUE;
328 physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount = VK_TRUE;
329 physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing = VK_TRUE;
330 requireDeviceExtensions.emplace_back(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME,false, &physicalDeviceDescriptorIndexingFeatures);
331 requireDeviceExtensions.emplace_back(VK_KHR_MAINTENANCE3_EXTENSION_NAME);
332 requireDeviceExtensions.emplace_back(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME);
333
334 requireDeviceExtensions.emplace_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
335 requireDeviceExtensions.emplace_back(VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME);
336 requireDeviceExtensions.emplace_back(VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME);
337 requireDeviceExtensions.emplace_back(VK_KHR_SHADER_CLOCK_EXTENSION_NAME);
338
339
340
341
342 requireDeviceExtensions.emplace_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
343
344 static VkPhysicalDeviceTimelineSemaphoreFeatures timelineFeature = {};
345 timelineFeature.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
346 timelineFeature.timelineSemaphore = VK_TRUE;
347 requireDeviceExtensions.emplace_back(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,false,&timelineFeature);
348
349
350 static VkPhysicalDeviceScalarBlockLayoutFeaturesEXT scalarFeature = {};
351 scalarFeature.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT;
352 scalarFeature.scalarBlockLayout = VK_TRUE;
353 requireDeviceExtensions.emplace_back(VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, false, &scalarFeature);
354 requireDeviceExtensions.emplace_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
355 static VkPhysicalDeviceFloat16Int8FeaturesKHR float16int8Features = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR };
356 float16int8Features.shaderFloat16 = VK_TRUE;
357 float16int8Features.shaderInt8 = VK_TRUE;
358 requireDeviceExtensions.emplace_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME,false,&float16int8Features);
359
360
361 requireDeviceExtensions.emplace_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
363 /*
364 *
365 static VkPhysicalDeviceMeshShaderFeaturesNV meshFeatures = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV };
366 requireDeviceExtensions.emplace_back(VK_NV_MESH_SHADER_EXTENSION_NAME,false,&meshFeatures);
367 */
368
369
370
371 requireDeviceExtensions.emplace_back(VK_NV_RAY_TRACING_EXTENSION_NAME);
372 //requireDeviceExtensions.emplace_back(VK_KHR_RAY_TRACING_EXTENSION_NAME);
373
374#ifdef VK_ENABLE_DebugPrint
375 requireDeviceExtensions.emplace_back(VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME);
376#endif
377
378
379 static VkPhysicalDeviceBufferDeviceAddressFeatures bufaddrFeatures = {
380VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
381 };
382
383 bufaddrFeatures.bufferDeviceAddress = VK_TRUE;
384 bufaddrFeatures.bufferDeviceAddressCaptureReplay = VK_TRUE;
386 requireDeviceExtensions.emplace_back(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, false, &bufaddrFeatures);
387
388
389
390 for (auto& v : requireDeviceExtensions) {
391 log_ctx(">>>>>>>>>>>>>>>>>>>>>>>>>> require a device extension [ %s ] \n", v.name);
392 }
393
394 }
GetVulkanDeviceExtensionsRequired
bool GetVulkanDeviceExtensionsRequired(VkPhysicalDevice pPhysicalDevice, std::vector< T > &outDeviceExtensionList)
log_ctx
#define log_ctx(...)
Definition: Context1Vk.h:37
DeviceMasterVk::instance
VkInstance instance
Definition: Context1Vk.h:249
DeviceMasterVk::physical
VkPhysicalDevice physical
Definition: Context1Vk.h:252
DeviceMasterVk::extensionSupported
bool extensionSupported(std::string extension)
Definition: Context1Vk.h:694
DeviceMasterVk::requireDeviceExtensions
std::vector< ExtensionEntry > requireDeviceExtensions
Definition: Context1Vk.h:266
DeviceMasterVk::enableDebugMarkers
bool enableDebugMarkers
Definition: Context1Vk.h:280

◆ createCommandPool()

template<class Q >
VkResult DeviceMasterVk< Q >::createCommandPool ( VkCommandPoolCreateFlags  createFlags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)
inline

Definition at line 657 of file Context1Vk.h.

658 {
659 VkCommandPoolCreateInfo cmdPoolInfo = {};
660 cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
661 cmdPoolInfo.queueFamilyIndex = queueFamilyIndices.stcg;
662 cmdPoolInfo.flags = createFlags;
663
664 return vkCreateCommandPool(logical, &cmdPoolInfo, nullptr, &commandPool);
665 }
DeviceMasterVk::logical
VkDevice logical
Definition: Context1Vk.h:253
DeviceMasterVk::commandPool
VkCommandPool commandPool
Definition: Context1Vk.h:278

◆ createLogicalDevice()

template<class Q >
VkResult DeviceMasterVk< Q >::createLogicalDevice ( VkApplicationInfo &  app,
bool  useSwapChain = true,
VkQueueFlags  requestedQueueTypes = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT 
)
inline

Definition at line 545 of file Context1Vk.h.

546 {
547 configuration();
548
549 bool enableMeshShader = true;
550 std::vector<void*> featureStructs;
551 if (requireDeviceExtensions.size() > 0)
552 {
553 auto extensionProperties = getDeviceExtensions();
554 if (fillFilteredNameArray(enabledDeviceExtensions, extensionProperties, requireDeviceExtensions, featureStructs) != VK_SUCCESS)
555 {
556 return VK_ERROR_VALIDATION_FAILED_EXT;
557 }
558 }
559
560
561 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
562 Qvillage.createInfo(queueCreateInfos, queueFamilyProperties);
563
564 VkDeviceCreateInfo deviceCreateInfo = {};
565 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
566 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());;
567 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
568 deviceCreateInfo.pEnabledFeatures = &enabledFeatures;
569 deviceCreateInfo.enabledExtensionCount = 0;
570
571 if (enabledDeviceExtensions.size() > 0)
572 {
573 deviceCreateInfo.enabledExtensionCount = enabledDeviceExtensions.size();
574 deviceCreateInfo.ppEnabledExtensionNames = enabledDeviceExtensions.data();
575 }
576
577 VkResult result;
578
579 if (enableMeshShader) {
580
581 deviceCreateInfo.pEnabledFeatures = nullptr;
582 VkPhysicalDeviceFeatures2 features2_;
583 VkPhysicalDeviceProperties2 properties2{};
584 vulkanFeatures.getFeatures(physical, features2_, properties2);
585
586 VkPhysicalDeviceFeatures2 features2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 };
587
588 features2.features = vulkanFeatures.features10;
589 static VulkanFeatures::Features11Old features11old;
590 features11old.read(vulkanFeatures.features11);
591 features2.pNext = &features11old.multiview;
592
593
594
595
596 struct ExtensionHeader // Helper struct to link extensions together
597 {
598 VkStructureType sType;
599 void* pNext;
600 };
601
602 ExtensionHeader* lastCoreFeature = nullptr;
603 if (!featureStructs.empty())
604 {
605 // build up chain of all used extension features
606 for (size_t i = 0; i < featureStructs.size(); i++)
607 {
608 auto* header = reinterpret_cast<ExtensionHeader*>(featureStructs[i]);
609 header->pNext = i < featureStructs.size() - 1 ? featureStructs[i + 1] : nullptr;
610 }
611
612 // append to the end of current feature2 struct
613 lastCoreFeature = (ExtensionHeader*)&features2;
614 while (lastCoreFeature->pNext != nullptr)
615 {
616 lastCoreFeature = (ExtensionHeader*)lastCoreFeature->pNext;
617 }
618 lastCoreFeature->pNext = featureStructs[0];
619
620 // query support
621
622 }
623
624
625
626 //vkGetPhysicalDeviceFeatures2(physical, &features2);
627
628 features2.features.wideLines = VK_TRUE;
629 features2.features.geometryShader = VK_TRUE;
630 features2.features.vertexPipelineStoresAndAtomics = VK_TRUE;
631 features2.features.robustBufferAccess = VK_FALSE;
632
633 deviceCreateInfo.pNext = &features2;
634
635 result = vkCreateDevice(physical, &deviceCreateInfo, nullptr, &logical);
636
637 //VkPhysicalDeviceBufferDeviceAddressFeatures* bdaFeatures = (VkPhysicalDeviceBufferDeviceAddressFeatures*)requireDeviceExtensions[18].pFeatureStruct;
638 //auto tf = bdaFeatures->bufferDeviceAddress;
639
640 }else {
641
642 result = vkCreateDevice(physical, &deviceCreateInfo, nullptr, &logical);
643
644 };
645
646 log_ctx(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Create Device %x <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n", logical);
647
648
649 Qvillage.getQ(logical);
650
651 this->enabledFeatures = enabledFeatures;
652
653 return result;
654
655 };
fillFilteredNameArray
VkResult fillFilteredNameArray(std::vector< const char * > &used, const std::vector< VkExtensionProperties > &properties, const std::vector< ExtensionEntry > &requested, std::vector< void * > &featureStructs)
Definition: Context1Vk.cpp:21
DeviceMasterVk::configuration
void configuration()
Definition: Context1Vk.h:282
DeviceMasterVk::enabledDeviceExtensions
std::vector< const char * > enabledDeviceExtensions
Definition: Context1Vk.h:267
DeviceMasterVk::vulkanFeatures
VulkanFeatures vulkanFeatures
Definition: Context1Vk.h:250
DeviceMasterVk::getDeviceExtensions
std::vector< VkExtensionProperties > getDeviceExtensions()
Definition: Context1Vk.h:699
DeviceMasterVk::enabledFeatures
VkPhysicalDeviceFeatures enabledFeatures
Definition: Context1Vk.h:264
DeviceMasterVk::queueFamilyProperties
std::vector< VkQueueFamilyProperties > queueFamilyProperties
Definition: Context1Vk.h:274
VulkanFeatures::Features11Old::read
void read(const VkPhysicalDeviceVulkan11Features &features11)
Definition: Context1Vk.h:122
VulkanFeatures::Features11Old::multiview
VkPhysicalDeviceMultiviewFeatures multiview
Definition: Context1Vk.h:104
VulkanFeatures::features10
VkPhysicalDeviceFeatures features10
Definition: Context1Vk.h:92
VulkanFeatures::features11
VkPhysicalDeviceVulkan11Features features11
Definition: Context1Vk.h:93
VulkanFeatures::getFeatures
void getFeatures(VkPhysicalDevice physical, VkPhysicalDeviceFeatures2 &features2, VkPhysicalDeviceProperties2 &properties2)
Definition: Context1Vk.h:193

◆ destroyCommandPool()

template<class Q >
void DeviceMasterVk< Q >::destroyCommandPool ( )
inline

Definition at line 677 of file Context1Vk.h.

677 {
678 if (commandPool)
679 {
680 log_ctx("ShutDown CommandPool \n");
681 vkDestroyCommandPool(logical, commandPool, nullptr);
682 commandPool = VK_NULL_HANDLE;
683 }
684 }

◆ destroyLogicalDevice()

template<class Q >
void DeviceMasterVk< Q >::destroyLogicalDevice ( )
inline

Definition at line 667 of file Context1Vk.h.

667 {
668
669 if (logical)
670 {
671 log_ctx("ShutDown Device \n");
672 vkDestroyDevice(logical, nullptr);
673 logical = VK_NULL_HANDLE;
674 }
675 }

◆ extensionSupported()

template<class Q >
bool DeviceMasterVk< Q >::extensionSupported ( std::string  extension)
inline

Definition at line 694 of file Context1Vk.h.

695 {
696 return (std::find(supportedExtensions.begin(), supportedExtensions.end(), extension) != supportedExtensions.end());
697 };
DeviceMasterVk::supportedExtensions
std::vector< std::string > supportedExtensions
Definition: Context1Vk.h:270

◆ getDeviceExtensions()

template<class Q >
std::vector< VkExtensionProperties > DeviceMasterVk< Q >::getDeviceExtensions ( )
inline

Definition at line 699 of file Context1Vk.h.

700 {
701 uint32_t count;
702 std::vector<VkExtensionProperties> extensionProperties;
703 vkEnumerateDeviceExtensionProperties(physical, nullptr, &count, nullptr);
704 extensionProperties.resize(count);
705 vkEnumerateDeviceExtensionProperties(physical, nullptr, &count, extensionProperties.data());
706 extensionProperties.resize(__min(extensionProperties.size(), size_t(count)));
707 return extensionProperties;
708 };

◆ getQueueFamilyIndex()

template<class Q >
uint32_t DeviceMasterVk< Q >::getQueueFamilyIndex ( VkQueueFlagBits  queueFlags)
inline

Definition at line 712 of file Context1Vk.h.

713 {
714 // Dedicated queue for compute
715 // Try to find a queue family index that supports compute but not graphics
716 if (queueFlags & VK_QUEUE_COMPUTE_BIT)
717 {
718 for (uint32_t i = 0; i < static_cast<uint32_t>(queueFamilyProperties.size()); i++)
719 {
720 if ((queueFamilyProperties[i].queueFlags & queueFlags) && ((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0))
721 {
722 return i;
723 break;
724 }
725 }
726 }
727
728 // Dedicated queue for transfer
729 // Try to find a queue family index that supports transfer but not graphics and compute
730 if (queueFlags & VK_QUEUE_TRANSFER_BIT)
731 {
732 for (uint32_t i = 0; i < static_cast<uint32_t>(queueFamilyProperties.size()); i++)
733 {
734 if ((queueFamilyProperties[i].queueFlags & queueFlags) && ((queueFamilyProperties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) && ((queueFamilyProperties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0))
735 {
736 return i;
737 break;
738 }
739 }
740 }
741
742 // For other queue types or if no separate compute queue is present, return the first one to support the requested flags
743 for (uint32_t i = 0; i < static_cast<uint32_t>(queueFamilyProperties.size()); i++)
744 {
745 if (queueFamilyProperties[i].queueFlags & queueFlags)
746 {
747 return i;
748 break;
749 }
750 }
751
752 throw std::runtime_error("Could not find a matching queue family index");
753 };

◆ setupPhysicalDevice()

template<class Q >
bool DeviceMasterVk< Q >::setupPhysicalDevice ( VkInstance  _instance)
inline

int high =0;

Definition at line 395 of file Context1Vk.h.

396 {
397
398 instance = _instance;
399 VkResult err;
400
401
402 // Physical device
403 uint32_t gpuCount = 0;
404 // Get number of available physical devices
405 VK_CHECK_RESULT(vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr));
406 assert(gpuCount > 0);
407
408
409 // Enumerate devices
410 std::vector<VkPhysicalDevice> devicePhysicals(gpuCount);
411 err = vkEnumeratePhysicalDevices(instance, &gpuCount, devicePhysicals.data());
412 if (err) {
413 log_vkabad(err, "Could not enumerate physical devices \n");
414 return false;
415 }
416
417
418 VkPhysicalDeviceIDPropertiesKHR pyid{};
419 pyid.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
420 VkPhysicalDeviceProperties prop{};
421
422 VkPhysicalDeviceProperties2 prop2{};
423 prop2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
424 prop2.properties = prop;
425
426 uint32_t selectedDevice = static_cast<uint32_t>(std::stoul(GPU_DEVICE_ID));
427
428 for (uint32_t d = 0; d < gpuCount; d++) {
429
430 vkGetPhysicalDeviceProperties2(devicePhysicals[d], &prop2);
431
432 log_ctx("device Name :: %s \n", prop2.properties.deviceName);
433 /*
434 char c[16];
435 for (int i = 0; i < 16; i++) c[i] = char(pyid.deviceUUID[i] + 48);
436 log_ctx("uuid :: %s \n",c);
437 */
438
439 uint32_t low = 0;
441 log_ctx("luid :: VALID %s \n", (pyid.deviceLUIDValid == VK_TRUE) ? "true" : "false");
442 for (int i = 0; i < 4; i++) {
443 uint32_t fl = pyid.deviceLUID[i];
444 fl = fl << (i * 8);
445 low = low | fl;
446 }
447 log_ctx(" lowpart %u \n", low);
448
449 }
450
451 physical = devicePhysicals[selectedDevice];
452 vkGetPhysicalDeviceProperties(physical, &properties);
453
454 VkPhysicalDeviceShaderSMBuiltinsFeaturesNV Vkpdss = {};
455 Vkpdss.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
456 Vkpdss.pNext = NULL;
457
458 VkPhysicalDeviceFeatures fet={};
459 VkPhysicalDeviceFeatures2 fet2={};
460 fet2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
461 fet2.pNext = &Vkpdss;
462 fet2.features = fet;
463 vkGetPhysicalDeviceFeatures2(physical, &fet2);
464
465
466
467 VkPhysicalDeviceShaderSMBuiltinsPropertiesNV Vkpdssp = {};
468 Vkpdssp.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
469 Vkpdssp.pNext = NULL;
470
471 prop2.pNext = &Vkpdssp;
472
473
474 vkGetPhysicalDeviceProperties2(physical, &prop2);
475
476 VkPhysicalDeviceFeatures2 features2_;
477 VkPhysicalDeviceProperties2 properties2{};
478 vulkanFeatures.getFeatures(physical, features2_, properties2);
479
480
481
482
483 ASSERT_PRINT(Vkpdss.shaderSMBuiltins, "Configure failed. shaderSMBuiltins is False.");
484 ASSERT_PRINT(vulkanFeatures.properties11.subgroupSize <= 32, "Configure failed. subgroupSize <= 32.");
485 ASSERT_PRINT(Vkpdssp.shaderSMCount == 40, "Configure failed. shaderSMCount == 40.");
486 ASSERT_PRINT(Vkpdssp.shaderWarpsPerSM >= 32, "Configure failed.shaderWarpsPerSM >= 32.");
487
488
489 ShaderProp = { vulkanFeatures.properties11.subgroupSize ,Vkpdssp.shaderSMCount ,Vkpdssp.shaderWarpsPerSM };
490
491 /*
492 VkPhysicalDeviceSubgroupProperties subgroupProperties = {};
493 subgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
494 subgroupProperties.pNext = NULL;
495
496 VkPhysicalDeviceProperties2 physicalDeviceProperties = {};
497 physicalDeviceProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
498 physicalDeviceProperties.pNext = &subgroupProperties;
499 prop = {};
500 physicalDeviceProperties.properties = prop;
501 */
502
503 vkGetPhysicalDeviceFeatures(physical, &features);
504 vkGetPhysicalDeviceMemoryProperties(physical, &memoryProperties);
505
506 uint32_t extCount = 0;
507 vkEnumerateDeviceExtensionProperties(physical, nullptr, &extCount, nullptr);
508 if (extCount > 0)
509 {
510 std::vector<VkExtensionProperties> extensions(extCount);
511 if (vkEnumerateDeviceExtensionProperties(physical, nullptr, &extCount, &extensions.front()) == VK_SUCCESS)
512 {
513 for (auto ext : extensions)
514 {
515 supportedExtensions.push_back(ext.extensionName);
516 }
517 }
518 }
519
520
521 uint32_t queueFamilyCount;
522 vkGetPhysicalDeviceQueueFamilyProperties(physical, &queueFamilyCount, nullptr);
523 assert(queueFamilyCount > 0);
524 queueFamilyProperties.resize(queueFamilyCount);
525
526 vkGetPhysicalDeviceQueueFamilyProperties(physical, &queueFamilyCount, queueFamilyProperties.data());
527
528
529 int idx = 0;
530 for (auto& q_family : queueFamilyProperties)
531 {
532 if (q_family.queueFlags == 15)queueFamilyIndices.stcg = idx;
533 if (q_family.queueFlags == 14)queueFamilyIndices.stc = idx;
534 if (q_family.queueFlags == 12)queueFamilyIndices.st = idx;
535 log_ctx("Queue number: %d Queue flags: %s \n", q_family.queueCount, std::to_string(q_family.queueFlags).c_str());
536 idx++;
537 }
538
539 VkBool32 validDepthFormat = vka::shelve::getSupportedDepthFormat(physical, &format.DEPTHFORMAT);
540 assert(validDepthFormat);
541 return true;
542
543 };
log_vkabad
#define log_vkabad(...)
Definition: log.hpp:38
ASSERT_PRINT
#define ASSERT_PRINT(condition,...)
Definition: log.hpp:43
_Vkformat::DEPTHFORMAT
VkFormat DEPTHFORMAT
Definition: vthreepy_types.h:90
DeviceMasterVk::ShaderProp
struct DeviceMasterVk::_ShaderProp ShaderProp
DeviceMasterVk::memoryProperties
VkPhysicalDeviceMemoryProperties memoryProperties
Definition: Context1Vk.h:260
DeviceMasterVk::properties
VkPhysicalDeviceProperties properties
Definition: Context1Vk.h:261
DeviceMasterVk::format
_Vkformat format
Definition: Context1Vk.h:272
DeviceMasterVk::features
VkPhysicalDeviceFeatures features
Definition: Context1Vk.h:263
VulkanFeatures::properties11
VkPhysicalDeviceVulkan11Properties properties11
Definition: Context1Vk.h:97

◆ shutdown()

template<class Q >
bool DeviceMasterVk< Q >::shutdown ( )
inline

Definition at line 686 of file Context1Vk.h.

686 {
687
688 destroyCommandPool();
689
690 destroyLogicalDevice();
691 return true;
692 }
DeviceMasterVk::destroyCommandPool
void destroyCommandPool()
Definition: Context1Vk.h:677
DeviceMasterVk::destroyLogicalDevice
void destroyLogicalDevice()
Definition: Context1Vk.h:667

Member Data Documentation

◆ commandPool

template<class Q >
VkCommandPool DeviceMasterVk< Q >::commandPool = VK_NULL_HANDLE

Definition at line 278 of file Context1Vk.h.

◆ enabledDeviceExtensions

template<class Q >
std::vector< const char*> DeviceMasterVk< Q >::enabledDeviceExtensions

Definition at line 267 of file Context1Vk.h.

◆ enableDebugMarkers

template<class Q >
bool DeviceMasterVk< Q >::enableDebugMarkers

Definition at line 280 of file Context1Vk.h.

◆ enabledFeatures

template<class Q >
VkPhysicalDeviceFeatures DeviceMasterVk< Q >::enabledFeatures {}

Definition at line 264 of file Context1Vk.h.

◆ features

template<class Q >
VkPhysicalDeviceFeatures DeviceMasterVk< Q >::features

Definition at line 263 of file Context1Vk.h.

◆ format

template<class Q >
_Vkformat DeviceMasterVk< Q >::format

Definition at line 272 of file Context1Vk.h.

◆ instance

template<class Q >
VkInstance DeviceMasterVk< Q >::instance

Definition at line 249 of file Context1Vk.h.

◆ logical

template<class Q >
VkDevice DeviceMasterVk< Q >::logical

Definition at line 253 of file Context1Vk.h.

◆ memoryProperties

template<class Q >
VkPhysicalDeviceMemoryProperties DeviceMasterVk< Q >::memoryProperties

Definition at line 260 of file Context1Vk.h.

◆ physical

template<class Q >
VkPhysicalDevice DeviceMasterVk< Q >::physical

Definition at line 252 of file Context1Vk.h.

◆ properties

template<class Q >
VkPhysicalDeviceProperties DeviceMasterVk< Q >::properties

Definition at line 261 of file Context1Vk.h.

◆ queueFamilyIndices

template<class Q >
queueFamilyIndices DeviceMasterVk< Q >::queueFamilyIndices

Definition at line 276 of file Context1Vk.h.

◆ queueFamilyProperties

template<class Q >
std::vector<VkQueueFamilyProperties> DeviceMasterVk< Q >::queueFamilyProperties

Definition at line 274 of file Context1Vk.h.

◆ Qvillage

template<class Q >
Q DeviceMasterVk< Q >::Qvillage

Definition at line 255 of file Context1Vk.h.

◆ requireDeviceExtensions

template<class Q >
std::vector<ExtensionEntry> DeviceMasterVk< Q >::requireDeviceExtensions

Definition at line 266 of file Context1Vk.h.

◆ ShaderProp

template<class Q >
struct DeviceMasterVk::_ShaderProp DeviceMasterVk< Q >::ShaderProp

◆ supportedExtensions

template<class Q >
std::vector<std::string> DeviceMasterVk< Q >::supportedExtensions

Definition at line 270 of file Context1Vk.h.

◆ vulkanFeatures

template<class Q >
VulkanFeatures DeviceMasterVk< Q >::vulkanFeatures

Definition at line 250 of file Context1Vk.h.

The documentation for this struct was generated from the following file: