Adds feature check for c++26

modules/common.cmake

@@ -1,6 +1,7 @@
 
-
+include(compiler/features)
 include(helpers)
+include(git/commit)
 
 if ((${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") OR (${CMAKE_CXX_PLATFORM_ID} STREQUAL "MinGW"))
 	include(compiler/gcc)
@@ -22,8 +23,4 @@ elseif (UNIX)
 	include(os/linux)
 else ()
 	message(DEBUG "Unknown Platform")
-endif ()
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" ${CMAKE_MODULE_PATH})
-
-message(DEBUG "Leaving ${CMAKE_CURRENT_LIST_FILE}")
+endif ()

modules/compiler/features.cmake

@@ -0,0 +1,2 @@
+include(features/reflection)
+include(features/c++26)

modules/compiler/flags.cmake

@@ -5,13 +5,17 @@
 		endfunction()
 
 		function(SetFGLFlags TARGET)
-			GET_PROPERTY(FGL_FLAGS GLOBAL PROPERTY FGL_FLAGS)
-			target_compile_options(${TARGET} PUBLIC ${FGL_FLAGS})
-			message("Set target ${TARGET} to use flags\n${FGL_FLAGS}")
+			GET_PROPERTY(FGL_COMPILE_FLAGS GLOBAL PROPERTY FGL_COMPILE_FLAGS)
+			GET_PROPERTY(FGL_LINKS_FLAGS GLOBAL PROPERTY FGL_LINK_FLAGS)
+			target_compile_options(${TARGET} PRIVATE ${FGL_COMPILE_FLAGS})
+			message("Set target ${TARGET} to use flags\n${FGL_COMPILE_FLAGS}")
+			target_link_options(${TARGET} PRIVATE ${FGL_LINK_FLAGS})
 		endfunction()
 
 		function(SetDependencyFlags TARGET)
 			GET_PROPERTY(FGL_CHILD_FLAGS GLOBAL PROPERTY FGL_CHILD_FLAGS)
-			target_compile_options(${TARGET} PUBLIC ${FGL_CHILD_FLAGS})
+			GET_PROPERTY(FGL_LINKS_FLAGS GLOBAL PROPERTY FGL_LINK_FLAGS)
+			target_compile_options(${TARGET} PRIVATE ${FGL_CHILD_FLAGS})
 			message("Set dependency ${TARGET} to use flags\n${FGL_CHILD_FLAGS}")
+			target_link_options(${TARGET} PRIVATE ${FGL_LINK_FLAGS})
 		endfunction()

modules/compiler/gcc.cmake

@@ -103,6 +103,9 @@
 				AppendWarningFlag("-Wuse-after-free") #Warns about accessing a value after calling 'free' on it
 				AppendWarningFlag("-Wuseless-cast") #Warns about a cast that is useless.
 
+				AppendWarningFlag("-Wno-non-virtual-dtor")
+
+				AppendWarningFlag("-Wno-terminate") # Disables -Wterminate errors, These are kinda weird and I tend to use throw inside of dtors with the intent of it terminating after. So we'll just silence them.
 
 				# Starting other weird flags
 				AppendWarningFlag("-fdiagnostics-show-template-tree") # Shows the template diagnostic info as a tree instead.
@@ -112,30 +115,39 @@
 
 				string(TOUPPER ${CMAKE_BUILD_TYPE} UPPER_BUILD_TYPE)
 
-				if (NOT DEFINED STATIC_ANAYLSIS)
-					set(STATIC_ANYLSIS 1)
+				if (DEFINED FGL_ENABLE_UBSAN AND FGL_ENABLE_UBSAN EQUAL 1)
+					list(APPEND FGL_CONFIG "-fsanitize=undefined,address,leak,alignment,bounds,vptr")
+					#					list(APPEND FGL_CONFIG "-fsanitize-trap")
 				endif ()
 
+				if (NOT DEFINED FGL_STATIC_ANALYSIS)
+					set(FGL_STATIC_ANALYSIS 0)
+				endif ()
 
-				#				if (STATIC_ANALYSIS EQUAL 1 AND UPPER_BUILD_TYPE STREQUAL "DEBUG")
-				#					list(APPEND FGL_CONFIG "-fanalyzer")
-				#					if (NOT DEFINED USE_WERROR OR NOT USE_WERROR)
-				#						list(APPEND FGL_CONFIG "-Wanalyzer-too-complex")
-				#					endif ()
-				#				elseif (NOT UPPER_BUILD_TYPE STREQUAL "DEBUG")
-				if (NOT UPPER_BUILD_TYPE STREQUAL "DEBUG")
+				if (FGL_STATIC_ANALYSIS EQUAL 1)
+					list(APPEND FGL_CONFIG "-fanalyzer")
+					#					list(APPEND FGL_CONFIG "-Wanalyzer-too-complex")
+					# Breaks more often then it is helpful
+					list(APPEND FGL_CONFIG "-Wno-analyzer-use-of-uninitialized-value")
+					list(APPEND FGL_CONFIG "-Wno-analyzer-malloc-leak")
+				elseif (NOT UPPER_BUILD_TYPE STREQUAL "DEBUG")
 					list(APPEND FGL_CONFIG "-flto=auto")
 				endif ()
 
 				list(APPEND FGL_CONFIG "-ftree-vectorize")
-				list(APPEND FGL_CONFIG "-fmax-errors=6")
-				LIST(APPEND FGL_CONFIG "-fmodules-ts")
-				LIST(APPEND FGL_CONFIG "-std=c++23")
+				list(APPEND FGL_CONFIG "-fmax-errors=2")
+
+				if (HAS_CPP_REFLECTION)
+					list(APPEND FGL_CONFIG "-freflection")
+				endif ()
+
+				list(APPEND FGL_CONFIG "-fdata-sections")
+				list(APPEND FGL_CONFIG "-ffunction-sections")
 
 				#AppendWarningFlag("-fanalyzer")
 				#AppendWarningFlag("-Wanalyzer-too-complex")
 
-				if (DEFINED USE_WERROR AND USE_WERROR)
+				if (DEFINED FGL_STRICT_WARNINGS AND FGL_STRICT_WARNINGS)
 					list(APPEND FGL_CONFIG "-Werror")
 				endif ()
 
@@ -154,7 +166,6 @@
 				list(APPEND FGL_SHARED_DEBUG "-gdwarf-4")
 				list(APPEND FGL_SHARED_DEBUG "-fvar-tracking-assignments")
 
-
 				# Optimization flags
 				set(FGL_FINAL_FLAGS_RELEASE "-O2;-s;${FGL_GENERAL_OPTIMIZATION_FLAGS};${FGL_SHARED_OPTIMIZATION_FLAGS}") # System agonistc flags
 				set(FGL_FINAL_FLAGS_RELWITHDEBINFO "-O2;${FGL_GENERAL_OPTIMIZATION_FLAGS};${FGL_SHARED_OPTIMIZATION_FLAGS};${FGL_SHARED_DEBUG}")
@@ -163,22 +174,25 @@
 
 				list(APPEND FGL_FLAGS ${FGL_CONFIG})
 				list(APPEND FGL_FLAGS ${FGL_FINAL_FLAGS_${UPPER_BUILD_TYPE}})
-				#				list(APPEND FGL_FLAGS ${FGL_WARNINGS})
+				list(APPEND FGL_FLAGS ${FGL_WARNINGS})
 
 				list(APPEND FGL_CHILD_FLAGS ${FGL_FINAL_FLAGS_${UPPER_BUILD_TYPE}})
 
 				# Final sets
-				#set(FGL_FLAGS "${FGL_CONFIG};${FGL_FINAL_FLAGS_${UPPER_BUILD_TYPE}};${FGL_WARNINGS}") # Flags for our shit
-				#set(FGL_FLAGS "${FGL_OPTIMIZATION_FLAGS_${UPPER_BUILD_TYPE}}" PARENT_SCOPE)
-				#set(FGL_CHILD_FLAGS "${FGL_FINAL_FLAGS_RELEASE}") # Child flags for adding optimization to anything we build ourselves but doesn't follow our standard
+				set(FGL_FLAGS "${FGL_CONFIG};${FGL_FINAL_FLAGS_${UPPER_BUILD_TYPE}};${FGL_WARNINGS}") # Flags for our shit
+				set(FGL_FLAGS "${FGL_OPTIMIZATION_FLAGS_${UPPER_BUILD_TYPE}}" PARENT_SCOPE)
+				set(FGL_CHILD_FLAGS "${FGL_FINAL_FLAGS_RELEASE}" PARENT_SCOPE) # Child flags for adding optimization to anything we build ourselves but doesn't follow our standard
 				# We use release flags since we really don't need to be using debug flags for anything not ours
 
-				SET_PROPERTY(GLOBAL PROPERTY FGL_FLAGS ${FGL_FLAGS})
-				SET_PROPERTY(GLOBAL PROPERTY FGL_CHILD_FLAGS ${FGL_CHILD_FLAGS})
+				set(FGL_LINK_FLAGS "-Wl,--gcc-sections;-Wl,--print-gc-sections" PARENT_SCOPE)
+
+
+				set_property(GLOBAL PROPERTY FGL_COMPILE_FLAGS ${FGL_FLAGS})
+				set_property(GLOBAL PROPERTY FGL_LINK_FLAGS ${FGL_LINK_FLAGS})
+				set_property(GLOBAL PROPERTY FGL_CHILD_FLAGS ${FGL_CHILD_FLAGS})
 
 				message("-- FGL_FLAGS: ${FGL_FLAGS}")
 				message("-- FGL_CHILD_FLAGS: ${FGL_CHILD_FLAGS}")
-
 			endif ()
 		endfunction()
 

modules/features/c++26.cmake

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.26)
+project(TestCXX)
+
+# Default to C++23
+set(STD_VERSION 23)
+
+# Check if the compiler supports C++26
+include(CheckCXXCompilerFlag)
+check_cxx_compiler_flag("-std=c++26" COMPILER_SUPPORTS_CXX26)
+
+if(COMPILER_SUPPORTS_CXX26)
+	set(STD_VERSION 26)
+endif()
+
+add_executable(${PROJECT_NAME} main.cpp)
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_${STD_VERSION})

modules/features/reflection.cmake

@@ -0,0 +1,14 @@
+set(REFLECTION_SRC "${CMAKE_CURRENT_LIST_DIR}/reflection.cpp")
+
+try_compile(HAS_CPP_REFLECTION
+		${CMAKE_BINARY_DIR}          # build directory
+		${REFLECTION_SRC}            # source file
+		CMAKE_FLAGS "-DCMAKE_CXX_STANDARD=26"
+		COMPILE_DEFINITIONS "-freflection"
+)
+
+if (HAS_CPP_REFLECTION)
+	message(STATUS "Compiler supports C++ reflection")
+else ()
+	message(STATUS "Compiler does NOT support C++ reflection")
+endif ()

modules/features/reflection.cpp

@@ -0,0 +1,57 @@
+#include <meta>
+using namespace std::meta;
+
+template < typename E, bool B = is_enumerable_type( ^^E ) >
+constexpr std::string_view enum_to_string( E e )
+{
+	if constexpr ( B )
+	{
+		constexpr info Enums = reflect_constant_array( enumerators_of( ^^E ) );
+		template for ( constexpr info I : [:Enums:] ) if ( e == [:I:] ) return identifier_of( I );
+	}
+	return "<unnamed>";
+}
+
+template < typename E, bool B = is_enumerable_type( ^^E ) >
+constexpr std::optional< E > string_to_enum( std::string_view s )
+{
+	if constexpr ( B )
+	{
+		constexpr info Enums = reflect_constant_array( enumerators_of( ^^E ) );
+		template for ( constexpr info I : [:Enums:] ) if ( s == identifier_of( I ) ) return [:I:];
+	}
+	return std::nullopt;
+}
+
+consteval void test()
+{
+	enum class Color : int;
+	static_assert( enum_to_string( Color { 0 } ) == "<unnamed>" );
+	static_assert( enum_to_string( Color { 3 } ) == "<unnamed>" );
+
+	enum class Color : int
+	{
+		Red,
+		Green,
+		Blue,
+		Yellow
+	};
+	static_assert( enum_to_string( Color::Red ) == "Red" );
+	static_assert( enum_to_string( Color::Green ) == "Green" );
+	static_assert( enum_to_string( Color::Blue ) == "Blue" );
+	static_assert( enum_to_string( Color::Yellow ) == "Yellow" );
+	static_assert( enum_to_string( Color { 0 } ) == "Red" );
+	static_assert( enum_to_string( Color { 3 } ) == "Yellow" );
+	static_assert( enum_to_string( Color { 4 } ) == "<unnamed>" );
+
+	static_assert( string_to_enum< Color >( "Red" ) == Color::Red );
+	static_assert( string_to_enum< Color >( "Green" ) == Color::Green );
+	static_assert( string_to_enum< Color >( "Blue" ) == Color::Blue );
+	static_assert( string_to_enum< Color >( "Yellow" ) == Color::Yellow );
+	static_assert( string_to_enum< Color >( "White" ) == std::nullopt );
+}
+
+int main()
+{
+	test();
+}

modules/git/commit.cmake

@@ -0,0 +1,114 @@
+function(getCommitHash OUTPUT_VARIABLE)
+	find_package(Git QUIET)
+	if (GIT_FOUND)
+		execute_process(
+				COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
+				WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+				OUTPUT_VARIABLE GIT_HASH
+				ERROR_VARIABLE GIT_ERROR
+				OUTPUT_STRIP_TRAILING_WHITESPACE
+				ERROR_STRIP_TRAILING_WHITESPACE
+		)
+		if (NOT GIT_ERROR)
+			set(${OUTPUT_VARIABLE} ${GIT_HASH} PARENT_SCOPE)
+		else ()
+			set(${OUTPUT_VARIABLE} "unknown" PARENT_SCOPE)
+		endif ()
+	else ()
+		set(${OUTPUT_VARIABLE} "unknown" PARENT_SCOPE)
+	endif ()
+endfunction()
+
+function(getBranchName OUTPUT_VARIABLE)
+	find_package(Git QUIET)
+	if (GIT_FOUND)
+		execute_process(
+				COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
+				WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+				OUTPUT_VARIABLE GIT_BRANCH
+				ERROR_VARIABLE GIT_ERROR
+				OUTPUT_STRIP_TRAILING_WHITESPACE
+				ERROR_STRIP_TRAILING_WHITESPACE
+		)
+		if (NOT GIT_ERROR)
+			set(${OUTPUT_VARIABLE} ${GIT_BRANCH} PARENT_SCOPE)
+		else ()
+			set(${OUTPUT_VARIABLE} "unknown" PARENT_SCOPE)
+		endif ()
+	else ()
+		set(${OUTPUT_VARIABLE} "unknown" PARENT_SCOPE)
+	endif ()
+endfunction()
+
+function(getGitTag OUTPUT_VARIABLE)
+	find_package(Git QUIET)
+	if (GIT_FOUND)
+		execute_process(
+				COMMAND ${GIT_EXECUTABLE} describe --tags --always
+				WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+				OUTPUT_VARIABLE GIT_TAG
+				ERROR_VARIABLE GIT_ERROR
+				OUTPUT_STRIP_TRAILING_WHITESPACE
+				ERROR_STRIP_TRAILING_WHITESPACE
+		)
+		if (NOT GIT_ERROR)
+			set(${OUTPUT_VARIABLE} ${GIT_TAG} PARENT_SCOPE)
+		else ()
+			set(${OUTPUT_VARIABLE} "unknown" PARENT_SCOPE)
+		endif ()
+	else ()
+		set(${OUTPUT_VARIABLE} "unknown" PARENT_SCOPE)
+	endif ()
+endfunction()
+
+function(addGitCommitDefine TARGET)
+	getCommitHash(GIT_HASH)
+	target_compile_definitions(${TARGET} PRIVATE FGL_GIT_COMMIT="${GIT_HASH}")
+endfunction()
+
+function(addGitBranchDefine TARGET)
+	getBranchName(GIT_BRANCH)
+	target_compile_definitions(${TARGET} PRIVATE FGL_GIT_BRANCH="${GIT_BRANCH}")
+endfunction()
+
+
+function(getIsDirty OUTPUT_VARIABLE)
+	find_package(Git QUIET)
+	if (GIT_FOUND)
+		execute_process(
+				COMMAND ${GIT_EXECUTABLE} status --porcelain
+				WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+				OUTPUT_VARIABLE GIT_STATUS
+				ERROR_VARIABLE GIT_ERROR
+				OUTPUT_STRIP_TRAILING_WHITESPACE
+				ERROR_STRIP_TRAILING_WHITESPACE
+		)
+		if (NOT GIT_ERROR)
+			if (GIT_STATUS)
+				set(${OUTPUT_VARIABLE} "1" PARENT_SCOPE)
+			else ()
+				set(${OUTPUT_VARIABLE} "0" PARENT_SCOPE)
+			endif ()
+		else ()
+			set(${OUTPUT_VARIABLE} "-1" PARENT_SCOPE)
+		endif ()
+	else ()
+		set(${OUTPUT_VARIABLE} "-1" PARENT_SCOPE)
+	endif ()
+endfunction()
+
+function(addGitDirtyDefine TARGET)
+	getIsDirty(GIT_DIRTY)
+	target_compile_definitions(${TARGET} PRIVATE FGL_GIT_DIRTY=${GIT_DIRTY})
+	target_compile_definitions(${TARGET} PRIVATE FGL_GIT_IS_DIRTY=1)
+endfunction()
+
+include(modules/git/tag.cmake)
+
+function(AddGitInfo TARGET)
+	addGitCommitDefine(${TARGET})
+	addGitBranchDefine(${TARGET})
+	addGitDirtyDefine(${TARGET})
+	addGitTagDefine(${TARGET})
+	addGitUnsyncedDefine(${TARGET})
+endfunction()

modules/git/tag.cmake

@@ -0,0 +1,95 @@
+function(getGitTagVersion)
+	execute_process(
+			COMMAND git describe --tags --abbrev=0
+			WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+			OUTPUT_VARIABLE GIT_TAG_VERSION
+			OUTPUT_STRIP_TRAILING_WHITESPACE
+			ERROR_QUIET
+	)
+
+	if (NOT GIT_TAG_VERSION)
+		set(GIT_TAG_VERSION "v0.0.0")
+	endif ()
+
+	string(REGEX MATCH "v?([0-9]+)\\.([0-9]+)\\.([0-9]+)" _ ${GIT_TAG_VERSION})
+	if (CMAKE_MATCH_1)
+		set(VERSION_MAJOR ${CMAKE_MATCH_1})
+	else ()
+		set(VERSION_MAJOR 0)
+	endif ()
+	if (CMAKE_MATCH_2)
+		set(VERSION_MINOR ${CMAKE_MATCH_2})
+	else ()
+		set(VERSION_MINOR 0)
+	endif ()
+	if (CMAKE_MATCH_3)
+		set(VERSION_PATCH ${CMAKE_MATCH_3})
+	else ()
+		set(VERSION_PATCH 0)
+	endif ()
+
+	set(GIT_TAG_VERSION ${GIT_TAG_VERSION} PARENT_SCOPE)
+	set(VERSION_MAJOR ${VERSION_MAJOR} PARENT_SCOPE)
+	set(VERSION_MINOR ${VERSION_MINOR} PARENT_SCOPE)
+	set(VERSION_PATCH ${VERSION_PATCH} PARENT_SCOPE)
+endfunction()
+
+function(setGitTagVersionDefines TARGET)
+	getGitTagVersion()
+
+	message("Adding version info to ${TARGET}")
+
+	target_compile_definitions(${TARGET} PUBLIC
+			${TARGET}_MAJOR_VERSION=${VERSION_MAJOR}
+			${TARGET}_MINOR_VERSION=${VERSION_MINOR}
+			${TARGET}_PATCH_VERSION=${VERSION_PATCH}
+	)
+endfunction()
+
+function(addGitTagDefine TARGET)
+	getGitTag(GIT_TAG)
+	setGitTagVersionDefines(${TARGET})
+	target_compile_definitions(${TARGET} PRIVATE FGL_GIT_TAG="${GIT_TAG}")
+endfunction()
+
+function(getIsUnsynced OUTPUT_VARIABLE)
+	find_package(Git QUIET)
+	if (GIT_FOUND)
+		# Get the commit hash of the latest tag
+		execute_process(
+				COMMAND ${GIT_EXECUTABLE} rev-list -n 1 $ (${GIT_EXECUTABLE} describe --tags --abbrev=0)
+				WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+				OUTPUT_VARIABLE TAG_COMMIT
+				ERROR_VARIABLE GIT_ERROR
+				OUTPUT_STRIP_TRAILING_WHITESPACE
+				ERROR_STRIP_TRAILING_WHITESPACE
+		)
+
+		# Get the current commit hash
+		execute_process(
+				COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+				WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+				OUTPUT_VARIABLE CURRENT_COMMIT
+				ERROR_VARIABLE GIT_ERROR2
+				OUTPUT_STRIP_TRAILING_WHITESPACE
+				ERROR_STRIP_TRAILING_WHITESPACE
+		)
+
+		if (NOT GIT_ERROR AND NOT GIT_ERROR2)
+			if (NOT "${CURRENT_COMMIT}" STREQUAL "${TAG_COMMIT}")
+				set(${OUTPUT_VARIABLE} "1" PARENT_SCOPE)
+			else ()
+				set(${OUTPUT_VARIABLE} "0" PARENT_SCOPE)
+			endif ()
+		else ()
+			set(${OUTPUT_VARIABLE} "-1" PARENT_SCOPE)
+		endif ()
+	else ()
+		set(${OUTPUT_VARIABLE} "-1" PARENT_SCOPE)
+	endif ()
+endfunction()
+
+function(addGitUnsyncedDefine TARGET)
+	getIsUnsynced(GIT_UNSYNCED)
+	target_compile_definitions(${TARGET} PRIVATE FGL_GIT_UNSYNCED=${GIT_UNSYNCED})
+endfunction()

modules/helpers.cmake

@@ -12,51 +12,93 @@ function(PostSetup)
 	CompilerPostSetup()
 endfunction()
 
-function(AddFGLExecutable NAME SRC_SOURCES_LOCATION)
-	set(CMAKE_CXX_STANDARD 23)
-	set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-	file(GLOB_RECURSE M_SOURCES CONFIGURE_DEPENDS
-			${SRC_SOURCES_LOCATION}/**.cppm)
+function(ConfigureFGLTarget NAME SRC_DIR INCLUDE_DIR)
+	if (INCLUDE_DIR)
+		target_include_directories(${NAME} PUBLIC ${INCLUDE_DIR})
+	endif ()
+
+	target_include_directories(${NAME} PRIVATE ${SRC_DIR})
+	if (DEFINED FGL_STRICT_WARNINGS AND FGL_STRICT_WARNINGS)
+		target_compile_definitions(${NAME} PUBLIC "-DFGL_STRICT_WARNINGS=1")
+	endif ()
+
+	if (COMPILER_SUPPORTS_CXX26)
+		target_compile_features(${NAME} PUBLIC cxx_std_26)
+	else ()
+		target_compile_features(${NAME} PUBLIC cxx_std_23)
+	endif ()
+endfunction()
+
+function(SplitDebugSymbols NAME)
+	if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+		add_custom_command(TARGET ${NAME} POST_BUILD
+				COMMAND ${CMAKE_OBJCOPY} --only-keep-debug $<TARGET_FILE:${NAME}> $<TARGET_FILE:${NAME}>.debug
+				COMMAND ${CMAKE_STRIP} --strip-debug --strip-unneeded $<TARGET_FILE:${NAME}>
+				COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=$<TARGET_FILE:${NAME}>.debug $<TARGET_FILE:${NAME}>
+				COMMENT "Stripping symbols and creating ${NAME}.debug"
+		)
+	endif ()
+endfunction()
+
+function(AddFGLExecutable NAME SRC_SOURCES_LOCATION)
+	file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS
+			${SRC_SOURCES_LOCATION}/**.cpp
+			${SRC_SOURCES_LOCATION}/**.hpp
+	)
+
+	file(GLOB_RECURSE UI_SOURCES CONFIGURE_DEPENDS
+			${SRC_SOURCES_LOCATION}/**.ui)
+
+	add_executable(${NAME} ${SOURCES})
+	target_sources(${NAME} PUBLIC ${SOURCES})
+
+	ConfigureFGLTarget(${NAME} ${SRC_SOURCES_LOCATION} "")
+
+	set_target_properties(${NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+	set_target_properties(${NAME} PROPERTIES CXX_STANDARD 23)
+	set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
+	SetFGLFlags(${NAME})
+	AddGitInfo(${NAME})
+	target_compile_definitions(${NAME} PRIVATE FGL_BUILD_TYPE="${CMAKE_BUILD_TYPE}")
+
+	SplitDebugSymbols(${NAME})
+
+endfunction()
+
+function(AddFGLLibrary NAME MODE SRC_SOURCES_LOCATION INCLUDE_SOURCES_LOCATION)
 
 	file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS
 			${SRC_SOURCES_LOCATION}/**.cpp
 			${SRC_SOURCES_LOCATION}/**.hpp
 	)
 
-	message("Compiling ${NAME} WITH ${M_SOURCES} as modules")
+	file(GLOB_RECURSE INCLUDE_HPP_SOURCES CONFIGURE_DEPENDS ${INCLUDE_SOURCES_LOCATION}/**.hpp)
 
-	add_executable(${NAME})
-	target_sources(${NAME} PUBLIC ${SOURCES})
-	target_sources(${NAME} PUBLIC FILE_SET modules TYPE CXX_MODULES FILES ${M_SOURCES})
+	add_library(${NAME} ${MODE})
+	target_sources(${NAME} PRIVATE ${SOURCES})
+
+	ConfigureFGLTarget(${NAME} ${SRC_SOURCES_LOCATION} ${INCLUDE_SOURCES_LOCATION})
 
-	target_include_directories(${NAME} PRIVATE ${SRC_SOURCES_LOCATION})
-	set_target_properties(${NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
-	set_target_properties(${NAME} PROPERTIES CXX_STANDARD 23)
-	set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
 	SetFGLFlags(${NAME})
+	AddGitInfo(${NAME})
+	target_compile_definitions(${NAME} PRIVATE FGL_BUILD_TYPE="${CMAKE_BUILD_TYPE}")
+
+	if (NOT "${MODE}" STREQUAL "OBJECT")
+		SplitDebugSymbols(${NAME})
+	endif ()
 endfunction()
 
-function(AddFGLLibrary NAME MODE SRC_SOURCES_LOCATION INCLUDE_SOURCES_LOCATION)
+function(AddFGLModule NAME SRC_SOURCES_LOCATION)
 	file(GLOB_RECURSE CPP_SOURCES CONFIGURE_DEPENDS ${SRC_SOURCES_LOCATION}/**.cpp)
 	file(GLOB_RECURSE HPP_SOURCES CONFIGURE_DEPENDS ${SRC_SOURCES_LOCATION}/**.hpp)
-	message("Found {CPPM_SOURCES}")
-	file(GLOB_RECURSE INCLUDE_HPP_SOURCES CONFIGURE_DEPENDS ${INCLUDE_SOURCES_LOCATION}/**.hpp)
-	file(GLOB_RECURSE INCLUDE_CPPM_SOURCES CONFIGURE_DEPENDS ${INCLUDE_SOURCES_LOCATION}/**.cppm)
-	add_library(${NAME} ${MODE} ${CPP_SOURCES} ${HPP_SOURCES} ${INCLUDE_SOURCES_LOCATION})
-
-
-	file(GLOB_RECURSE CPPM_SOURCES CONFIGURE_DEPENDS ${SRC_SOURCES_LOCATION}/**.cppm)
-
-	target_sources(${NAME} PUBLIC FILE_SET modules TYPE CXX_MODULES BASE_DIRS ${SRC_SOURCES_LOCATION} FILES ${CPPM_SOURCES})
-
-	target_compile_features(${NAME} PRIVATE cxx_std_23 INTERFACE cxx_std_20)
-
-	target_include_directories(${NAME} PUBLIC ${INCLUDE_SOURCES_LOCATION})
+	add_library(${NAME} MODULE ${CPP_SOURCES} ${HPP_SOURCES})
 	target_include_directories(${NAME} PRIVATE ${SRC_SOURCES_LOCATION})
-	set_target_properties(${NAME} PROPERTIES CXX_STANDARD 23)
-	set_target_properties(${NAME} PROPERTIES CXX_STANDARD_REQUIRED ON)
 	SetFGLFlags(${NAME})
+	AddGitInfo(${NAME})
+	target_compile_definitions(${NAME} PRIVATE FGL_BUILD_TYPE="${CMAKE_BUILD_TYPE}")
+
+	SplitDebugSymbols(${NAME})
 endfunction()
 
 function(AddFGLChildLibrary NAME MODE SRC_SOURCES_LOCATION INCLUDE_SOURCES_LOCATION)
@@ -66,5 +108,7 @@ function(AddFGLChildLibrary NAME MODE SRC_SOURCES_LOCATION INCLUDE_SOURCES_LOCAT
 	add_library(${NAME} ${MODE} ${CPP_SOURCES} ${HPP_SOURCES} ${INCLUDE_SOURCES_LOCATION})
 	target_include_directories(${NAME} PUBLIC ${INCLUDE_SOURCES_LOCATION})
 	target_include_directories(${NAME} PRIVATE ${SRC_SOURCES_LOCATION})
-	#	SetFGLFlags(${NAME})
+	ConfigureFGLTarget(${NAME} ${SRC_SOURCES_LOCATION} ${INCLUDE_SOURCES_LOCATION})
+
+	SplitDebugSymbols(${NAME})
 endfunction()