Resolved conflicts, merged master

Author: Przemog1

.gitmodules

@@ -78,9 +78,6 @@
 	path = 3rdparty/dxc/dxc
 	url = git@github.com:Devsh-Graphics-Programming/DirectXShaderCompiler.git
 	branch = devshFixes
-[submodule "3rdparty/tcpp"]
-	path = 3rdparty/tcpp
-	url = git@github.com:Erfan-Ahmadi/tcpp.git
 [submodule "3rdparty/imgui"]
 	path = 3rdparty/imgui
 	url = git@github.com:Devsh-Graphics-Programming/imgui.git

3rdparty/tcpp

@@ -10,7 +10,7 @@
 
 #ifdef _NBL_PLATFORM_WINDOWS_
 
-namespace nbl::asset::hlsl::impl
+namespace nbl::asset::impl
 {
 	class DXC;
 }
@@ -53,7 +53,7 @@ class NBL_API2 CHLSLCompiler final : public IShaderCompiler
 
 		// This can't be a unique_ptr due to it being an undefined type 
 		// when Nabla is used as a lib
-		nbl::asset::hlsl::impl::DXC* m_dxcCompilerTypes;
+		nbl::asset::impl::DXC* m_dxcCompilerTypes;
 
 		static CHLSLCompiler::SOptions option_cast(const IShaderCompiler::SCompilerOptions& options)
 		{

examples_tests

@@ -26,75 +26,81 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 
 		class NBL_API2 IIncludeLoader : public core::IReferenceCounted
 		{
-		public:
-			virtual std::optional<std::string> getInclude(const system::path& searchPath, const std::string& includeName) const = 0;
+			public:
+				struct found_t
+				{
+					system::path absolutePath = {};
+					std::string contents = {};
+
+					explicit inline operator bool() const {return !absolutePath.empty();}
+				};
+				virtual found_t getInclude(const system::path& searchPath, const std::string& includeName) const = 0;
 		};
 
 		class NBL_API2 IIncludeGenerator : public core::IReferenceCounted
 		{
-		public:
-			// ! if includeName doesn't begin with prefix from `getPrefix` this function will return an empty string
-			virtual std::optional<std::string> getInclude(const std::string& includeName) const;
+			public:
+				// ! if includeName doesn't begin with prefix from `getPrefix` this function will return an empty string
+				virtual IIncludeLoader::found_t getInclude(const std::string& includeName) const;
 
-			virtual std::string_view getPrefix() const = 0;
+				virtual std::string_view getPrefix() const = 0;
 
-		protected:
+			protected:
 
-			using HandleFunc_t = std::function<std::string(const std::string&)>;
-			virtual core::vector<std::pair<std::regex, HandleFunc_t>> getBuiltinNamesToFunctionMapping() const = 0;
+				using HandleFunc_t = std::function<std::string(const std::string&)>;
+				virtual core::vector<std::pair<std::regex,HandleFunc_t>> getBuiltinNamesToFunctionMapping() const = 0;
 
-			// ! Parses arguments from include path
-			// ! template is path/to/shader.hlsl/arg0/arg1/...
-			static core::vector<std::string> parseArgumentsFromPath(const std::string& _path);
+				// ! Parses arguments from include path
+				// ! template is path/to/shader.hlsl/arg0/arg1/...
+				static core::vector<std::string> parseArgumentsFromPath(const std::string& _path);
 		};
 
 		class NBL_API2 CFileSystemIncludeLoader : public IIncludeLoader
 		{
-		public:
-			CFileSystemIncludeLoader(core::smart_refctd_ptr<system::ISystem>&& system);
+			public:
+				CFileSystemIncludeLoader(core::smart_refctd_ptr<system::ISystem>&& system);
 
-			std::optional<std::string> getInclude(const system::path& searchPath, const std::string& includeName) const override;
+				IIncludeLoader::found_t getInclude(const system::path& searchPath, const std::string& includeName) const override;
 
-		protected:
-			core::smart_refctd_ptr<system::ISystem> m_system;
+			protected:
+				core::smart_refctd_ptr<system::ISystem> m_system;
 		};
 
 		class NBL_API2 CIncludeFinder : public core::IReferenceCounted
 		{
-		public:
-			CIncludeFinder(core::smart_refctd_ptr<system::ISystem>&& system);
-
-			// ! includes within <>
-			// @param requestingSourceDir: the directory where the incude was requested
-			// @param includeName: the string within <> of the include preprocessing directive
-			std::optional<std::string> getIncludeStandard(const system::path& requestingSourceDir, const std::string& includeName) const;
+			public:
+				CIncludeFinder(core::smart_refctd_ptr<system::ISystem>&& system);
 
-			// ! includes within ""
-			// @param requestingSourceDir: the directory where the incude was requested
-			// @param includeName: the string within "" of the include preprocessing directive
-			std::optional<std::string> getIncludeRelative(const system::path& requestingSourceDir, const std::string& includeName) const;
+				// ! includes within <>
+				// @param requestingSourceDir: the directory where the incude was requested
+				// @param includeName: the string within <> of the include preprocessing directive
+				IIncludeLoader::found_t getIncludeStandard(const system::path& requestingSourceDir, const std::string& includeName) const;
 
-			inline core::smart_refctd_ptr<CFileSystemIncludeLoader> getDefaultFileSystemLoader() const { return m_defaultFileSystemLoader; }
+				// ! includes within ""
+				// @param requestingSourceDir: the directory where the incude was requested
+				// @param includeName: the string within "" of the include preprocessing directive
+				IIncludeLoader::found_t getIncludeRelative(const system::path& requestingSourceDir, const std::string& includeName) const;
 
-			void addSearchPath(const std::string& searchPath, const core::smart_refctd_ptr<IIncludeLoader>& loader);
+				inline core::smart_refctd_ptr<CFileSystemIncludeLoader> getDefaultFileSystemLoader() const { return m_defaultFileSystemLoader; }
 
-			void addGenerator(const core::smart_refctd_ptr<IIncludeGenerator>& generator);
+				void addSearchPath(const std::string& searchPath, const core::smart_refctd_ptr<IIncludeLoader>& loader);
 
-		protected:
+				void addGenerator(const core::smart_refctd_ptr<IIncludeGenerator>& generator);
 
-			std::optional<std::string> trySearchPaths(const std::string& includeName) const;
+			protected:
+				IIncludeLoader::found_t trySearchPaths(const std::string& includeName) const;
 
-			std::optional<std::string> tryIncludeGenerators(const std::string& includeName) const;
+				IIncludeLoader::found_t tryIncludeGenerators(const std::string& includeName) const;
 
-			struct LoaderSearchPath
-			{
-				core::smart_refctd_ptr<IIncludeLoader> loader = nullptr;
-				std::string searchPath = {};
-			};
+				struct LoaderSearchPath
+				{
+					core::smart_refctd_ptr<IIncludeLoader> loader = nullptr;
+					std::string searchPath = {};
+				};
 
-			std::vector<LoaderSearchPath> m_loaders;
-			std::vector<core::smart_refctd_ptr<IIncludeGenerator>> m_generators;
-			core::smart_refctd_ptr<CFileSystemIncludeLoader> m_defaultFileSystemLoader;
+				std::vector<LoaderSearchPath> m_loaders;
+				std::vector<core::smart_refctd_ptr<IIncludeGenerator>> m_generators;
+				core::smart_refctd_ptr<CFileSystemIncludeLoader> m_defaultFileSystemLoader;
 		};
 
 		enum class E_SPIRV_VERSION : uint32_t
@@ -115,8 +121,12 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 			std::string_view sourceIdentifier = "";
 			system::logger_opt_ptr logger = nullptr;
 			const CIncludeFinder* includeFinder = nullptr;
-			uint32_t maxSelfInclusionCount = 4u;
-			core::SRange<const char* const> extraDefines = {nullptr, nullptr};
+			struct SMacroDefinition
+			{
+				std::string_view identifier;
+				std::string_view definition;
+			};
+			std::span<const SMacroDefinition> extraDefines = {};
 		};
 
 		// https://github.com/microsoft/DirectXShaderCompiler/blob/main/docs/SPIR-V.rst#debugging
