CMakeLists.txt

cmake_minimum_required(VERSION 3.15)
# if(CMAKE_GENERATOR STREQUAL "Xcode")
# 	set(CMAKE_OSX_ARCHITECTURES "$(ARCHS_STANDARD)" CACHE STRING "")
# endif()
include(CMakeLists.local OPTIONAL)

if (NOT CMAKE_BUILD_TYPE)
	set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Compile Type" FORCE)
endif()
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS Debug Release MinSizeRel RelWithDebInfo Profile)

option(UNITTESTS "Builds with unittests" ON)
option(VISUALTESTS "Builds with visual tests (src/tests)" ON)

option(VOXEDIT "Builds voxedit" ON)
option(THUMBNAILER "Builds thumbnailer" ON)
option(VOXCONVERT "Builds voxconvert" ON)
option(PALCONVERT "Builds palconvert" ON)

option(USE_OPENGLES "Enable OpenGLES" OFF)
option(USE_CCACHE "Use ccache" ON)
option(USE_YOCTO "Enable Yocto/Trace support" ON)
option(USE_DOXYGEN_CHECK "Use -Wdocumentation if available" OFF)
option(USE_CPPCHECK "Enable cppcheck" OFF)
option(USE_CLANG_TIDY "Enable Clang Tidy" OFF)
option(USE_IMGUITESTENGINE "Enable imgui test engine" OFF)
option(USE_STACKTRACES "Enable stacktraces" ON)
option(USE_SANITIZERS "Enable sanitizer" OFF)
option(USE_GLSLANG_VALIDATOR "Enable the use of the standalone glslang validator" OFF)
option(USE_SPIRV "Enable SPIR-V shader compilation for OpenGL (requires glslangValidator)" OFF)
option(USE_LIBS_FORCE_LOCAL "Don't use systemwide installations" OFF)
option(USE_LIBDEFLATE "Enable libdeflate support" ON)
option(USE_BENCHMARKS "Build benchmarks" ON)
option(USE_COVERAGE "Build with coverage" OFF)

set(ROOT_PROJECT_MAJOR_VERSION 0)
set(ROOT_PROJECT_MINOR_VERSION 6)
set(ROOT_PROJECT_MICRO_VERSION 0)
set(ROOT_PROJECT_PATCH_VERSION 0)
set(ROOT_PROJECT_VERSION "${ROOT_PROJECT_MAJOR_VERSION}.${ROOT_PROJECT_MINOR_VERSION}.${ROOT_PROJECT_MICRO_VERSION}.${ROOT_PROJECT_PATCH_VERSION}")
set(ROOT_PROJECT_NAME vengi)
project(
	${ROOT_PROJECT_NAME}
	VERSION ${ROOT_PROJECT_VERSION}
	DESCRIPTION "vengi - voxel art tools"
	HOMEPAGE_URL "https://github.com/vengi-voxel/vengi")
set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE STRING "Root dir")
set(DATA_DIR ${ROOT_DIR}/data CACHE STRING "" FORCE)
set(SCRIPTS_CMAKE_DIR ${PROJECT_SOURCE_DIR}/cmake)
set(GENERATE_DIR ${CMAKE_BINARY_DIR}/generated CACHE STRING "Generated code dir")
set(PKGDATABASEDIR "" CACHE STRING "System directory to search for data files (must end on /)")
set(PKGDATADIR "" CACHE STRING "System directory to search for data files (must end on /)")
add_custom_target(engine_codegen)

include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
include(CheckCXXSourceCompiles)
include(CheckIPOSupported)
include(CMakeParseArguments)
include(CheckIncludeFiles)
include(GNUInstallDirs)

if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
	set(WINDOWS 1)
elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Android")
	set(LINUX 1)
elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
	set(LINUX 1)
elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Emscripten")
	set(EMSCRIPTEN 1)
	set(USE_STACKTRACES OFF)
	set(USE_OPENGLES ON)
elseif (APPLE)
else()
	message(WARNING "Unknown host system: ${CMAKE_SYSTEM_NAME}. Default to linux")
	set(LINUX 1)
endif()

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED on)
set(CMAKE_CXX_EXTENSIONS off)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

if (${CMAKE_BUILD_TYPE} MATCHES "Release")
	set(CMAKE_LINK_WHAT_YOU_USE ON)
	option(USE_LINK_TIME_OPTIMIZATION "Enable link time optimization" ON)
else()
	option(USE_LINK_TIME_OPTIMIZATION "Enable link time optimization" OFF)
endif()

check_ipo_supported(RESULT HAVE_LTO OUTPUT error)
if (HAVE_LTO)
	if (USE_LINK_TIME_OPTIMIZATION)
		# Use memory-efficient LTO variants to avoid OOM during linking.
		# ThinLTO (Clang) and single-job LTO (GCC) drastically reduce peak memory
		# compared to full parallel LTO while still providing profiling-relevant
		# optimizations.
		if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
			set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
			add_compile_options("-flto=thin")
			add_link_options("-flto=thin")
			message(STATUS "IPO / ThinLTO enabled (memory-efficient)")
		elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
			set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
			add_compile_options("-flto=1")
			add_link_options("-flto=1")
			message(STATUS "IPO / LTO enabled (single-threaded, reduced memory)")
		else()
			set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON)
			message(STATUS "IPO / LTO enabled")
		endif()
	else()
		set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)
		message(STATUS "IPO / LTO disabled")
	endif()
