CosmicEngine/CMakeLists.txt

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités.
cmake_minimum_required(VERSION 3.20)
set (CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
# Nom du projet.
set(PROJECT CosmicEngine)
project(${PROJECT})

# Génération de la liste des fichiers sources.
file(GLOB_RECURSE
    SRCS_ENGINE
    src/Engine/*
)

file(GLOB_RECURSE
    SRCS_SCRIPTS
    src/Modules/Scripts/*
)

file(GLOB_RECURSE
    SRCS
    src/main.cpp)

file(GLOB_RECURSE
    SRCS_TESTS
    test/*
)

file(GLOB_RECURSE
    HEADERS_ENGINE
    src/Engine/*.h
    src/Engine/*.hpp
)

# ---------- Inclusion des packages sous windows -----------
if(WIN32)
endif()
# ---------- Inclusion des packages sous mac -----------
if(APPLE)
endif()
# ---------- Inclusion des packages sous linux -----------

if(UNIX)

# ---------- Inclusion de GLM -----------
# GLM Lib pour mathématique, en mode header only.
    set(GLMlib_DIR ./lib/CMake/Linux)
    find_package(GLMlib REQUIRED)
    if(GLMlib_FOUND)
        message("lib GLM Trouvé")
    else()
        message("lib GLM Introuvable")
    endif()
# ---------------------------------------

# ------- Inclusion de JSONfMC++ --------
# JSONfMC++ Lib pour gestion fichier JSON, en mode header only.
    set(JSONlib_DIR ./lib/CMake/Linux)
    find_package(JSONlib REQUIRED)

    if(JSONlib_FOUND)
        message("lib JSONFMC++ Trouvé")
    else()
        message("lib JSONFMC++ Introuvable")
    endif()
# ---------------------------------------

# ------- Inclusion de EnTT --------
# EnTT Lib pour gestion fichier JSON, en mode header only.
     set(EnTTlib_DIR ./lib/CMake/Linux)
     find_package(EnTTlib REQUIRED)

     if(EnTTlib_FOUND)
         message("lib EnTTlib Trouvé")
     else()
         message("lib EnTTlib Introuvable")
     endif()

# ---------- Inclusion de ASSIMP -----------
# Assimp Lib import modèles 3D.
     find_package(assimp REQUIRED)
     if(assimp_FOUND)
         message("lib ASSIMP Trouvé")
     else()
         message("lib ASSIMP Introuvable")
     endif()  
# ---------------------------------------

# ---------- Inclusion de OpenAL-----------
# OpenAL Lib gérer le son.
    # Les autre plateforme (Linux...) ont un installateur de paquet, la lib se trouve toute seul. 
    # set(OPENAL_DIR ./lib/CMake/Linux)  
    find_package(OpenAL REQUIRED)

    if(OpenAL_FOUND)
         message("lib OpenAL Trouvé")
    else()
         message("lib OpenAL Introuvable")
    endif()
# ---------------------------------------

# ------- Inclusion de dr_libs --------
# dr_libs Lib pour gestion du son en mode header only.
set(drlibs_DIR ./lib/CMake/Linux)
find_package(drlibs REQUIRED)

if(drlibs_FOUND)
    message("lib dr_libs Trouvé")
else()
    message("lib dr_libs Introuvable")
endif()
# ---------------------------------------

# ---------- Inclusion de Catch2-----------
# Gestion des tests unitaires

find_package(Catch2 3 REQUIRED)
# These tests can use the Catch2-provided main
if(Catch2_found)
    message("lib Catch2 Trouvé")
else()
    message("lib Catch2 Introuvable")
endif()

# ---------- Inclusion de SDL3-----------
# la sdl3

find_package(SDL3 REQUIRED)
# These tests can use the Catch2-provided main
if(SDL3_found)
    message("lib Catch2 Trouvé")
else()
    message("lib Catch2 Introuvable")
endif()

# ---------- Inclusion de Vulkan-----------
# vulkan
# --------- Inclusion de Vulkan ----------
# Vulkan Lib pour charger Vulkan, fournit avec les drivers, donc se trouve toute seul.
find_package(Vulkan REQUIRED)
if(VULKAN_FOUND)
    message("lib OpenGL Trouvé")
else()
    message("lib OpenGL Introuvable")
endif()
# ---------------------------------------

# ------- Inclusion de SDL2_IMAGE --------
# SDL2_IMAGE Lib pour charger une image
    # Les autre plateforme (Linux...) ont un installateur de paquet, la lib se trouve toute seul.   
     find_package(SDL3_image QUIET)
    # #find_library(SDL2_image libSDL2_image)

     if(SDL3_image_FOUND)
         message("lib SDL3_IMAGE Trouvé")
     else()
         message("lib SDL3_IMAGE Introuvable")
     endif()
# ---------------------------------------

# ------- Inclusion de SDL3_TTF --------
#SDL3_IMAGE Lib pour charger une police d'écriture.
     #set(SDL3_ttf_DIR ./lib/CMake/Linux)
     # Les autre plateforme (Linux...) ont un installateur de paquet, la lib se trouve toute seul.
     find_package(SDL3_ttf QUIET)
     #find_library(SDL2_ttf libSDL2_ttf)
     if(SDL3_ttf_FOUND)
         message("lib SDL3_TTF Trouvé")
     else()
         message("lib SDL3_TTF Introuvable")
     endif()
# ---------------------------------------

# ------- Inclusion de Spirv-cross --------
#Spirv-cross pour metadonnees shader spirv
    set(spirvreflectlib_DIR ./lib/CMake/Linux/)
     # Les autre plateforme (Linux...) ont un installateur de paquet, la lib se trouve toute seul.
#     find_package(spirv_cross_core QUIET)
     find_package(spirvreflectlib QUIET)

     if(spirvreflectlib_FOUND)
         message("lib spirvReflect Trouvé")
     else()
         message("lib spirvReflect Introuvable")
     endif()
# ---------------------------------------
add_library(spirv-reflect STATIC ${SPIRV_EXT_SRC})

# ------- Inclusion de VulkanAllocator --------
set(VulkanMemoryAllocatorlib_DIR ./lib/CMake/Linux)
find_package(VulkanMemoryAllocatorlib REQUIRED)

if(VulkanMemoryAllocatorlib_FOUND)
    message("lib VulkanMemoryAllocator Trouvé")
else()
    message("lib VulkanMemoryAllocator Introuvable")
endif()
# ---------------------------------------

# ---------- Inclusion de JoltPhysics -----------
# JoltPhysics Lib Moteur physique.
    set(JoltPhysicslib_DIR ./lib/CMake/Linux)
    # # Les autre plateforme (Linux...) ont un installateur de paquet, la lib se trouve toute seul.
    
    find_package(JoltPhysicslib REQUIRED)
    if(JoltPhysicslib_FOUND)
        message("lib JOLT Trouvé")
    else()
        message("lib JOLT Introuvable")
    endif()
# ---------------------------------------

# ------- Inclusion de JSON-Schema-Validator --------
# JSON-Schema-Validator Lib pour valider les fichier JSON, en mode header only.
if(WIN32)
    set(JsonValidator_DIR  ./lib/CMake/Windows)
else()
    set(JsonValidator_DIR ./lib/CMake/Linux)
endif()

find_package(JsonValidator REQUIRED)

if(JsonValidator_FOUND)
    message("lib JSON_Schema_Validator Trouvé")
else()
    message("lib JSON_Schema_Validator Introuvable")
endif()
# ---------------------------------------

# ------- Inclusion de MSDFATLASGEN --------
# Pour les font
set(MsdfAtlasGen_DIR ./lib/CMake/Linux)

find_package(MsdfAtlasGen REQUIRED)

if(MsdfAtlasGen_FOUND)
    message("lib MsdfAtlasGen Trouvé")
else()
    message("lib MsdfAtlasGen Introuvable")
endif()
# ---------------------------------------


endif()


# Chemin executable
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "bin/${CMAKE_BUILD_TYPE}")
set(PATH_TO_SHADER_BUILD_TYPE "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
function(compile_slang_shaders SLANG_FILES OUTPUT_DIR)
    set(SLANG_COMPILER ${CMAKE_CURRENT_SOURCE_DIR}/lib/All/slang/bin/slangc)
    set(GENERATED_SPV_FILES "")
    set (SHADERS_DIR ${PATH_TO_SHADER_BUILD_TYPE}/assets/shaders/slang)
    set (ENTRY_POINTS -entry vertMain -entry fragMain)

    foreach(SLANG_FILE ${SLANG_FILES})
        get_filename_component(FILE_NAME ${SLANG_FILE} NAME_WE)
        
        # Un seul fichier de sortie par shader source
        set(OUTPUT_FILE "${OUTPUT_DIR}/${FILE_NAME}.spv")
        
        # Compiler tout le shader en un seul SPIR-V
        add_custom_command(
            OUTPUT ${OUTPUT_FILE}
            COMMAND ${SLANG_COMPILER} 
                ${SLANG_FILE}
                -target spirv
                -profile spirv_1_4 
                -emit-spirv-directly 
                -o ${OUTPUT_FILE}
            DEPENDS ${SLANG_FILE}
            COMMENT "Compiling Slang shader ${FILE_NAME} → ${OUTPUT_FILE}"
            VERBATIM
        )
        
        list(APPEND GENERATED_SPV_FILES ${OUTPUT_FILE})
    endforeach()

    set(GENERATED_SPV_FILES ${GENERATED_SPV_FILES} PARENT_SCOPE)
endfunction()


add_library(Engine STATIC ${SRCS_ENGINE} ${SRCS_EXTERNAL_GLAD} ${ENGINE_HEADERS})

target_include_directories(Engine
    PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Engine
    )
    
add_library(EngineHeaders INTERFACE)
target_include_directories(EngineHeaders INTERFACE
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Engine
    ${GLM_INCLUDE_DIRS}
    ${JSONFMCPP_INCLUDE_DIRS}
    ${ENTT_INCLUDE_DIRS}
    ${JOLT_INCLUDE_DIRS}
    ${VMA_INCLUDE_DIRS}
    ${DRLIBS_INCLUDE_DIRS}
    ${MSDFATLASGEN_INCLUDE_DIRS}
    ${OPENAL_INCLUDE_DIR}
    ${SPIRV_REFLECT_INCLUDE_DIRS}
    ${ASSIMP_INCLUDE_DIRS}
    ${JSONVALIDATOR_INCLUDE_DIRS}
)

add_library(ScriptModule SHARED ${SRCS_SCRIPTS})
target_include_directories(ScriptModule PRIVATE ${HEADERS_ENGINE})

set_property(TARGET Engine PROPERTY INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)

add_executable(${PROJECT} ${SRCS})
set_property(TARGET ${PROJECT} PROPERTY INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
add_executable(CosmicTest ${SRCS_TESTS})
set_property(TARGET CosmicTest PROPERTY INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
set_property(TARGET ScriptModule PROPERTY INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)

# On indique que l'on veut un exécutable nommé PROJECT compilé à partir des fichiers décrits par les variables SRCS et HEADERS.
file(GLOB_RECURSE SLANG_SHADERS "${PATH_TO_SHADER_BUILD_TYPE}/assets/shaders/slang/*.slang")
compile_slang_shaders("${SLANG_SHADERS}" "${PATH_TO_SHADER_BUILD_TYPE}/assets/shaders/slang/spv")

message(STATUS "GENERATED_SPV_FILES = ${GENERATED_SPV_FILES}")

# Créer la target ICI, au niveau global
if(GENERATED_SPV_FILES)
    add_custom_target(CompileSlangShaders ALL
        DEPENDS ${GENERATED_SPV_FILES}
    )
endif()

add_dependencies(${PROJECT} EngineHeaders)
add_dependencies(Engine CompileSlangShaders)
add_dependencies(ScriptModule EngineHeaders)



include_directories(${GLM_INCLUDE_DIRS})
include_directories(${JSONFMCPP_INCLUDE_DIRS})
include_directories(${ENTT_INCLUDE_DIRS})
include_directories(${SPIRV_REFLECT_INCLUDE_DIRS})
include_directories(${VMA_INCLUDE_DIRS})
include_directories(${ASSIMP_INCLUDE_DIRS})
include_directories(${JOLT_INCLUDE_DIRS})
include_directories(${OPENAL_INCLUDE_DIR})
include_directories(${JSONVALIDATOR_INCLUDE_DIRS})
include_directories(${DRLIBS_INCLUDE_DIRS})
include_directories(${MSDFATLASGEN_INCLUDE_DIRS})

if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(Engine PRIVATE
JPH_ENABLE_ASSERTS      
JPH_PROFILE_ENABLED      
JPH_OBJECT_STREAM       
JPH_DEBUG_RENDERER      
)

#target_compile_definitions(ScriptModule PRIVATE
#    JPH_ENABLE_ASSERTS      
#    JPH_PROFILE_ENABLED      
#    JPH_OBJECT_STREAM       
#    JPH_DEBUG_RENDERER      
#)
else() # Release
target_compile_definitions(Engine PRIVATE
JPH_OBJECT_STREAM
)
#target_compile_definitions(ScriptModule PRIVATE
#    JPH_OBJECT_STREAM
#)
endif()

target_link_libraries(Engine PRIVATE
    debug ${JOLT_LIBRARIES_DEBUG}
    optimized ${JOLT_LIBRARIES_RELEASE}
    SDL3::SDL3
    SDL3_image
    SDL3_ttf
    Vulkan::Vulkan
    spirv-reflect
    ${ASSIMP_LIBRARIES}
    OpenAL::OpenAL
    ${JSONVALIDATOR_LIBRARIES}
    ${MSDFATLASGEN}
)

target_link_libraries(CosmicTest PRIVATE Catch2::Catch2WithMain Engine EngineHeaders)
target_link_libraries(ScriptModule PRIVATE EngineHeaders)
target_link_options(ScriptModule PRIVATE -Wl,--allow-shlib-undefined)
target_link_libraries(${PROJECT} PUBLIC Engine EngineHeaders)
target_link_options(${PROJECT} PRIVATE
    -Wl,--export-dynamic
)

if(UNIX)
add_custom_command(
        TARGET ScriptModule POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E copy
                ${CMAKE_CURRENT_BINARY_DIR}/libScriptModule.so
                ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
endif()			

# Paramètre de compilation
if (UNIX)
    set(CMAKE_CXX_FLAGS "-Wall -fPIC")
    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")

endif ()

# Valgrind ne marche que pour Linux...
if (UNIX)
    add_custom_target("valgrind"
        COMMAND ${CMAKE_CTEST_COMMAND} 
            --force-new-ctest-process --test-action memcheck
        COMMAND cat "${CMAKE_BINARY_DIR}/Testing/Temporary/MemoryChecker.*.log")
endif()

# Doxygen
# check if Doxygen is installed
find_package(Doxygen)
if (DOXYGEN_FOUND)
    # set input and output files
    set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in)
    set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/doc/Doxyfile)

    # request to configure the file
    configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)
    message("Doxygen build started")

    # note the option ALL which allows to build the docs together with the application
    add_custom_target("doxygen"
        COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT}
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "Generating API documentation with Doxygen"
        VERBATIM)
else()
    message("Doxygen need to be installed to generate the doxygen documentation")
endif()

foreach(source IN LISTS SRCS_ENGINE)
    get_filename_component(source_path "${source}" PATH)
    STRING(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "" source_path ${source_path})
    string(REPLACE "/" "\\" source_path_msvc "${source_path}")
    source_group("${source_path_msvc}" FILES "${source}")
endforeach()

foreach(source IN LISTS SRCS)
    get_filename_component(source_path "${source}" PATH)
    STRING(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "" source_path ${source_path})
    string(REPLACE "/" "\\" source_path_msvc "${source_path}")
    source_group("${source_path_msvc}" FILES "${source}")
endforeach()

message(STATUS "Tree reorganized")