mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-09-20 14:02:17 +00:00
c06a3300f6
new: - InstanceVersion: print out the instance version - PhysicalDeviceExtensions: print out the device specific extensions - PhysicalDeviceFeatures: print out the device specific features - PhysicalDeviceGroups: print out the device groups (interesting with SLI) - PhysicalDeviceMemoryProperties: print out the device specific memory properties - PhysicalDeviceQueueFamilyProperties: print out the device specific queue family properties - SurfaceCapabilities: print out the surface specific capabilities - SurfaceFormats: print out the supported surface specific formats improved: - InstanceExtensionProperties: print out the instance extensions alphabetically - InstanceLayerProperties: removed an unused local function - RayTracing: improved fence usage
670 lines
59 KiB
C++
670 lines
59 KiB
C++
// Copyright(c) 2019, NVIDIA CORPORATION. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
// VulkanHpp Samples : PhysicalDeviceProperties
|
|
// Get properties per physical device.
|
|
|
|
#include "../utils/utils.hpp"
|
|
#include "vulkan/vulkan.hpp"
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <vector>
|
|
|
|
static char const* AppName = "PhysicalDeviceProperties";
|
|
static char const* EngineName = "Vulkan.hpp";
|
|
|
|
std::string decodeAPIVersion(uint32_t apiVersion)
|
|
{
|
|
return std::to_string(VK_VERSION_MAJOR(apiVersion)) + "." + std::to_string(VK_VERSION_MINOR(apiVersion)) + "." + std::to_string(VK_VERSION_PATCH(apiVersion));
|
|
}
|
|
|
|
std::string decodeDriverVersion(uint32_t driverVersion, uint32_t vendorID)
|
|
{
|
|
switch (vendorID)
|
|
{
|
|
case 4318:
|
|
return std::to_string((driverVersion >> 22) & 0x3FF) + "." + std::to_string((driverVersion >> 14) & 0xFF) + "." + std::to_string((driverVersion >> 6) & 0xFF) + "." + std::to_string(driverVersion & 0x3F);
|
|
case 0x8086:
|
|
return std::to_string((driverVersion >> 14) & 0x3FFFF) + "." + std::to_string((driverVersion & 0x3FFF));
|
|
default:
|
|
return decodeAPIVersion(driverVersion);
|
|
}
|
|
}
|
|
|
|
std::string decodeVendorID(uint32_t vendorID)
|
|
{
|
|
// below 0x10000 are the PCI vendor IDs (https://pcisig.com/membership/member-companies)
|
|
if (vendorID < 0x10000)
|
|
{
|
|
switch (vendorID)
|
|
{
|
|
case 0x1022:
|
|
return "Advanced Micro Devices";
|
|
case 0x10DE:
|
|
return "NVidia Corporation";
|
|
case 0x8086:
|
|
return "Intel Corporation";
|
|
default:
|
|
return std::to_string(vendorID);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// above 0x10000 should be vkVendorIDs
|
|
return vk::to_string(vk::VendorId(vendorID));
|
|
}
|
|
}
|
|
|
|
namespace vk
|
|
{
|
|
namespace su
|
|
{
|
|
struct LUID
|
|
{
|
|
public:
|
|
LUID(uint8_t const data[VK_LUID_SIZE])
|
|
{
|
|
memcpy(m_data, data, VK_LUID_SIZE * sizeof(uint8_t));
|
|
}
|
|
|
|
uint8_t m_data[VK_LUID_SIZE];
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& os, LUID const& uuid)
|
|
{
|
|
os << std::setfill('0') << std::hex;
|
|
for (int j = 0; j < VK_LUID_SIZE; ++j)
|
|
{
|
|
os << std::setw(2) << static_cast<uint32_t>(uuid.m_data[j]);
|
|
if (j == 3 || j == 5)
|
|
{
|
|
std::cout << '-';
|
|
}
|
|
}
|
|
os << std::setfill(' ') << std::dec;
|
|
return os;
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int /*argc*/, char ** /*argv*/)
|
|
{
|
|
try
|
|
{
|
|
vk::UniqueInstance instance = vk::su::createInstance(AppName, EngineName);
|
|
#if !defined(NDEBUG)
|
|
vk::UniqueDebugUtilsMessengerEXT debugUtilsMessenger = vk::su::createDebugUtilsMessenger(instance);
|
|
#endif
|
|
|
|
// enumerate the physicalDevices
|
|
std::vector<vk::PhysicalDevice> physicalDevices = instance->enumeratePhysicalDevices();
|
|
|
|
/* VULKAN_KEY_START */
|
|
|
|
std::cout << std::boolalpha;
|
|
for (size_t i=0 ; i<physicalDevices.size() ; i++)
|
|
{
|
|
// some properties are only valid, if a corresponding extension is available!
|
|
std::vector<vk::ExtensionProperties> extensionProperties = physicalDevices[i].enumerateDeviceExtensionProperties();
|
|
|
|
std::cout << "PhysicalDevice " << i << "\n";
|
|
auto properties2 = physicalDevices[i].getProperties2<vk::PhysicalDeviceProperties2, vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT,
|
|
vk::PhysicalDeviceConservativeRasterizationPropertiesEXT, vk::PhysicalDeviceCooperativeMatrixPropertiesNV,
|
|
vk::PhysicalDeviceDepthStencilResolvePropertiesKHR, vk::PhysicalDeviceDescriptorIndexingPropertiesEXT,
|
|
vk::PhysicalDeviceDiscardRectanglePropertiesEXT, vk::PhysicalDeviceDriverPropertiesKHR,
|
|
vk::PhysicalDeviceExternalMemoryHostPropertiesEXT, vk::PhysicalDeviceFloatControlsPropertiesKHR,
|
|
vk::PhysicalDeviceFragmentDensityMapPropertiesEXT, vk::PhysicalDeviceIDProperties, vk::PhysicalDeviceInlineUniformBlockPropertiesEXT,
|
|
vk::PhysicalDeviceLineRasterizationPropertiesEXT, vk::PhysicalDeviceMaintenance3Properties, vk::PhysicalDeviceMeshShaderPropertiesNV,
|
|
vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, vk::PhysicalDeviceMultiviewProperties,
|
|
vk::PhysicalDevicePCIBusInfoPropertiesEXT, vk::PhysicalDevicePointClippingProperties, vk::PhysicalDeviceProtectedMemoryProperties,
|
|
vk::PhysicalDevicePushDescriptorPropertiesKHR, vk::PhysicalDeviceRayTracingPropertiesNV, vk::PhysicalDeviceSampleLocationsPropertiesEXT,
|
|
vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT, vk::PhysicalDeviceShaderCoreProperties2AMD,
|
|
vk::PhysicalDeviceShaderCorePropertiesAMD, vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV,
|
|
vk::PhysicalDeviceShadingRateImagePropertiesNV, vk::PhysicalDeviceSubgroupProperties,
|
|
vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT, vk::PhysicalDeviceTimelineSemaphorePropertiesKHR,
|
|
vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT, vk::PhysicalDeviceTransformFeedbackPropertiesEXT,
|
|
vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>();
|
|
vk::PhysicalDeviceProperties const& properties = properties2.get<vk::PhysicalDeviceProperties2>().properties;
|
|
std::cout << "\t" << "Properties:\n";
|
|
std::cout << "\t\t" << "apiVersion = " << decodeAPIVersion(properties.apiVersion) << "\n";
|
|
std::cout << "\t\t" << "driverVersion = " << decodeDriverVersion(properties.driverVersion, properties.vendorID) << "\n";
|
|
std::cout << "\t\t" << "vendorID = " << decodeVendorID(properties.vendorID) << "\n";
|
|
std::cout << "\t\t" << "deviceID = " << properties.deviceID << "\n";
|
|
std::cout << "\t\t" << "deviceType = " << vk::to_string(properties.deviceType) << "\n";
|
|
std::cout << "\t\t" << "deviceName = " << properties.deviceName << "\n";
|
|
std::cout << "\t\t" << "pipelineCacheUUID = " << vk::su::UUID(properties.pipelineCacheUUID) << "\n";
|
|
std::cout << "\t\t" << "limits:\n";
|
|
std::cout << "\t\t\t" << "bufferImageGranularity = " << properties.limits.bufferImageGranularity << "\n";
|
|
std::cout << "\t\t\t" << "discreteQueuePriorities = " << properties.limits.discreteQueuePriorities << "\n";
|
|
std::cout << "\t\t\t" << "framebufferColorSampleCounts = " << vk::to_string(properties.limits.framebufferColorSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "framebufferDepthSampleCounts = " << vk::to_string(properties.limits.framebufferDepthSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "framebufferNoAttachmentsSampleCounts = " << vk::to_string(properties.limits.framebufferNoAttachmentsSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "framebufferStencilSampleCounts = " << vk::to_string(properties.limits.framebufferStencilSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "lineWidthGranularity = " << properties.limits.lineWidthGranularity << "\n";
|
|
std::cout << "\t\t\t" << "lineWidthRange = " << "[" << properties.limits.lineWidthRange[0] << ", " << properties.limits.lineWidthRange[1] << "]" << "\n";
|
|
std::cout << "\t\t\t" << "maxBoundDescriptorSets = " << properties.limits.maxBoundDescriptorSets << "\n";
|
|
std::cout << "\t\t\t" << "maxClipDistances = " << properties.limits.maxClipDistances << "\n";
|
|
std::cout << "\t\t\t" << "maxColorAttachments = " << properties.limits.maxColorAttachments << "\n";
|
|
std::cout << "\t\t\t" << "maxCombinedClipAndCullDistances = " << properties.limits.maxCombinedClipAndCullDistances << "\n";
|
|
std::cout << "\t\t\t" << "maxComputeSharedMemorySize = " << properties.limits.maxComputeSharedMemorySize << "\n";
|
|
std::cout << "\t\t\t" << "maxComputeWorkGroupCount = " << "[" << properties.limits.maxComputeWorkGroupCount[0] << ", " << properties.limits.maxComputeWorkGroupCount[1] << ", " << properties.limits.maxComputeWorkGroupCount[2] << "]" << "\n";
|
|
std::cout << "\t\t\t" << "maxComputeWorkGroupInvocations = " << properties.limits.maxComputeWorkGroupInvocations << "\n";
|
|
std::cout << "\t\t\t" << "maxComputeWorkGroupSize = " << "[" << properties.limits.maxComputeWorkGroupSize[0] << ", " << properties.limits.maxComputeWorkGroupSize[1] << ", " << properties.limits.maxComputeWorkGroupSize[2] << "]" << "\n";
|
|
std::cout << "\t\t\t" << "maxCullDistances = " << properties.limits.maxCullDistances << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetInputAttachments = " << properties.limits.maxDescriptorSetInputAttachments << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetSampledImages = " << properties.limits.maxDescriptorSetSampledImages << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetSamplers = " << properties.limits.maxDescriptorSetSamplers << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetStorageBuffers = " << properties.limits.maxDescriptorSetStorageBuffers << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetStorageBuffersDynamic = " << properties.limits.maxDescriptorSetStorageBuffersDynamic << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetStorageImages = " << properties.limits.maxDescriptorSetStorageImages << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetUniformBuffers = " << properties.limits.maxDescriptorSetUniformBuffers << "\n";
|
|
std::cout << "\t\t\t" << "maxDescriptorSetUniformBuffersDynamic = " << properties.limits.maxDescriptorSetUniformBuffersDynamic << "\n";
|
|
std::cout << "\t\t\t" << "maxDrawIndexedIndexValue = " << properties.limits.maxDrawIndexedIndexValue << "\n";
|
|
std::cout << "\t\t\t" << "maxDrawIndirectCount = " << properties.limits.maxDrawIndirectCount << "\n";
|
|
std::cout << "\t\t\t" << "maxFragmentCombinedOutputResources = " << properties.limits.maxFragmentCombinedOutputResources << "\n";
|
|
std::cout << "\t\t\t" << "maxFragmentDualSrcAttachments = " << properties.limits.maxFragmentDualSrcAttachments << "\n";
|
|
std::cout << "\t\t\t" << "maxFragmentInputComponents = " << properties.limits.maxFragmentInputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxFragmentOutputAttachments = " << properties.limits.maxFragmentOutputAttachments << "\n";
|
|
std::cout << "\t\t\t" << "maxFramebufferHeight = " << properties.limits.maxFramebufferHeight << "\n";
|
|
std::cout << "\t\t\t" << "maxFramebufferLayers = " << properties.limits.maxFramebufferLayers << "\n";
|
|
std::cout << "\t\t\t" << "maxFramebufferWidth = " << properties.limits.maxFramebufferWidth << "\n";
|
|
std::cout << "\t\t\t" << "maxGeometryInputComponents = " << properties.limits.maxGeometryInputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxGeometryOutputComponents = " << properties.limits.maxGeometryOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxGeometryOutputVertices = " << properties.limits.maxGeometryOutputVertices << "\n";
|
|
std::cout << "\t\t\t" << "maxGeometryShaderInvocations = " << properties.limits.maxGeometryShaderInvocations << "\n";
|
|
std::cout << "\t\t\t" << "maxGeometryTotalOutputComponents = " << properties.limits.maxGeometryTotalOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxImageArrayLayers = " << properties.limits.maxImageArrayLayers << "\n";
|
|
std::cout << "\t\t\t" << "maxImageDimension1D = " << properties.limits.maxImageDimension1D << "\n";
|
|
std::cout << "\t\t\t" << "maxImageDimension2D = " << properties.limits.maxImageDimension2D << "\n";
|
|
std::cout << "\t\t\t" << "maxImageDimension3D = " << properties.limits.maxImageDimension3D << "\n";
|
|
std::cout << "\t\t\t" << "maxImageDimensionCube = " << properties.limits.maxImageDimensionCube << "\n";
|
|
std::cout << "\t\t\t" << "maxInterpolationOffset = " << properties.limits.maxInterpolationOffset << "\n";
|
|
std::cout << "\t\t\t" << "maxMemoryAllocationCount = " << properties.limits.maxMemoryAllocationCount << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageDescriptorInputAttachments = " << properties.limits.maxPerStageDescriptorInputAttachments << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageDescriptorSampledImages = " << properties.limits.maxPerStageDescriptorSampledImages << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageDescriptorSamplers = " << properties.limits.maxPerStageDescriptorSamplers << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageDescriptorStorageBuffers = " << properties.limits.maxPerStageDescriptorStorageBuffers << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageDescriptorStorageImages = " << properties.limits.maxPerStageDescriptorStorageImages << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageDescriptorUniformBuffers = " << properties.limits.maxPerStageDescriptorUniformBuffers << "\n";
|
|
std::cout << "\t\t\t" << "maxPerStageResources = " << properties.limits.maxPerStageResources << "\n";
|
|
std::cout << "\t\t\t" << "maxPushConstantsSize = " << properties.limits.maxPushConstantsSize << "\n";
|
|
std::cout << "\t\t\t" << "maxSampleMaskWords = " << properties.limits.maxSampleMaskWords << "\n";
|
|
std::cout << "\t\t\t" << "maxSamplerAllocationCount = " << properties.limits.maxSamplerAllocationCount << "\n";
|
|
std::cout << "\t\t\t" << "maxSamplerAnisotropy = " << properties.limits.maxSamplerAnisotropy << "\n";
|
|
std::cout << "\t\t\t" << "maxSamplerLodBias = " << properties.limits.maxSamplerLodBias << "\n";
|
|
std::cout << "\t\t\t" << "maxStorageBufferRange = " << properties.limits.maxStorageBufferRange << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationControlPerPatchOutputComponents = " << properties.limits.maxTessellationControlPerPatchOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationControlPerVertexInputComponents = " << properties.limits.maxTessellationControlPerVertexInputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationControlPerVertexOutputComponents = " << properties.limits.maxTessellationControlPerVertexOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationControlTotalOutputComponents = " << properties.limits.maxTessellationControlTotalOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationEvaluationInputComponents = " << properties.limits.maxTessellationEvaluationInputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationEvaluationOutputComponents = " << properties.limits.maxTessellationEvaluationOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationGenerationLevel = " << properties.limits.maxTessellationGenerationLevel << "\n";
|
|
std::cout << "\t\t\t" << "maxTessellationPatchSize = " << properties.limits.maxTessellationPatchSize << "\n";
|
|
std::cout << "\t\t\t" << "maxTexelBufferElements = " << properties.limits.maxTexelBufferElements << "\n";
|
|
std::cout << "\t\t\t" << "maxTexelGatherOffset = " << properties.limits.maxTexelGatherOffset << "\n";
|
|
std::cout << "\t\t\t" << "maxTexelOffset = " << properties.limits.maxTexelOffset << "\n";
|
|
std::cout << "\t\t\t" << "maxUniformBufferRange = " << properties.limits.maxUniformBufferRange << "\n";
|
|
std::cout << "\t\t\t" << "maxVertexInputAttributeOffset = " << properties.limits.maxVertexInputAttributeOffset << "\n";
|
|
std::cout << "\t\t\t" << "maxVertexInputAttributes = " << properties.limits.maxVertexInputAttributes << "\n";
|
|
std::cout << "\t\t\t" << "maxVertexInputBindings = " << properties.limits.maxVertexInputBindings << "\n";
|
|
std::cout << "\t\t\t" << "maxVertexInputBindingStride = " << properties.limits.maxVertexInputBindingStride << "\n";
|
|
std::cout << "\t\t\t" << "maxVertexOutputComponents = " << properties.limits.maxVertexOutputComponents << "\n";
|
|
std::cout << "\t\t\t" << "maxViewportDimensions = " << "[" << properties.limits.maxViewportDimensions[0] << ", " << properties.limits.maxViewportDimensions[1] << "]" << "\n";
|
|
std::cout << "\t\t\t" << "maxViewports = " << properties.limits.maxViewports << "\n";
|
|
std::cout << "\t\t\t" << "minInterpolationOffset = " << properties.limits.minInterpolationOffset << "\n";
|
|
std::cout << "\t\t\t" << "minMemoryMapAlignment = " << properties.limits.minMemoryMapAlignment << "\n";
|
|
std::cout << "\t\t\t" << "minStorageBufferOffsetAlignment = " << properties.limits.minStorageBufferOffsetAlignment << "\n";
|
|
std::cout << "\t\t\t" << "minTexelBufferOffsetAlignment = " << properties.limits.minTexelBufferOffsetAlignment << "\n";
|
|
std::cout << "\t\t\t" << "minTexelGatherOffset = " << properties.limits.minTexelGatherOffset << "\n";
|
|
std::cout << "\t\t\t" << "minTexelOffset = " << properties.limits.minTexelOffset << "\n";
|
|
std::cout << "\t\t\t" << "minUniformBufferOffsetAlignment = " << properties.limits.minUniformBufferOffsetAlignment << "\n";
|
|
std::cout << "\t\t\t" << "mipmapPrecisionBits = " << properties.limits.mipmapPrecisionBits << "\n";
|
|
std::cout << "\t\t\t" << "nonCoherentAtomSize = " << properties.limits.nonCoherentAtomSize << "\n";
|
|
std::cout << "\t\t\t" << "optimalBufferCopyOffsetAlignment = " << properties.limits.optimalBufferCopyOffsetAlignment << "\n";
|
|
std::cout << "\t\t\t" << "optimalBufferCopyRowPitchAlignment = " << properties.limits.optimalBufferCopyRowPitchAlignment << "\n";
|
|
std::cout << "\t\t\t" << "pointSizeGranularity = " << properties.limits.pointSizeGranularity << "\n";
|
|
std::cout << "\t\t\t" << "pointSizeRange = " << "[" << properties.limits.pointSizeRange[0] << ", " << properties.limits.pointSizeRange[1] << "]" << "\n";
|
|
std::cout << "\t\t\t" << "sampledImageColorSampleCounts = " << vk::to_string(properties.limits.sampledImageColorSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "sampledImageDepthSampleCounts = " << vk::to_string(properties.limits.sampledImageDepthSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "sampledImageIntegerSampleCounts = " << vk::to_string(properties.limits.sampledImageIntegerSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "sampledImageStencilSampleCounts = " << vk::to_string(properties.limits.sampledImageStencilSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "sparseAddressSpaceSize = " << properties.limits.sparseAddressSpaceSize << "\n";
|
|
std::cout << "\t\t\t" << "standardSampleLocations = " << static_cast<bool>(properties.limits.standardSampleLocations) << "\n";
|
|
std::cout << "\t\t\t" << "storageImageSampleCounts = " << vk::to_string(properties.limits.storageImageSampleCounts) << "\n";
|
|
std::cout << "\t\t\t" << "strictLines = " << static_cast<bool>(properties.limits.strictLines) << "\n";
|
|
std::cout << "\t\t\t" << "subPixelInterpolationOffsetBits = " << properties.limits.subPixelInterpolationOffsetBits << "\n";
|
|
std::cout << "\t\t\t" << "subPixelPrecisionBits = " << properties.limits.subPixelPrecisionBits << "\n";
|
|
std::cout << "\t\t\t" << "subTexelPrecisionBits = " << properties.limits.subTexelPrecisionBits << "\n";
|
|
std::cout << "\t\t\t" << "timestampComputeAndGraphics = " << static_cast<bool>(properties.limits.timestampComputeAndGraphics) << "\n";
|
|
std::cout << "\t\t\t" << "timestampPeriod = " << properties.limits.timestampPeriod << "\n";
|
|
std::cout << "\t\t\t" << "viewportBoundsRange = " << "[" << properties.limits.viewportBoundsRange[0] << ", " << properties.limits.viewportBoundsRange[1] << "]" << "\n";
|
|
std::cout << "\t\t\t" << "viewportSubPixelBits = " << properties.limits.viewportSubPixelBits << "\n";
|
|
std::cout << "\t\t" << "sparseProperties:\n";
|
|
std::cout << "\t\t\t" << "residencyAlignedMipSize = " << static_cast<bool>(properties.sparseProperties.residencyAlignedMipSize) << "\n";
|
|
std::cout << "\t\t\t" << "residencyNonResidentStrict = " << static_cast<bool>(properties.sparseProperties.residencyNonResidentStrict) << "\n";
|
|
std::cout << "\t\t\t" << "residencyStandard2DBlockShape = " << static_cast<bool>(properties.sparseProperties.residencyStandard2DBlockShape) << "\n";
|
|
std::cout << "\t\t\t" << "residencyStandard2DMultisampleBlockShape = " << static_cast<bool>(properties.sparseProperties.residencyStandard2DMultisampleBlockShape) << "\n";
|
|
std::cout << "\t\t\t" << "residencyStandard3DBlockShape = " << static_cast<bool>(properties.sparseProperties.residencyStandard3DBlockShape) << "\n";
|
|
std::cout << "\n";
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_blend_operation_advanced"))
|
|
{
|
|
vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& blendOperationAdvancedProperties = properties2.get<vk::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>();
|
|
std::cout << "\t" << "BlendOperationAdvancedProperties:\n";
|
|
std::cout << "\t\t" << "advancedBlendAllOperations = " << static_cast<bool>(blendOperationAdvancedProperties.advancedBlendAllOperations) << "\n";
|
|
std::cout << "\t\t" << "advancedBlendCorrelatedOverlap = " << static_cast<bool>(blendOperationAdvancedProperties.advancedBlendCorrelatedOverlap) << "\n";
|
|
std::cout << "\t\t" << "advancedBlendIndependentBlend = " << static_cast<bool>(blendOperationAdvancedProperties.advancedBlendIndependentBlend) << "\n";
|
|
std::cout << "\t\t" << "advancedBlendMaxColorAttachments = " << blendOperationAdvancedProperties.advancedBlendMaxColorAttachments << "\n";
|
|
std::cout << "\t\t" << "advancedBlendNonPremultipliedDstColor = " << static_cast<bool>(blendOperationAdvancedProperties.advancedBlendNonPremultipliedDstColor) << "\n";
|
|
std::cout << "\t\t" << "advancedBlendNonPremultipliedSrcColor = " << static_cast<bool>(blendOperationAdvancedProperties.advancedBlendNonPremultipliedSrcColor) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_conservative_rasterization"))
|
|
{
|
|
vk::PhysicalDeviceConservativeRasterizationPropertiesEXT const& conservativeRasterizationProperties = properties2.get<vk::PhysicalDeviceConservativeRasterizationPropertiesEXT>();
|
|
std::cout << "\t" << "ConservativeRasterizationProperties:\n";
|
|
std::cout << "\t\t" << "conservativePointAndLineRasterization = " << static_cast<bool>(conservativeRasterizationProperties.conservativePointAndLineRasterization) << "\n";
|
|
std::cout << "\t\t" << "conservativeRasterizationPostDepthCoverage = " << static_cast<bool>(conservativeRasterizationProperties.conservativeRasterizationPostDepthCoverage) << "\n";
|
|
std::cout << "\t\t" << "degenerateLinesRasterized = " << static_cast<bool>(conservativeRasterizationProperties.degenerateLinesRasterized) << "\n";
|
|
std::cout << "\t\t" << "degenerateTrianglesRasterized = " << static_cast<bool>(conservativeRasterizationProperties.degenerateTrianglesRasterized) << "\n";
|
|
std::cout << "\t\t" << "extraPrimitiveOverestimationSizeGranularity = " << conservativeRasterizationProperties.extraPrimitiveOverestimationSizeGranularity << "\n";
|
|
std::cout << "\t\t" << "fullyCoveredFragmentShaderInputVariable = " << static_cast<bool>(conservativeRasterizationProperties.fullyCoveredFragmentShaderInputVariable) << "\n";
|
|
std::cout << "\t\t" << "maxExtraPrimitiveOverestimationSize = " << conservativeRasterizationProperties.maxExtraPrimitiveOverestimationSize << "\n";
|
|
std::cout << "\t\t" << "primitiveOverestimationSize = " << conservativeRasterizationProperties.primitiveOverestimationSize << "\n";
|
|
std::cout << "\t\t" << "primitiveUnderestimation = " << static_cast<bool>(conservativeRasterizationProperties.primitiveUnderestimation) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_NV_cooperative_matrix"))
|
|
{
|
|
vk::PhysicalDeviceCooperativeMatrixPropertiesNV const& cooperativeMatrixProperties = properties2.get<vk::PhysicalDeviceCooperativeMatrixPropertiesNV>();
|
|
std::cout << "\t" << "CooperativeMatrixProperties:\n";
|
|
std::cout << "\t\t" << "cooperativeMatrixSupportedStages = " << vk::to_string(cooperativeMatrixProperties.cooperativeMatrixSupportedStages) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_KHR_depth_stencil_resolve"))
|
|
{
|
|
vk::PhysicalDeviceDepthStencilResolvePropertiesKHR const& depthStencilResolveProperties = properties2.get<vk::PhysicalDeviceDepthStencilResolvePropertiesKHR>();
|
|
std::cout << "\t" << "DepthStencilResolveProperties:\n";
|
|
std::cout << "\t\t" << "independentResolve = " << static_cast<bool>(depthStencilResolveProperties.independentResolve) << "\n";
|
|
std::cout << "\t\t" << "independentResolveNone = " << static_cast<bool>(depthStencilResolveProperties.independentResolveNone) << "\n";
|
|
std::cout << "\t\t" << "supportedDepthResolveModes = " << vk::to_string(depthStencilResolveProperties.supportedDepthResolveModes) << "\n";
|
|
std::cout << "\t\t" << "supportedStencilResolveModes = " << vk::to_string(depthStencilResolveProperties.supportedStencilResolveModes) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_descriptor_indexing"))
|
|
{
|
|
vk::PhysicalDeviceDescriptorIndexingPropertiesEXT const& descriptorIndexingProperties = properties2.get<vk::PhysicalDeviceDescriptorIndexingPropertiesEXT>();
|
|
std::cout << "\t" << "DescriptorIndexingProperties:\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindInputAttachments = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindSampledImages = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindSamplers = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindStorageBuffers = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindStorageImages = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindUniformBuffers = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = " << descriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindInputAttachments = " << descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindSampledImages = " << descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindSamplers = " << descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindStorageBuffers = " << descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindStorageImages = " << descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindUniformBuffers = " << descriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers << "\n";
|
|
std::cout << "\t\t" << "maxPerStageUpdateAfterBindResources = " << descriptorIndexingProperties.maxPerStageUpdateAfterBindResources << "\n";
|
|
std::cout << "\t\t" << "maxUpdateAfterBindDescriptorsInAllPools = " << descriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools << "\n";
|
|
std::cout << "\t\t" << "quadDivergentImplicitLod = " << static_cast<bool>(descriptorIndexingProperties.quadDivergentImplicitLod) << "\n";
|
|
std::cout << "\t\t" << "robustBufferAccessUpdateAfterBind = " << static_cast<bool>(descriptorIndexingProperties.robustBufferAccessUpdateAfterBind) << "\n";
|
|
std::cout << "\t\t" << "shaderInputAttachmentArrayNonUniformIndexingNative = " << static_cast<bool>(descriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative) << "\n";
|
|
std::cout << "\t\t" << "shaderSampledImageArrayNonUniformIndexingNative = " << static_cast<bool>(descriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative) << "\n";
|
|
std::cout << "\t\t" << "shaderStorageBufferArrayNonUniformIndexingNative = " << static_cast<bool>(descriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative) << "\n";
|
|
std::cout << "\t\t" << "shaderStorageImageArrayNonUniformIndexingNative = " << static_cast<bool>(descriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative) << "\n";
|
|
std::cout << "\t\t" << "shaderUniformBufferArrayNonUniformIndexingNative = " << static_cast<bool>(descriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_discard_rectangles"))
|
|
{
|
|
vk::PhysicalDeviceDiscardRectanglePropertiesEXT const& discardRectangleProperties = properties2.get<vk::PhysicalDeviceDiscardRectanglePropertiesEXT>();
|
|
std::cout << "\t" << "DiscardRectangleProperties:\n";
|
|
std::cout << "\t\t" << "maxDiscardRectangles = " << discardRectangleProperties.maxDiscardRectangles << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_KHR_driver_properties"))
|
|
{
|
|
vk::PhysicalDeviceDriverPropertiesKHR const& driverProperties = properties2.get<vk::PhysicalDeviceDriverPropertiesKHR>();
|
|
std::cout << "\t" << "DriverProperties:\n";
|
|
std::cout << "\t\t" << "driverID = " << vk::to_string(driverProperties.driverID) << "\n";
|
|
std::cout << "\t\t" << "driverName = " << driverProperties.driverName << "\n";
|
|
std::cout << "\t\t" << "driverInfo = " << driverProperties.driverInfo << "\n";
|
|
std::cout << "\t\t" << "conformanceVersion = " << static_cast<uint32_t>(driverProperties.conformanceVersion.major) << "." << static_cast<uint32_t>(driverProperties.conformanceVersion.minor) << "." << static_cast<uint32_t>(driverProperties.conformanceVersion.subminor) << "." << static_cast<uint32_t>(driverProperties.conformanceVersion.patch) << std::dec << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_external_memory_host"))
|
|
{
|
|
vk::PhysicalDeviceExternalMemoryHostPropertiesEXT const& externalMemoryHostProperties = properties2.get<vk::PhysicalDeviceExternalMemoryHostPropertiesEXT>();
|
|
std::cout << "\t" << "ExternalMemoryHostProperties:\n";
|
|
std::cout << "\t\t" << "minImportedHostPointerAlignment = " << externalMemoryHostProperties.minImportedHostPointerAlignment << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_KHR_shader_float_controls"))
|
|
{
|
|
vk::PhysicalDeviceFloatControlsPropertiesKHR const& floatControlsProperties = properties2.get<vk::PhysicalDeviceFloatControlsPropertiesKHR>();
|
|
std::cout << "\t" << "FloatControlsProperties:\n";
|
|
std::cout << "\t\t" << "denormBehaviorIndependence = " << vk::to_string(floatControlsProperties.denormBehaviorIndependence) << "\n";
|
|
std::cout << "\t\t" << "roundingModeIndependence = " << vk::to_string(floatControlsProperties.roundingModeIndependence) << "\n";
|
|
std::cout << "\t\t" << "shaderDenormFlushToZeroFloat16 = " << static_cast<bool>(floatControlsProperties.shaderDenormFlushToZeroFloat16) << "\n";
|
|
std::cout << "\t\t" << "shaderDenormFlushToZeroFloat32 = " << static_cast<bool>(floatControlsProperties.shaderDenormFlushToZeroFloat32) << "\n";
|
|
std::cout << "\t\t" << "shaderDenormFlushToZeroFloat64 = " << static_cast<bool>(floatControlsProperties.shaderDenormFlushToZeroFloat64) << "\n";
|
|
std::cout << "\t\t" << "shaderDenormPreserveFloat16 = " << static_cast<bool>(floatControlsProperties.shaderDenormPreserveFloat16) << "\n";
|
|
std::cout << "\t\t" << "shaderDenormPreserveFloat32 = " << static_cast<bool>(floatControlsProperties.shaderDenormPreserveFloat32) << "\n";
|
|
std::cout << "\t\t" << "shaderDenormPreserveFloat64 = " << static_cast<bool>(floatControlsProperties.shaderDenormPreserveFloat64) << "\n";
|
|
std::cout << "\t\t" << "shaderRoundingModeRTEFloat16 = " << static_cast<bool>(floatControlsProperties.shaderRoundingModeRTEFloat16) << "\n";
|
|
std::cout << "\t\t" << "shaderRoundingModeRTEFloat32 = " << static_cast<bool>(floatControlsProperties.shaderRoundingModeRTEFloat32) << "\n";
|
|
std::cout << "\t\t" << "shaderRoundingModeRTEFloat64 = " << static_cast<bool>(floatControlsProperties.shaderRoundingModeRTEFloat64) << "\n";
|
|
std::cout << "\t\t" << "shaderRoundingModeRTZFloat16 = " << static_cast<bool>(floatControlsProperties.shaderRoundingModeRTZFloat16) << "\n";
|
|
std::cout << "\t\t" << "shaderRoundingModeRTZFloat32 = " << static_cast<bool>(floatControlsProperties.shaderRoundingModeRTZFloat32) << "\n";
|
|
std::cout << "\t\t" << "shaderRoundingModeRTZFloat64 = " << static_cast<bool>(floatControlsProperties.shaderRoundingModeRTZFloat64) << "\n";
|
|
std::cout << "\t\t" << "shaderSignedZeroInfNanPreserveFloat16 = " << static_cast<bool>(floatControlsProperties.shaderSignedZeroInfNanPreserveFloat16) << "\n";
|
|
std::cout << "\t\t" << "shaderSignedZeroInfNanPreserveFloat32 = " << static_cast<bool>(floatControlsProperties.shaderSignedZeroInfNanPreserveFloat32) << "\n";
|
|
std::cout << "\t\t" << "shaderSignedZeroInfNanPreserveFloat64 = " << static_cast<bool>(floatControlsProperties.shaderSignedZeroInfNanPreserveFloat64) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_fragment_density_map"))
|
|
{
|
|
vk::PhysicalDeviceFragmentDensityMapPropertiesEXT const& fragmentDensityMapProperties = properties2.get<vk::PhysicalDeviceFragmentDensityMapPropertiesEXT>();
|
|
std::cout << "\t" << "FragmentDensityProperties:\n";
|
|
std::cout << "\t\t" << "fragmentDensityInvocations = " << static_cast<bool>(fragmentDensityMapProperties.fragmentDensityInvocations) << "\n";
|
|
std::cout << "\t\t" << "maxFragmentDensityTexelSize = " << fragmentDensityMapProperties.maxFragmentDensityTexelSize.width << " x " << fragmentDensityMapProperties.maxFragmentDensityTexelSize.height << "\n";
|
|
std::cout << "\t\t" << "minFragmentDensityTexelSize = " << fragmentDensityMapProperties.minFragmentDensityTexelSize.width << " x " << fragmentDensityMapProperties.minFragmentDensityTexelSize.height << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
vk::PhysicalDeviceIDProperties const& idProperties = properties2.get<vk::PhysicalDeviceIDProperties>();
|
|
std::cout << "\t" << "IDProperties:\n";
|
|
std::cout << "\t\t" << "deviceUUID = " << vk::su::UUID(idProperties.deviceUUID) << "\n";
|
|
std::cout << "\t\t" << "driverUUID = " << vk::su::UUID(idProperties.driverUUID) << "\n";
|
|
std::cout << "\t\t" << "deviceLUID = " << vk::su::LUID(idProperties.deviceLUID) << "\n";
|
|
std::cout << "\t\t" << "deviceNodeMask = " << std::hex << idProperties.deviceNodeMask << std::dec << "\n";
|
|
std::cout << "\t\t" << "deviceLUIDValid = " << static_cast<bool>(idProperties.deviceLUIDValid) << "\n";
|
|
std::cout << "\n";
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_inline_uniform_block"))
|
|
{
|
|
vk::PhysicalDeviceInlineUniformBlockPropertiesEXT const& inlineUniformBlockProperties = properties2.get<vk::PhysicalDeviceInlineUniformBlockPropertiesEXT>();
|
|
std::cout << "\t" << "InlineUniformBlockProperties:\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetInlineUniformBlocks = " << inlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks << "\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetUpdateAfterBindInlineUniformBlocks = " << inlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks << "\n";
|
|
std::cout << "\t\t" << "maxInlineUniformBlockSize = " << inlineUniformBlockProperties.maxInlineUniformBlockSize << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorInlineUniformBlocks = " << inlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks << "\n";
|
|
std::cout << "\t\t" << "maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = " << inlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_line_rasterization"))
|
|
{
|
|
vk::PhysicalDeviceLineRasterizationPropertiesEXT const& lineRasterizationProperties = properties2.get<vk::PhysicalDeviceLineRasterizationPropertiesEXT>();
|
|
std::cout << "\t" << "LineRasterizationProperties:\n";
|
|
std::cout << "\t\t" << "lineSubPixelPrecisionBits = " << lineRasterizationProperties.lineSubPixelPrecisionBits << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
vk::PhysicalDeviceMaintenance3Properties const& maintenance3Properties = properties2.get<vk::PhysicalDeviceMaintenance3Properties>();
|
|
std::cout << "\t" << "Maintenance3Properties:\n";
|
|
std::cout << "\t\t" << "maxMemoryAllocationSize = " << maintenance3Properties.maxMemoryAllocationSize << "\n";
|
|
std::cout << "\t\t" << "maxPerSetDescriptors = " << maintenance3Properties.maxPerSetDescriptors << "\n";
|
|
std::cout << "\n";
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_NV_mesh_shader"))
|
|
{
|
|
vk::PhysicalDeviceMeshShaderPropertiesNV const& meshShaderProperties = properties2.get<vk::PhysicalDeviceMeshShaderPropertiesNV>();
|
|
std::cout << "\t" << "MeshShaderProperties:\n";
|
|
std::cout << "\t\t" << "maxDrawMeshTasksCount = " << meshShaderProperties.maxDrawMeshTasksCount << "\n";
|
|
std::cout << "\t\t" << "maxMeshMultiviewViewCount = " << meshShaderProperties.maxMeshMultiviewViewCount << "\n";
|
|
std::cout << "\t\t" << "maxMeshOutputPrimitives = " << meshShaderProperties.maxMeshOutputPrimitives << "\n";
|
|
std::cout << "\t\t" << "maxMeshOutputVertices = " << meshShaderProperties.maxMeshOutputVertices << "\n";
|
|
std::cout << "\t\t" << "maxMeshTotalMemorySize = " << meshShaderProperties.maxMeshTotalMemorySize << "\n";
|
|
std::cout << "\t\t" << "maxMeshWorkGroupInvocations = " << meshShaderProperties.maxMeshWorkGroupInvocations << "\n";
|
|
std::cout << "\t\t" << "maxMeshWorkGroupSize = " << "[" << meshShaderProperties.maxMeshWorkGroupSize[0] << ", " << meshShaderProperties.maxMeshWorkGroupSize[1] << ", " << meshShaderProperties.maxMeshWorkGroupSize[2] << "]" << "\n";
|
|
std::cout << "\t\t" << "maxTaskOutputCount = " << meshShaderProperties.maxTaskOutputCount << "\n";
|
|
std::cout << "\t\t" << "maxTaskTotalMemorySize = " << meshShaderProperties.maxTaskTotalMemorySize << "\n";
|
|
std::cout << "\t\t" << "maxTaskWorkGroupInvocations = " << meshShaderProperties.maxTaskWorkGroupInvocations << "\n";
|
|
std::cout << "\t\t" << "maxTaskWorkGroupSize = " << "[" << meshShaderProperties.maxTaskWorkGroupSize[0] << ", " << meshShaderProperties.maxTaskWorkGroupSize[1] << ", " << meshShaderProperties.maxTaskWorkGroupSize[2] << "]" << "\n";
|
|
std::cout << "\t\t" << "meshOutputPerPrimitiveGranularity = " << meshShaderProperties.meshOutputPerPrimitiveGranularity << "\n";
|
|
std::cout << "\t\t" << "meshOutputPerVertexGranularity = " << meshShaderProperties.meshOutputPerVertexGranularity << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_NVX_multiview_per_view_attributes"))
|
|
{
|
|
vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& multiviewPerViewAttributesProperties = properties2.get<vk::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>();
|
|
std::cout << "\t" << "MultiviewPerViewAttributesProperties:\n";
|
|
std::cout << "\t\t" << "perViewPositionAllComponents = " << static_cast<bool>(multiviewPerViewAttributesProperties.perViewPositionAllComponents) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
vk::PhysicalDeviceMultiviewProperties const& multiviewProperties = properties2.get<vk::PhysicalDeviceMultiviewProperties>();
|
|
std::cout << "\t" << "MultiviewProperties:\n";
|
|
std::cout << "\t\t" << "maxMultiviewInstanceIndex = " << multiviewProperties.maxMultiviewInstanceIndex << "\n";
|
|
std::cout << "\t\t" << "maxMultiviewViewCount = " << multiviewProperties.maxMultiviewViewCount << "\n";
|
|
std::cout << "\n";
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_pci_bus_info"))
|
|
{
|
|
vk::PhysicalDevicePCIBusInfoPropertiesEXT const& pciBusInfoProperties = properties2.get<vk::PhysicalDevicePCIBusInfoPropertiesEXT>();
|
|
std::cout << "\t" << "PCIBusInfoProperties:\n";
|
|
std::cout << "\t\t" << "pciDomain = " << pciBusInfoProperties.pciDomain << "\n";
|
|
std::cout << "\t\t" << "pciBus = " << pciBusInfoProperties.pciBus << "\n";
|
|
std::cout << "\t\t" << "pciDevice = " << pciBusInfoProperties.pciDevice << "\n";
|
|
std::cout << "\t\t" << "pciFunction = " << pciBusInfoProperties.pciFunction << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_KHR_maintenance2"))
|
|
{
|
|
vk::PhysicalDevicePointClippingProperties const& pointClippingProperties = properties2.get<vk::PhysicalDevicePointClippingProperties>();
|
|
std::cout << "\t" << "PointClippingProperties:\n";
|
|
std::cout << "\t\t" << "pointClippingBehavior = " << vk::to_string(pointClippingProperties.pointClippingBehavior) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
vk::PhysicalDeviceProtectedMemoryProperties const& protectedMemoryProperties = properties2.get<vk::PhysicalDeviceProtectedMemoryProperties>();
|
|
std::cout << "\t" << "ProtectedMemoryProperties:\n";
|
|
std::cout << "\t\t" << "protectedNoFault = " << static_cast<bool>(protectedMemoryProperties.protectedNoFault) << "\n";
|
|
std::cout << "\n";
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_KHR_push_descriptor"))
|
|
{
|
|
vk::PhysicalDevicePushDescriptorPropertiesKHR const& pushDescriptorProperties = properties2.get<vk::PhysicalDevicePushDescriptorPropertiesKHR>();
|
|
std::cout << "\t" << "PushDescriptorProperties:\n";
|
|
std::cout << "\t\t" << "maxPushDescriptors = " << pushDescriptorProperties.maxPushDescriptors << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_NV_ray_tracing"))
|
|
{
|
|
vk::PhysicalDeviceRayTracingPropertiesNV const& rayTracingProperties = properties2.get<vk::PhysicalDeviceRayTracingPropertiesNV>();
|
|
std::cout << "\t" << "RayTracingProperties:\n";
|
|
std::cout << "\t\t" << "maxDescriptorSetAccelerationStructures = " << rayTracingProperties.maxDescriptorSetAccelerationStructures << "\n";
|
|
std::cout << "\t\t" << "maxGeometryCount = " << rayTracingProperties.maxGeometryCount << "\n";
|
|
std::cout << "\t\t" << "maxInstanceCount = " << rayTracingProperties.maxInstanceCount << "\n";
|
|
std::cout << "\t\t" << "maxRecursionDepth = " << rayTracingProperties.maxRecursionDepth << "\n";
|
|
std::cout << "\t\t" << "maxShaderGroupStride = " << rayTracingProperties.maxShaderGroupStride << "\n";
|
|
std::cout << "\t\t" << "maxTriangleCount = " << rayTracingProperties.maxTriangleCount << "\n";
|
|
std::cout << "\t\t" << "shaderGroupBaseAlignment = " << rayTracingProperties.shaderGroupBaseAlignment << "\n";
|
|
std::cout << "\t\t" << "shaderGroupHandleSize = " << rayTracingProperties.shaderGroupHandleSize << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_sample_locations"))
|
|
{
|
|
vk::PhysicalDeviceSampleLocationsPropertiesEXT const& sampleLocationProperties = properties2.get<vk::PhysicalDeviceSampleLocationsPropertiesEXT>();
|
|
std::cout << "\t" << "SampleLocationProperties:\n";
|
|
std::cout << "\t\t" << "maxSampleLocationGridSize = " << sampleLocationProperties.maxSampleLocationGridSize.width << " x " << sampleLocationProperties.maxSampleLocationGridSize.height << "\n";
|
|
std::cout << "\t\t" << "sampleLocationCoordinateRange = " << "[" << sampleLocationProperties.sampleLocationCoordinateRange[0] << ", " << sampleLocationProperties.sampleLocationCoordinateRange[1] << "]" << "\n";
|
|
std::cout << "\t\t" << "sampleLocationSampleCounts = " << vk::to_string(sampleLocationProperties.sampleLocationSampleCounts) << "\n";
|
|
std::cout << "\t\t" << "sampleLocationSubPixelBits = " << sampleLocationProperties.sampleLocationSubPixelBits << "\n";
|
|
std::cout << "\t\t" << "variableSampleLocations = " << static_cast<bool>(sampleLocationProperties.variableSampleLocations) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_sampler_filter_minmax"))
|
|
{
|
|
vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& samplerFilterMinmaxProperties = properties2.get<vk::PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>();
|
|
std::cout << "\t" << "SamplerFilterMinmaxProperties:\n";
|
|
std::cout << "\t\t" << "filterMinmaxImageComponentMapping = " << static_cast<bool>(samplerFilterMinmaxProperties.filterMinmaxImageComponentMapping) << "\n";
|
|
std::cout << "\t\t" << "filterMinmaxSingleComponentFormats = " << static_cast<bool>(samplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_AMD_shader_core_properties2"))
|
|
{
|
|
vk::PhysicalDeviceShaderCoreProperties2AMD const& shaderCoreProperties2 = properties2.get<vk::PhysicalDeviceShaderCoreProperties2AMD>();
|
|
std::cout << "\t" << "ShaderCoreProperties2:\n";
|
|
std::cout << "\t\t" << "activeComputeUnitCount = " << shaderCoreProperties2.activeComputeUnitCount << "\n";
|
|
std::cout << "\t\t" << "shaderCoreFeatures = " << vk::to_string(shaderCoreProperties2.shaderCoreFeatures) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_AMD_shader_core_properties2"))
|
|
{
|
|
vk::PhysicalDeviceShaderCorePropertiesAMD const& shaderCoreProperties = properties2.get<vk::PhysicalDeviceShaderCorePropertiesAMD>();
|
|
std::cout << "\t" << "ShaderCoreProperties:\n";
|
|
std::cout << "\t\t" << "computeUnitsPerShaderArray = " << shaderCoreProperties.computeUnitsPerShaderArray << "\n";
|
|
std::cout << "\t\t" << "maxSgprAllocation = " << shaderCoreProperties.maxSgprAllocation << "\n";
|
|
std::cout << "\t\t" << "maxVgprAllocation = " << shaderCoreProperties.maxVgprAllocation << "\n";
|
|
std::cout << "\t\t" << "minSgprAllocation = " << shaderCoreProperties.minSgprAllocation << "\n";
|
|
std::cout << "\t\t" << "minVgprAllocation = " << shaderCoreProperties.minVgprAllocation << "\n";
|
|
std::cout << "\t\t" << "sgprAllocationGranularity = " << shaderCoreProperties.sgprAllocationGranularity << "\n";
|
|
std::cout << "\t\t" << "sgprsPerSimd = " << shaderCoreProperties.sgprsPerSimd << "\n";
|
|
std::cout << "\t\t" << "shaderArraysPerEngineCount = " << shaderCoreProperties.shaderArraysPerEngineCount << "\n";
|
|
std::cout << "\t\t" << "shaderEngineCount = " << shaderCoreProperties.shaderEngineCount << "\n";
|
|
std::cout << "\t\t" << "simdPerComputeUnit = " << shaderCoreProperties.simdPerComputeUnit << "\n";
|
|
std::cout << "\t\t" << "vgprAllocationGranularity = " << shaderCoreProperties.vgprAllocationGranularity << "\n";
|
|
std::cout << "\t\t" << "vgprsPerSimd = " << shaderCoreProperties.vgprsPerSimd << "\n";
|
|
std::cout << "\t\t" << "wavefrontSize = " << shaderCoreProperties.wavefrontSize << "\n";
|
|
std::cout << "\t\t" << "wavefrontsPerSimd = " << shaderCoreProperties.wavefrontsPerSimd << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_NV_shader_sm_builtins"))
|
|
{
|
|
vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV const& shaderSMBuiltinsProperties = properties2.get<vk::PhysicalDeviceShaderSMBuiltinsPropertiesNV>();
|
|
std::cout << "\t" << "ShaderSMBuiltinsProperties:\n";
|
|
std::cout << "\t\t" << "shaderSMCount = " << shaderSMBuiltinsProperties.shaderSMCount << "\n";
|
|
std::cout << "\t\t" << "shaderWarpsPerSM = " << shaderSMBuiltinsProperties.shaderWarpsPerSM << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_NV_shading_rate_image"))
|
|
{
|
|
vk::PhysicalDeviceShadingRateImagePropertiesNV const& shadingRageImageProperties = properties2.get<vk::PhysicalDeviceShadingRateImagePropertiesNV>();
|
|
std::cout << "\t" << "ShadingRateImageProperties:\n";
|
|
std::cout << "\t\t" << "shadingRateMaxCoarseSamples = " << shadingRageImageProperties.shadingRateMaxCoarseSamples << "\n";
|
|
std::cout << "\t\t" << "shadingRatePaletteSize = " << shadingRageImageProperties.shadingRatePaletteSize << "\n";
|
|
std::cout << "\t\t" << "shadingRatePaletteSize = " << "[" << shadingRageImageProperties.shadingRateTexelSize.width << " x " << shadingRageImageProperties.shadingRateTexelSize.height << "]" << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
vk::PhysicalDeviceSubgroupProperties const& subgroupProperties = properties2.get<vk::PhysicalDeviceSubgroupProperties>();
|
|
std::cout << "\t" << "SubgroupProperties:\n";
|
|
std::cout << "\t\t" << "quadOperationsInAllStages = " << static_cast<bool>(subgroupProperties.quadOperationsInAllStages) << "\n";
|
|
std::cout << "\t\t" << "subgroupSize = " << subgroupProperties.subgroupSize << "\n";
|
|
std::cout << "\t\t" << "supportedOperations = " << vk::to_string(subgroupProperties.supportedOperations) << "\n";
|
|
std::cout << "\t\t" << "supportedStages = " << vk::to_string(subgroupProperties.supportedStages) << "\n";
|
|
std::cout << "\n";
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_subgroup_size_control"))
|
|
{
|
|
vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT const& subgroupSizeControlProperties = properties2.get<vk::PhysicalDeviceSubgroupSizeControlPropertiesEXT>();
|
|
std::cout << "\t" << "SubgroupSizeControlProperties:\n";
|
|
std::cout << "\t\t" << "maxComputeWorkgroupSubgroups = " << subgroupSizeControlProperties.maxComputeWorkgroupSubgroups << "\n";
|
|
std::cout << "\t\t" << "maxSubgroupSize = " << subgroupSizeControlProperties.maxSubgroupSize << "\n";
|
|
std::cout << "\t\t" << "minSubgroupSize = " << subgroupSizeControlProperties.minSubgroupSize << "\n";
|
|
std::cout << "\t\t" << "requiredSubgroupSizeStages = " << vk::to_string(subgroupSizeControlProperties.requiredSubgroupSizeStages) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_KHR_timeline_semaphore"))
|
|
{
|
|
vk::PhysicalDeviceTimelineSemaphorePropertiesKHR const& timelineSemaphoreProperties = properties2.get<vk::PhysicalDeviceTimelineSemaphorePropertiesKHR>();
|
|
std::cout << "\t" << "TimelineSemaphoreProperties:\n";
|
|
std::cout << "\t\t" << "maxTimelineSemaphoreValueDifference = " << timelineSemaphoreProperties.maxTimelineSemaphoreValueDifference << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_texel_buffer_alignment"))
|
|
{
|
|
vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT const& texelBufferAlignmentProperties = properties2.get<vk::PhysicalDeviceTexelBufferAlignmentPropertiesEXT>();
|
|
std::cout << "\t" << "TexelBufferAlignmentProperties:\n";
|
|
std::cout << "\t\t" << "storageTexelBufferOffsetAlignmentBytes = " << texelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes << "\n";
|
|
std::cout << "\t\t" << "storageTexelBufferOffsetSingleTexelAlignment = " << static_cast<bool>(texelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment) << "\n";
|
|
std::cout << "\t\t" << "uniformTexelBufferOffsetAlignmentBytes = " << texelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes << "\n";
|
|
std::cout << "\t\t" << "uniformTexelBufferOffsetSingleTexelAlignment = " << static_cast<bool>(texelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_transform_feedback"))
|
|
{
|
|
vk::PhysicalDeviceTransformFeedbackPropertiesEXT const& transformFeedbackProperties = properties2.get<vk::PhysicalDeviceTransformFeedbackPropertiesEXT>();
|
|
std::cout << "\t" << "TransformFeedbackProperties:\n";
|
|
std::cout << "\t\t" << "maxTransformFeedbackBufferDataSize = " << transformFeedbackProperties.maxTransformFeedbackBufferDataSize << "\n";
|
|
std::cout << "\t\t" << "maxTransformFeedbackBufferDataStride = " << transformFeedbackProperties.maxTransformFeedbackBufferDataStride << "\n";
|
|
std::cout << "\t\t" << "maxTransformFeedbackBuffers = " << transformFeedbackProperties.maxTransformFeedbackBuffers << "\n";
|
|
std::cout << "\t\t" << "maxTransformFeedbackBufferSize = " << transformFeedbackProperties.maxTransformFeedbackBufferSize << "\n";
|
|
std::cout << "\t\t" << "maxTransformFeedbackStreamDataSize = " << transformFeedbackProperties.maxTransformFeedbackStreamDataSize << "\n";
|
|
std::cout << "\t\t" << "maxTransformFeedbackStreams = " << transformFeedbackProperties.maxTransformFeedbackStreams << "\n";
|
|
std::cout << "\t\t" << "transformFeedbackDraw = " << static_cast<bool>(transformFeedbackProperties.transformFeedbackDraw) << "\n";
|
|
std::cout << "\t\t" << "transformFeedbackQueries = " << static_cast<bool>(transformFeedbackProperties.transformFeedbackQueries) << "\n";
|
|
std::cout << "\t\t" << "transformFeedbackRasterizationStreamSelect = " << static_cast<bool>(transformFeedbackProperties.transformFeedbackRasterizationStreamSelect) << "\n";
|
|
std::cout << "\t\t" << "transformFeedbackStreamsLinesTriangles = " << static_cast<bool>(transformFeedbackProperties.transformFeedbackStreamsLinesTriangles) << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
|
|
if (vk::su::contains(extensionProperties, "VK_EXT_vertex_attribute_divisor"))
|
|
{
|
|
vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const& vertexAttributeDivisorProperties = properties2.get<vk::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>();
|
|
std::cout << "\t" << "VertexAttributeDivisorProperties:\n";
|
|
std::cout << "\t\t" << "maxVertexAttribDivisor = " << vertexAttributeDivisorProperties.maxVertexAttribDivisor << "\n";
|
|
std::cout << "\n";
|
|
}
|
|
}
|
|
|
|
/* VULKAN_KEY_END */
|
|
}
|
|
catch (vk::SystemError err)
|
|
{
|
|
std::cout << "vk::SystemError: " << err.what() << std::endl;
|
|
exit(-1);
|
|
}
|
|
catch (std::runtime_error err)
|
|
{
|
|
std::cout << "std::runtime_error: " << err.what() << std::endl;
|
|
exit(-1);
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cout << "unknown error\n";
|
|
exit(-1);
|
|
}
|
|
return 0;
|
|
}
|