else()
	message(STATUS "IPO / LTO not supported: <${error}>")
endif()

if (NOT EMSCRIPTEN AND USE_COVERAGE)
	if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
		add_compile_options("-O0" "--coverage")
		add_link_options("--coverage")
	elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
		add_compile_options("-O0" "--coverage")
		add_link_options("-lgcov" "--coverage")
	endif()
endif()

if (MSVC)
	include(${SCRIPTS_CMAKE_DIR}/system/msvc.cmake)
elseif (WINDOWS)
	include(${SCRIPTS_CMAKE_DIR}/system/mingw.cmake)
elseif (APPLE)
	include(${SCRIPTS_CMAKE_DIR}/system/apple.cmake)
elseif (EMSCRIPTEN)
	include(${SCRIPTS_CMAKE_DIR}/system/emscripten.cmake)
else()
	include(${SCRIPTS_CMAKE_DIR}/system/linux.cmake)
endif()

find_program(GLSLANG_EXECUTABLE NAMES glslangValidator glslang-standalone)
if (GLSLANG_EXECUTABLE)
	message(STATUS "Found glslang tool at ${GLSLANG_EXECUTABLE}")
elseif(USE_GLSLANG_VALIDATOR)
	message(WARNING "Couldn't find glslang tool but using it was requested")
endif()

include(${SCRIPTS_CMAKE_DIR}/git.cmake)
include(${SCRIPTS_CMAKE_DIR}/util.cmake)
include(${SCRIPTS_CMAKE_DIR}/genshader.cmake)
include(${SCRIPTS_CMAKE_DIR}/externallib.cmake)
include(${SCRIPTS_CMAKE_DIR}/valgrind.cmake)
include(${SCRIPTS_CMAKE_DIR}/perf.cmake)
include(${SCRIPTS_CMAKE_DIR}/heaptrack.cmake)
include(${SCRIPTS_CMAKE_DIR}/apitrace.cmake)
include(${SCRIPTS_CMAKE_DIR}/debug.cmake)
include(${SCRIPTS_CMAKE_DIR}/googletest.cmake)
include(${SCRIPTS_CMAKE_DIR}/lua.cmake)
include(${SCRIPTS_CMAKE_DIR}/macros.cmake)
# Only register targets created under src/ (skip contrib/ third-party libs).
set(LINECOUNT_DIR_REGEX "/src/")
include(${SCRIPTS_CMAKE_DIR}/LineCount.cmake)
include(${SCRIPTS_CMAKE_DIR}/pack.cmake)
include(CPack)

# First for the generic no-config case (e.g. with mingw)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/lib)

# Second, for multi-config builds (e.g. msvc)
foreach(OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
	string(TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG)
	set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR})
	set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/lib)
	set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_BINARY_DIR}/${CMAKE_BUILD_TYPE}/lib)
endforeach()

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${SCRIPTS_CMAKE_DIR})
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)

find_host_program(GDB_EXECUTABLE NAMES ${GDB_BINARY} gdb)
find_host_program(LLDB_EXECUTABLE NAMES ${LLDB_BINARY} lldb)

include_directories(${CMAKE_CURRENT_BINARY_DIR})

# These includes are needed to let the include for IMPLICIT_DEPENDS for shaders work
include_directories(src/modules/video/shaders)

include_directories(src/modules)

add_subdirectory(contrib/libs)
add_subdirectory(tools)

if (UNITTESTS OR USE_IMGUITESTENGINE)
	enable_testing()
	set(CTEST_TEST_TIMEOUT 1800)
endif()
add_subdirectory(src)

configure_file(src/engine-git.h.in engine-git.h @ONLY)
configure_file(src/engine-config.h.in engine-config.h @ONLY)
message(STATUS "Generate engine-config.h in ${CMAKE_CURRENT_BINARY_DIR}")

engine_app_id(APP_ID_VOXEDIT voxedit)
engine_app_id(APP_ID_VOXCONVERTUI voxconvertui)
configure_file(${ROOT_DIR}/contrib/installer/linux/vengi.spec.in ${PROJECT_BINARY_DIR}/vengi.spec)

find_package(Doxygen)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile-mcss.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile-mcss @ONLY)
if (DOXYGEN_FOUND)
	add_custom_target(doc ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
		COMMENT "Generating API documentation with Doxygen" VERBATIM
		DEPENDS engine_codegen
	)
endif(DOXYGEN_FOUND)

# Linecount analysis (opt-in: cmake -DLINECOUNT=ON, or make linecount*).
# See cmake/LineCount.cmake
if (LINECOUNT)
	set(LINECOUNT_STRIP_PREFIX "src/modules/")
	set(LINECOUNT_SKIP_TARGET_REGEX "^(tests-|benchmarks-)")
	set(LINECOUNT_SKIP_PATH_REGEX "/(tests|benchmarks)/")
	linecount_finalize()
endif()