@@ -290,8 +300,6 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 
 		virtual void insertIntoStart(std::string& code, std::ostringstream&& ins) const = 0;
 
-		void insertExtraDefines(std::string& code, const core::SRange<const char* const>& defines) const;
-
 		core::smart_refctd_ptr<system::ISystem> m_system;
 	private:
 		core::smart_refctd_ptr<CIncludeFinder> m_defaultIncludeFinder;

include/nbl/asset/utils/CHLSLCompiler.h

@@ -0,0 +1,22 @@
+// Copyright (C) 2023 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine".
+// For conditions of distribution and use, see copyright notice in nabla.h
+#ifndef _NBL_BUILTIN_HLSL_DEVICE_CAPABILITIES_TRAITS_INCLUDED_
+#define _NBL_BUILTIN_HLSL_DEVICE_CAPABILITIES_TRAITS_INCLUDED_
+
+#include <nbl/builtin/hlsl/member_test_macros.hlsl>
+
+#ifdef __HLSL_VERSION
+namespace nbl
+{
+namespace hlsl
+{
+template<typename device_capabilities>
+struct device_capabilities_traits
+{
+    // TODO: check for members and default them to sane things, only do the 5 members in CJITIncludeLoader.cpp struct, we'll do the rest on `vulkan_1_3` branch with Nahim
+};
+}
+}
+#endif
+#endif

include/nbl/asset/utils/IShaderCompiler.h

