IPhysicalDevice::APIVersion struct and version reporting for Vulkan and GL backends

Erfan-Ahmadi · Erfan-Ahmadi · commit 92a06156ee45 · 2022-02-01T15:40:56.000+03:30
diff --git a/include/nbl/video/IPhysicalDevice.h b/include/nbl/video/IPhysicalDevice.h
@@ -103,7 +103,7 @@ class IPhysicalDevice : public core::Interface, public core::Unmovable
             // a workgroup of the next cut of the DAG spins for an extended time to wait on a workgroup from a previous one.
             inline uint32_t computeOptimalPersistentWorkgroupDispatchSize(const uint64_t elementCount, const uint32_t workgroupSize, const uint32_t workgroupSpinningProtection=1u) const
             {
-				assert(elementCount!=0ull && "Input element count can't be 0!");
+                assert(elementCount!=0ull && "Input element count can't be 0!");
                 const uint64_t infinitelyWideDeviceWGCount = (elementCount-1ull)/(static_cast<uint64_t>(workgroupSize)*static_cast<uint64_t>(workgroupSpinningProtection))+1ull;
                 const uint32_t maxResidentWorkgroups = maxResidentInvocations/workgroupSize;
                 return static_cast<uint32_t>(core::min<uint64_t>(infinitelyWideDeviceWGCount,maxResidentWorkgroups));
@@ -320,9 +320,17 @@ class IPhysicalDevice : public core::Interface, public core::Unmovable
             asset::VkExtent3D minImageTransferGranularity;
         };
 
+        struct APIVersion
+        {
+          uint32_t major : 5;
+          uint32_t minor : 5;
+          uint32_t patch : 22;
+        };
+
         const SLimits& getLimits() const { return m_limits; }
         const SFeatures& getFeatures() const { return m_features; }
         const SMemoryProperties& getMemoryProperties() const { return m_memoryProperties; }
+        const APIVersion& getAPIVersion() const { return m_apiVersion; }
 
         // these are the defines which shall be added to any IGPUShader which has its source as GLSL
         inline core::SRange<const char* const> getExtraGLSLDefines() const
@@ -402,6 +410,7 @@ class IPhysicalDevice : public core::Interface, public core::Unmovable
         SLimits m_limits;
         SFeatures m_features;
         SMemoryProperties m_memoryProperties;
+        APIVersion m_apiVersion;
         using qfam_props_array_t = core::smart_refctd_dynamic_array<SQueueFamilyProperties>;
         qfam_props_array_t m_qfamProperties;
 
diff --git a/src/nbl/video/CVulkanCommon.h b/src/nbl/video/CVulkanCommon.h
@@ -5,6 +5,8 @@
 namespace nbl::video
 {
 
+static constexpr uint32_t MinimumVulkanApiVersion = VK_MAKE_API_VERSION(0, 1, 1, 0);
+
 static inline asset::E_FORMAT getFormatFromVkFormat(VkFormat in)
 {
     switch (in)
diff --git a/src/nbl/video/CVulkanConnection.cpp b/src/nbl/video/CVulkanConnection.cpp
@@ -175,12 +175,17 @@ namespace nbl::video
             debugMessengerCreateInfo.pfnUserCallback = CVulkanDebugCallback::defaultCallback;
             debugMessengerCreateInfo.pUserData = debugCallback.get();
         }
+        
+        uint32_t instanceApiVersion = MinimumVulkanApiVersion;
+        vkEnumerateInstanceVersion(&instanceApiVersion); // Get Highest
+        if(instanceApiVersion < MinimumVulkanApiVersion)
+        {
+            assert(false);
+            return nullptr;
+        }
 
         VkInstance vk_instance;
         {
-            uint32_t instanceApiVersion = VK_MAKE_API_VERSION(0, 1, 1, 0);
-            vkEnumerateInstanceVersion(&instanceApiVersion);
-
             VkApplicationInfo applicationInfo = { VK_STRUCTURE_TYPE_APPLICATION_INFO };
             applicationInfo.pNext = nullptr; // pNext must be NULL
             applicationInfo.pApplicationName = appName;
@@ -242,7 +247,7 @@ namespace nbl::video
             physicalDevices.emplace_back(std::make_unique<CVulkanPhysicalDevice>(
                 core::smart_refctd_ptr(sys),
                 core::make_smart_refctd_ptr<asset::IGLSLCompiler>(sys.get()),
-                api.get(), api->m_rdoc_api, vk_physicalDevices[i], vk_instance));
+                api.get(), api->m_rdoc_api, vk_physicalDevices[i], vk_instance, instanceApiVersion));
 
         }
 
