first working modules!

Author: Cheaterdev

main.sharpmake.cs

@@ -45,6 +45,9 @@ public Common() : base(typeof(CustomTarget))
         {
             SourceFilesExtensions.Add(".sig");
             SourceFilesExtensions.Add(".hlsl");
+			SourceFilesExtensions.Add(".ixx");
+
+			SourceFilesCompileExtensions.Add(".ixx");
 
             RootPath = @"[project.SharpmakeCsPath]\projects\[project.Name]";
 
@@ -67,6 +70,8 @@ public virtual void ConfigureAll(Configuration conf, CustomTarget target)
             conf.ProjectPath = @"[project.RootPath]";
 
             conf.IncludePaths.Add(SourceRootPath);
+			conf.ExportAdditionalLibrariesEvenForStaticLib = true;
+			conf.PrecompSourceExcludeExtension.Add(".ixx");
 
             conf.Options.Add(Options.Vc.Compiler.CppLanguageStandard.Latest);
             conf.Options.Add(Options.Vc.Compiler.Exceptions.Enable);

sources/Core/Data/Data.h

@@ -1,7 +1,7 @@
 #pragma once
 #include "Debug/Exceptions.h"
 #include "Utils/utils.h"
-
+#include "Serialization/serialization.h"
 namespace DataPacker
 {
 
@@ -212,9 +212,7 @@ class Cache
 	}
 
 private:
-	friend class boost::serialization::access;
-	template<class Archive>
-	void serialize(Archive& ar, const unsigned int)
+	SERIALIZE()
 	{
 		ar& NVP(table);
 	}

sources/Core/Events/Events.h

@@ -1,6 +1,8 @@
 #pragma once
 #include "Data/Data.h"
 #include "Serialization/serialization.h"
+
+import Vectors;
 namespace Events
 {
 

sources/Core/Math/Constants.h

@@ -0,0 +1,108 @@
+module;
+#include <cmath>
+export module Constants;
+
+export
+{
+	namespace Math
+	{
+		// precision constants
+
+		const float eps2 = 0.001f;
+		const float eps4 = 0.00001f;
+		const float eps6 = 0.0000001f;
+		const float eps8 = 0.000000001f;
+		const float eps10 = 0.00000000001f;
+		const float eps12 = 0.0000000000001f;
+
+		// math constants
+		const float pi = 3.141592653589793238462643383279f;
+		const float e = 2.718281828459045235360287471352f;
+		const float radToDeg = 180 / pi;
+		const float degToRad = pi / 180;
+
+		const float m_pi_2 = pi / 2.0f;
+		const float m_2_pi = pi * 2.0f;
+
+
+		// math special functions
+		template<class T>
+		T clamp(const T& n, const T& min, const T& max)
+		{
+			return std::min(std::max(n, min), max);
+		}
+
+		template<class T>
+		T saturate(const T& n)
+		{
+			return clamp(n, static_cast<T>(0), static_cast<T>(1));
+		}
+
+
+		inline float sin(const float angle)
+		{
+			return sinf(angle);
+		}
+
+		inline float cos(const float angle)
+		{
+			return cosf(angle);
+		}
+
+		inline float asin(const float angle)
+		{
+			return asinf(angle);
+		}
+
+		inline float acos(const float angle)
+		{
+			return acosf(angle);
+		}
+
+
+		template <class A, class B>
+		auto pow(A a, B b)
+		{
+			return std::pow(a, b);
+		}
+
+		template <class A>
+		auto sqrt(A a)
+		{
+			return std::sqrt(a);
+		}
+
+
+		template <typename T> __forceinline T AlignUpWithMask(T value, size_t mask)
+		{
+			return (T)(((size_t)value + mask) & ~mask);
+		}
+
+		template <typename T> __forceinline T AlignDownWithMask(T value, size_t mask)
+		{
+			return (T)((size_t)value & ~mask);
+		}
+
+		template <typename T> __forceinline T AlignUp(T value, size_t alignment)
+		{
+			return AlignUpWithMask(value, alignment - 1);
+		}
+
+		template <typename T> __forceinline T roundUp(T num, size_t factor) { return num + factor - 1 - (num + factor - 1) % factor; }
+
+		template <typename T> __forceinline T AlignDown(T value, size_t alignment)
+		{
+			return AlignDownWithMask(value, alignment - 1);
+		}
+
+		template <typename T> __forceinline bool IsAligned(T value, size_t alignment)
+		{
+			return 0 == (size_t(value) & (alignment - 1));
+		}
+
+		template <typename T> __forceinline T DivideByMultiple(T value, size_t alignment)
+		{
+			return (T)((value + alignment - 1) / alignment);
+		}
+	}
+}

sources/Core/Math/Constants.ixx

@@ -1,6 +1,8 @@
-#include "Constants.h"
-#include "Types/Vectors.h"
-#include "Types/Quaternions.h"
-#include "Types/Matrices.h"
+
+import Constants;
+import Vectors;
+import Quaternion;
+import Matrices;
+
 
 #include "Primitives/Intersections.h"

sources/Core/Math/Math.h

@@ -1,7 +1,9 @@
 #pragma once
-#include "../Constants.h"
-#include "../Types/Vectors.h"
-#include "../Types/Matrices.h"
+import Constants;
+import Vectors;
+import Quaternion;
+import Matrices;
+#include "Serialization/serialization.h"
 
 enum class primitive_types
 {