@@ -19,7 +19,6 @@ namespace hlsl
 namespace spirv
 {
 
-#pragma region ATOMICS
 template<typename T>
 T atomicAdd([[vk::ext_reference]] T ptr, uint32_t memoryScope, uint32_t memorySemantics, T value);
 template<>
@@ -95,9 +94,9 @@ int32_t atomicCompSwap([[vk::ext_reference]] int32_t ptr, uint32_t memoryScope,
 template<>
 [[vk::ext_instruction( spv::OpAtomicCompareExchange )]]
 uint32_t atomicCompSwap([[vk::ext_reference]] uint32_t ptr, uint32_t memoryScope, uint32_t memSemanticsEqual, uint32_t memSemanticsUnequal, uint32_t value, uint32_t comparator);
-#pragma endregion ATOMICS
 
-#pragma region BARRIERS
+
+
 // Memory Semantics link here: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#Memory_Semantics_-id-
 
 // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_memory_semantics_id
@@ -108,16 +107,12 @@ void controlBarrier(uint32_t executionScope, uint32_t memoryScope, uint32_t memo
 
 [[vk::ext_instruction( spv::OpMemoryBarrier )]]
 void memoryBarrier(uint32_t memoryScope, uint32_t memorySemantics);
-#pragma endregion BARRIERS
 
-#pragma region CONVERSION
 
 // Add specializations if you need to emit a `ext_capability` (this means that the instruction needs to forward through an `impl::` struct and so on)
 template<class T, class U>
 [[vk::ext_instruction(spv::OpBitcast)]]
 T bitcast(U);
-
-#pragma endregion CONVERSION
 }
 #endif
 }

include/nbl/builtin/hlsl/device_capabilities_traits.hlsl

@@ -662,16 +662,18 @@ struct unsigned_integer_of_size<8>
 // shoudl really return a std::type_info like struct or something, but no `constexpr` and unsure whether its possible to have a `const static SomeStruct` makes it hard to do...
 #define typeid(expr) (::nbl::hlsl::impl::typeid_t<__decltype(expr)>::value)
 
-#define NBL_REGISTER_OBJ_TYPE(T, A) namespace nbl { namespace hlsl { \
-    namespace impl { template<> struct typeid_t<T> : integral_constant<uint32_t,__COUNTER__> {}; } \ 
+// Found a bug in Boost.Wave, try to avoid multi-line macros https://github.com/boostorg/wave/issues/195
+#define NBL_IMPL_SPECIALIZE_TYPE_ID(T) namespace impl { template<> struct typeid_t<T> : integral_constant<uint32_t,__COUNTER__> {}; }
+
+#define NBL_REGISTER_OBJ_TYPE(T,A) namespace nbl { namespace hlsl { NBL_IMPL_SPECIALIZE_TYPE_ID(T) \
     template<> struct alignment_of<T> : integral_constant<uint32_t,A> {}; \
     template<> struct alignment_of<const T> : integral_constant<uint32_t,A> {}; \
     template<> struct alignment_of<typename impl::add_lvalue_reference<T>::type> : integral_constant<uint32_t,A> {}; \
     template<> struct alignment_of<typename impl::add_lvalue_reference<const T>::type> : integral_constant<uint32_t,A> {}; \
 }}
 
 // TODO: find out how to do it such that we don't get duplicate definition if we use two function identifiers with same signature
-#define NBL_REGISTER_FUN_TYPE(fn) namespace nbl { namespace hlsl { template<> struct typeid_t<__decltype(fn)> : integral_constant<uint32_t,__COUNTER__> {}; }}
+#define NBL_REGISTER_FUN_TYPE(fn) namespace nbl { namespace hlsl { NBL_IMPL_SPECIALIZE_TYPE_ID(__decltype(fn)) }}
 // TODO: ideally we'd like to call NBL_REGISTER_FUN_TYPE under the hood, but we can't right now. Also we have a bigger problem, the passing of the function identifier as the second template parameter doesn't work :(
 /*
 template<> \

include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl

@@ -22,19 +22,19 @@ class CColoredStdoutLoggerANSI : public IThreadsafeLogger
       switch (logLevel)
       {
         case ELL_DEBUG:
-          printf("\x1b[37m%s", str.data()); // White
+          printf("\x1b[37m%s\x1b[0m", str.data()); // White
           break;
         case ELL_INFO:
-          printf("\x1b[37m%s", str.data()); // White
+          printf("\x1b[37m%s\x1b[0m", str.data()); // White
           break;
         case ELL_WARNING:
-          printf("\x1b[33m%s", str.data()); // yellow
+          printf("\x1b[33m%s\x1b[0m", str.data()); // yellow
           break;
         case ELL_ERROR:
-          printf("\x1b[31m%s", str.data()); // red
+          printf("\x1b[31m%s\x1b[0m", str.data()); // red
           break;
         case ELL_PERFORMANCE:
-          printf("\x1b[34m%s", str.data()); // blue
+          printf("\x1b[34m%s\x1b[0m", str.data()); // blue
           break;
         case ELL_NONE:
           assert(false);