diff --git a/src/nbl/video/CVulkanPhysicalDevice.h b/src/nbl/video/CVulkanPhysicalDevice.h
@@ -12,7 +12,7 @@ namespace nbl::video
 class CVulkanPhysicalDevice final : public IPhysicalDevice
 {
 public:
-    CVulkanPhysicalDevice(core::smart_refctd_ptr<system::ISystem>&& sys, core::smart_refctd_ptr<asset::IGLSLCompiler>&& glslc, IAPIConnection* api, renderdoc_api_t* rdoc, VkPhysicalDevice vk_physicalDevice, VkInstance vk_instance)
+    CVulkanPhysicalDevice(core::smart_refctd_ptr<system::ISystem>&& sys, core::smart_refctd_ptr<asset::IGLSLCompiler>&& glslc, IAPIConnection* api, renderdoc_api_t* rdoc, VkPhysicalDevice vk_physicalDevice, VkInstance vk_instance, uint32_t instanceApiVersion)
         : IPhysicalDevice(std::move(sys),std::move(glslc)), m_api(api), m_rdoc_api(rdoc), m_vkPhysicalDevice(vk_physicalDevice), m_vkInstance(vk_instance)
     {
         // Get Supported Extensions
@@ -80,21 +80,38 @@ class CVulkanPhysicalDevice final : public IPhysicalDevice
             constexpr auto beefyGPUWorkgroupMaxOccupancy = 256u; // TODO: find a way to query and report this somehow, persistent threads are very useful!
             m_limits.maxResidentInvocations = beefyGPUWorkgroupMaxOccupancy*m_limits.maxOptimallyResidentWorkgroupInvocations;
 
+            
+            /*
+                [NO NABALA SUPPORT] Vulkan 1.0 implementation must support the 1.0 version of SPIR-V and the 1.0 version of the SPIR-V Extended Instructions for GLSL. If the VK_KHR_spirv_1_4 extension is enabled, the implementation must additionally support the 1.4 version of SPIR-V.
+                A Vulkan 1.1 implementation must support the 1.0, 1.1, 1.2, and 1.3 versions of SPIR-V and the 1.0 version of the SPIR-V Extended Instructions for GLSL.
+                A Vulkan 1.2 implementation must support the 1.0, 1.1, 1.2, 1.3, 1.4, and 1.5 versions of SPIR-V and the 1.0 version of the SPIR-V Extended Instructions for GLSL.
+            */
+            
+            uint32_t apiVersion = std::min(instanceApiVersion, deviceProperties.properties.apiVersion);
+            assert(apiVersion >= MinimumVulkanApiVersion);
             m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_3;
 
-            switch (VK_API_VERSION_MINOR(deviceProperties.properties.apiVersion))
+            switch (VK_API_VERSION_MINOR(apiVersion))
             {
             case 0:
-                m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_0; break;
+                m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_0; 
+                assert(false);
+                break;
             case 1:
-                m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_3; break;
+                m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_3;
+                break;
             case 2:
-                m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_5; break;
+                m_limits.spirvVersion = asset::IGLSLCompiler::ESV_1_5;
+                break;
             default:
                 _NBL_DEBUG_BREAK_IF("Invalid Vulkan minor version!");
                 break;
             }
 
+            m_apiVersion.major = VK_API_VERSION_MAJOR(apiVersion);
+            m_apiVersion.minor = VK_API_VERSION_MINOR(apiVersion);
+            m_apiVersion.patch = VK_API_VERSION_PATCH(apiVersion);
+
             // AccelerationStructure
             if (m_availableFeatureSet.find(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME) != m_availableFeatureSet.end())
             {
diff --git a/src/nbl/video/IOpenGL_PhysicalDeviceBase.h b/src/nbl/video/IOpenGL_PhysicalDeviceBase.h
@@ -22,9 +22,9 @@ namespace nbl::video
 template <typename LogicalDeviceType>
 class IOpenGL_PhysicalDeviceBase : public IPhysicalDevice
 {
-    using function_table_t = typename LogicalDeviceType::FunctionTableType;
-    static inline constexpr EGLint EGL_API_TYPE = function_table_t::EGL_API_TYPE;
-    static inline constexpr bool IsGLES = (EGL_API_TYPE == EGL_OPENGL_ES_API);
+	using function_table_t = typename LogicalDeviceType::FunctionTableType;
+	static inline constexpr EGLint EGL_API_TYPE = function_table_t::EGL_API_TYPE;
+	static inline constexpr bool IsGLES = (EGL_API_TYPE == EGL_OPENGL_ES_API);
 
 	static inline constexpr uint32_t MaxQueues = 8u;
 
@@ -162,17 +162,17 @@ class IOpenGL_PhysicalDeviceBase : public IPhysicalDevice
 	}
 
 public:
-    IOpenGL_PhysicalDeviceBase(IAPIConnection* api, renderdoc_api_t* rdoc, core::smart_refctd_ptr<system::ISystem>&& s, egl::CEGL&& _egl, COpenGLDebugCallback&& _dbgCb, EGLConfig _config, EGLContext ctx, EGLint _major, EGLint _minor)
+	IOpenGL_PhysicalDeviceBase(IAPIConnection* api, renderdoc_api_t* rdoc, core::smart_refctd_ptr<system::ISystem>&& s, egl::CEGL&& _egl, COpenGLDebugCallback&& _dbgCb, EGLConfig _config, EGLContext ctx, EGLint _major, EGLint _minor)
 		: IPhysicalDevice(std::move(s),core::make_smart_refctd_ptr<asset::IGLSLCompiler>(s.get())), m_api(api), m_rdoc_api(rdoc), m_egl(std::move(_egl)), m_dbgCb(std::move(_dbgCb)), m_config(_config), m_gl_major(_major), m_gl_minor(_minor)
-    {
-        // OpenGL backend emulates presence of just one queue family with all capabilities (graphics, compute, transfer, ... what about sparse binding?)
-        SQueueFamilyProperties qprops;
-        qprops.queueFlags = core::bitflag(EQF_GRAPHICS_BIT)|EQF_COMPUTE_BIT|EQF_TRANSFER_BIT;
-        qprops.queueCount = MaxQueues;
-        qprops.timestampValidBits = 30u; // ??? TODO: glGetQueryiv(GL_TIMESTAMP,GL_QUERY_COUNTER_BITS,&qprops.timestampValidBits)
-        qprops.minImageTransferGranularity = { 1u,1u,1u };
+	{
+		// OpenGL backend emulates presence of just one queue family with all capabilities (graphics, compute, transfer, ... what about sparse binding?)
+		SQueueFamilyProperties qprops;
+		qprops.queueFlags = core::bitflag(EQF_GRAPHICS_BIT)|EQF_COMPUTE_BIT|EQF_TRANSFER_BIT;
+		qprops.queueCount = MaxQueues;
+		qprops.timestampValidBits = 30u; // ??? TODO: glGetQueryiv(GL_TIMESTAMP,GL_QUERY_COUNTER_BITS,&qprops.timestampValidBits)
+		qprops.minImageTransferGranularity = { 1u,1u,1u };
 
-        m_qfamProperties = core::make_refctd_dynamic_array<qfam_props_array_t>(1u, qprops);
+		m_qfamProperties = core::make_refctd_dynamic_array<qfam_props_array_t>(1u, qprops);
 
 		m_egl.call.peglBindAPI(EGL_API_TYPE);
 
@@ -492,8 +492,17 @@ class IOpenGL_PhysicalDeviceBase : public IPhysicalDevice
 			}
 		}
 		
+		int majorVer = 0;
+		int minorVer = 0;
+		GetIntegerv(GL_MAJOR_VERSION, &majorVer);
+		GetIntegerv(GL_MINOR_VERSION, &minorVer);
+		m_apiVersion.major = majorVer;
+		m_apiVersion.minor = minorVer;
+		m_apiVersion.patch = 0u;
+
+
 		std::ostringstream pool;
-        addCommonGLSLDefines(pool,runningInRenderDoc);
+		addCommonGLSLDefines(pool,runningInRenderDoc);
 		{
 			std::string define;
 			for (size_t j=0ull; j<std::extent<decltype(COpenGLFeatureMap::m_GLSLExtensions)>::value; ++j)
@@ -507,13 +516,13 @@ class IOpenGL_PhysicalDeviceBase : public IPhysicalDevice
 				}
 			}
 		}
-        finalizeGLSLDefinePool(std::move(pool));
+		finalizeGLSLDefinePool(std::move(pool));
 
 		// we dont need this any more
 		m_egl.call.peglMakeCurrent(m_egl.display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 		m_egl.call.peglDestroyContext(m_egl.display, ctx);
 		m_egl.call.peglDestroySurface(m_egl.display, pbuf);
-    }
+	}
 
 	IDebugCallback* getDebugCallback()
 	{
@@ -530,11 +539,11 @@ class IOpenGL_PhysicalDeviceBase : public IPhysicalDevice
 
 	IAPIConnection* m_api; // dumb pointer to avoid circ ref
 	renderdoc_api_t* m_rdoc_api;
-    egl::CEGL m_egl;
+	egl::CEGL m_egl;
 	COpenGLDebugCallback m_dbgCb;
 
-    EGLConfig m_config;
-    EGLint m_gl_major, m_gl_minor;
+	EGLConfig m_config;
+	EGLint m_gl_major, m_gl_minor;
 
 	COpenGLFeatureMap m_glfeatures;
 };

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@`
`5`	`5`	`namespace nbl::video`
`6`	`6`	`{`
`7`	`7`
	`8`	`+static constexpr uint32_t MinimumVulkanApiVersion = VK_MAKE_API_VERSION(0, 1, 1, 0);`
	`9`	`+`
`8`	`10`	`static inline asset::E_FORMAT getFormatFromVkFormat(VkFormat in)`
`9`	`11`	`{`
`10`	`12`	`switch (in)`