Merge pull request #597 from Devsh-Graphics-Programming/examples_rewrite

Examples Rewrite

Author: AnastaZIuk

3rdparty/nbl_spirv_cross

@@ -278,8 +278,9 @@ class IDescriptorSetLayout : public virtual core::IReferenceCounted
 		{
 			bindings[i].binding = i;
 			bindings[i].type = type;
-			bindings[i].count = counts ? counts[i]:1u;
+			bindings[i].createFlags = SBinding::E_CREATE_FLAGS::ECF_NONE;
 			bindings[i].stageFlags = stageAccessFlags ? stageAccessFlags[i]:asset::IShader::ESS_ALL;
+			bindings[i].count = counts ? counts[i]:1u;
 			bindings[i].samplers = nullptr;
 		}
 	}

examples_tests

@@ -33,9 +33,36 @@ namespace nbl::asset
 class NBL_API2 CSPIRVIntrospector : public core::Uncopyable
 {
 	public:
-
-		class NBL_API2 CIntrospectionData : public core::IReferenceCounted
+		static IDescriptor::E_TYPE resType2descType(E_SHADER_RESOURCE_TYPE _t)
 		{
+			switch (_t)
+			{
+				case ESRT_COMBINED_IMAGE_SAMPLER:
+					return IDescriptor::E_TYPE::ET_COMBINED_IMAGE_SAMPLER;
+					break;
+				case ESRT_STORAGE_IMAGE:
+					return IDescriptor::E_TYPE::ET_STORAGE_IMAGE;
+					break;
+				case ESRT_UNIFORM_TEXEL_BUFFER:
+					return IDescriptor::E_TYPE::ET_UNIFORM_TEXEL_BUFFER;
+					break;
+				case ESRT_STORAGE_TEXEL_BUFFER:
+					return IDescriptor::E_TYPE::ET_STORAGE_TEXEL_BUFFER;
+					break;
+				case ESRT_UNIFORM_BUFFER:
+					return IDescriptor::E_TYPE::ET_UNIFORM_BUFFER;
+					break;
+				case ESRT_STORAGE_BUFFER:
+					return IDescriptor::E_TYPE::ET_STORAGE_BUFFER;
+					break;
+				default:
+					break;
+			}
+			return IDescriptor::E_TYPE::ET_COUNT;
+		}
+
+	class NBL_API2 CIntrospectionData : public core::IReferenceCounted
+	{
 		protected:
 			~CIntrospectionData();
 
@@ -64,6 +91,7 @@ class NBL_API2 CSPIRVIntrospector : public core::Uncopyable
 
 			struct {
 				bool present;
+				core::string name;
 				SShaderPushConstant info;
 			} pushConstant;
 

include/nbl/asset/IDescriptorSetLayout.h

@@ -137,9 +137,6 @@ struct SShaderMemoryBlock
 
     SMember::SMembers members;
 
-    //! Note: for SSBOs and UBOs it's the block name, but for push_constant it's the instance name.
-    std::string name;
-
     //! size!=rtSizedArrayOneElementSize implies that last member is rutime-sized array (e.g. buffer SSBO { float buf[]; }).
     //! Use getRuntimeSize for size of the struct with assumption of passed number of elements.
     size_t size;
@@ -174,6 +171,8 @@ struct SShaderPushConstant : public impl::SShaderMemoryBlock
 
 struct SShaderResourceVariant
 {
+    //! Note: for SSBOs and UBOs it's the block name, but for push_constant it's the instance name.
+    std::string name;
     //! binding
     uint32_t binding;
     E_SHADER_RESOURCE_TYPE type;
@@ -186,6 +185,7 @@ struct SShaderResourceVariant
     //! Then user can look up default value of this specialization constant in SIntrospectionData::specConstants.
     bool descCountIsSpecConstant;
 
+
     template<E_SHADER_RESOURCE_TYPE restype>
     SShaderResource<restype>& get() { return reinterpret_cast<SShaderResource<restype>&>(variant); }
     template<E_SHADER_RESOURCE_TYPE restype>

include/nbl/asset/utils/CSPIRVIntrospector.h

@@ -33,9 +33,6 @@ using add_pointer = std::add_pointer<T>;
 #define NBL_REF_ARG(T) typename nbl::hlsl::add_reference<T>::type
 #define NBL_CONST_REF_ARG(T) typename nbl::hlsl::add_reference<std::add_const_t<T>>::type
 
-// it includes vector and matrix
-#include <nbl/builtin/hlsl/cpp_compat/intrinsics.h>
-
 #else
 
 #define ARROW .arrow().
@@ -68,4 +65,7 @@ struct add_pointer
 
 #endif
 
+// it includes vector and matrix
+#include <nbl/builtin/hlsl/cpp_compat/intrinsics.h>
+
 #endif

include/nbl/asset/utils/ShaderRes.h

@@ -3,10 +3,11 @@
 
 #include <nbl/builtin/hlsl/cpp_compat/vector.hlsl>
 
-#ifndef __HLSL_VERSION
-namespace nbl::hlsl
+namespace nbl
 {
-
+namespace hlsl
+{
+#ifndef __HLSL_VERSION
 template<typename T, uint16_t N, uint16_t M>
 struct matrix final : private glm::mat<N,M,T>
 {
@@ -55,12 +56,13 @@ struct matrix final : private glm::mat<N,M,T>
         return glm::transpose(reinterpret_cast<Base const&>(m));
     }
 };
+#endif
 
 
 #define NBL_TYPEDEF_MATRICES_FOR_ROW(T, R) \
-using T ## R ## x4 = matrix<T, R, 4>; \
-using T ## R ## x3 = matrix<T, R, 3>; \
-using T ## R ## x2 = matrix<T, R, 2>; 
+typedef matrix<T, R, 4> T ## R ## x4; \
+typedef matrix<T, R, 3> T ## R ## x3; \
+typedef matrix<T, R, 2> T ## R ## x2; 
 
 #define NBL_TYPEDEF_MATRICES_FOR_SCALAR(T) \
     NBL_TYPEDEF_MATRICES_FOR_ROW(T, 4) \
@@ -80,8 +82,7 @@ NBL_TYPEDEF_MATRICES_FOR_SCALAR(float64_t);
 
 #undef NBL_TYPEDEF_MATRICES_FOR_ROW
 #undef NBL_TYPEDEF_MATRICES_FOR_SCALAR
-
 }
-#endif
+}
 
 #endif

include/nbl/builtin/hlsl/cpp_compat.hlsl

@@ -1,56 +1,21 @@
 #ifndef _NBL_BUILTIN_HLSL_CPP_COMPAT_VECTOR_INCLUDED_
 #define _NBL_BUILTIN_HLSL_CPP_COMPAT_VECTOR_INCLUDED_
 
+// stuff for C++
 #ifndef __HLSL_VERSION 
+#include <stdint.h>
+
+#include <half.h>
 
 #define GLM_FORCE_SWIZZLE
 #include <glm/glm.hpp>
 #include <glm/detail/_swizzle.hpp>
-#include <stdint.h>
-#include <half.h>
 
 namespace nbl::hlsl
 {
-
 template<typename T, uint16_t N>
 using vector = glm::vec<N, T>;
 
-// ideally we should have sized bools, but no idea what they'd be
-using bool4 = vector<bool, 4>;
-using bool3 = vector<bool, 3>;
-using bool2 = vector<bool, 2>;
-using bool1 = vector<bool, 1>;
-
-using int32_t4 = vector<int32_t, 4>;
-using int32_t3 = vector<int32_t, 3>;
-using int32_t2 = vector<int32_t, 2>;
-using int32_t1 = vector<int32_t, 1>;
-
-using uint32_t4 = vector<uint32_t, 4>;
-using uint32_t3 = vector<uint32_t, 3>;
-using uint32_t2 = vector<uint32_t, 2>;
-using uint32_t1 = vector<uint32_t, 1>;
-
-// TODO: halfN -> needs class implementation or C++23 std:float16_t
-
-using float16_t = half;
-using float16_t4 = vector<float16_t, 4>;
-using float16_t3 = vector<float16_t, 3>;
-using float16_t2 = vector<float16_t, 2>;
-using float16_t1 = vector<float16_t, 1>;
-
-using float32_t = float;
-using float32_t4 = vector<float32_t, 4>;
-using float32_t3 = vector<float32_t, 3>;
-using float32_t2 = vector<float32_t, 2>;
-using float32_t1 = vector<float32_t, 1>;
-
-using float64_t = double;
-using float64_t4 = vector<float64_t, 4>;
-using float64_t3 = vector<float64_t, 3>;
-using float64_t2 = vector<float64_t, 2>;
-using float64_t1 = vector<float64_t, 1>;
-
 template<typename T, uint16_t N>
 glm::vec<N, bool> operator<(const glm::vec<N, T>& lhs, const glm::vec<N, T>& rhs)
 {
@@ -77,4 +42,38 @@ glm::vec<N, bool> operator>=(const glm::vec<N, T>& lhs, const glm::vec<N, T>& rh
 }
 #endif
 
+// general typedefs for both langs
+namespace nbl
+{
+namespace hlsl
+{
+typedef half float16_t;
+typedef float float32_t;
+typedef double float64_t;
+
+#define NBL_TYPEDEF_VECTORS(T) \
+typedef vector<T,4> T ## 4; \
+typedef vector<T,3> T ## 3; \
+typedef vector<T,2> T ## 2; \
+typedef vector<T,1> T ## 1
+
+// ideally we should have sized bools, but no idea what they'd be
+NBL_TYPEDEF_VECTORS(bool);
+
+NBL_TYPEDEF_VECTORS(int16_t);
+NBL_TYPEDEF_VECTORS(int32_t);
+NBL_TYPEDEF_VECTORS(int64_t);
+
+NBL_TYPEDEF_VECTORS(uint16_t);
+NBL_TYPEDEF_VECTORS(uint32_t);
+NBL_TYPEDEF_VECTORS(uint64_t);
+
+NBL_TYPEDEF_VECTORS(float16_t);
+NBL_TYPEDEF_VECTORS(float32_t);
+NBL_TYPEDEF_VECTORS(float64_t);
+
+#undef NBL_TYPEDEF_VECTORS
+}
+}
+
 #endif

include/nbl/builtin/hlsl/cpp_compat/matrix.hlsl

@@ -10,7 +10,7 @@
 // C++ headers
 #ifndef __HLSL_VERSION
 #include <limits>
-#include <openexr/IlmBase/Imath/ImathHalfLimits.h>
+#include "halfLimits.h"
 #endif
 
 /*
@@ -262,9 +262,9 @@ struct numeric_limits : impl::numeric_limits<T> {};
 
 
 template<class T>
-struct numeric_limits : std::conditional_t<std::is_same_v<T,float16_t>,IMATH_INTERNAL_NAMESPACE::limits<T>,std::numeric_limits<T>>
+struct numeric_limits : std::numeric_limits<T>
 {
-    using base = std::conditional_t<std::is_same_v<T,float16_t>,IMATH_INTERNAL_NAMESPACE::limits<T>,std::numeric_limits<T>>;
+    using base = std::numeric_limits<T>;
     using uint_type = std::remove_cvref_t<decltype(impl::num_traits<T>::infinity)>;
 
     NBL_CONSTEXPR_STATIC_INLINE T min = base::min();

include/nbl/builtin/hlsl/cpp_compat/vector.hlsl

@@ -124,7 +124,9 @@ template< class U, class T >
 smart_refctd_ptr<U> smart_refctd_ptr_static_cast(smart_refctd_ptr<T>&& smart_ptr);
 
 template< class U, class T >
-smart_refctd_ptr<U> move_and_static_cast(smart_refctd_ptr<T>&& smart_ptr);
+smart_refctd_ptr<U> move_and_static_cast(smart_refctd_ptr<T>& smart_ptr);
+template< class U, class T >
+smart_refctd_ptr<U> move_and_static_cast(smart_refctd_ptr<T>&& smart_ptr) {return move_and_static_cast<U,T>(smart_ptr);}
 
 
 template< class U, class T >
@@ -133,7 +135,9 @@ template< class U, class T >
 smart_refctd_ptr<U> smart_refctd_ptr_dynamic_cast(smart_refctd_ptr<T>&& smart_ptr);
 
 template< class U, class T >
-smart_refctd_ptr<U> move_and_dynamic_cast(smart_refctd_ptr<T>&& smart_ptr);
+smart_refctd_ptr<U> move_and_dynamic_cast(smart_refctd_ptr<T>& smart_ptr);
+template< class U, class T >
+smart_refctd_ptr<U> move_and_dynamic_cast(smart_refctd_ptr<T>&& smart_ptr) {return move_and_dynamic_cast<U,T>(smart_ptr);}
 
 } // end namespace nbl::core