CMakeLists.txt

cmake_minimum_required(VERSION 3.10)
project(LimonEngine)

set(PROJECT_VERSION 0.7)
add_definitions(-DGLM_ENABLE_EXPERIMENTAL)
add_definitions(-DGLM_FORCE_SILENT_WARNINGS)
add_definitions(-DASSIMP_VALIDATE_WORKAROUND)
add_definitions(-DCEREAL_SUPPORT)
add_definitions(-DTICK_PER_SECOND=60)
add_definitions(-DMAX_PYTHON_SCRIPT_COUNT=64)
add_definitions(-DPYTHON_DEBUGGING)
add_definitions(-DSDOC_STATIC)
add_definitions(-DGLM_FORCE_ALIGNED_GTC)
add_definitions(-DTRACY_ENABLE)

option(TRACY_SERVER_ENABLED "Enable the embedded Tracy server" ON)
if(TRACY_SERVER_ENABLED)
    add_definitions(-DTRACY_SERVER_ENABLED)
endif()

#set(CMAKE_VERBOSE_MAKEFILE ON)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})

FUNCTION(disable_postfixes TARGET_NAME)
    set_target_properties(${TARGET_NAME} PROPERTIES
            DEBUG_POSTFIX ""
            RELEASE_POSTFIX ""
            RELWITHDEBINFO_POSTFIX ""
            MINSIZEREL_POSTFIX ""
    )
ENDFUNCTION()

set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
#include(cotire)

# Use CMake's standard way to set C++ version
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

option(ENABLE_ASAN "Enable AddressSanitizer (requires a Clang toolchain, e.g. MSYS2 clang64)" OFF)
if(ENABLE_ASAN)
    message(STATUS "AddressSanitizer enabled")
    add_compile_options(-fsanitize=address -fno-omit-frame-pointer -g)
    add_link_options(-fsanitize=address)
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
        set(SIMD_FLAGS "-msse4.1 -mlzcnt")
    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
        # For 32-bit arm, neon is optional
        set(SIMD_FLAGS "-mfpu=neon")
    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
        # For 64-bit arm, neon is required, no flag needed
        set(SIMD_FLAGS "")
    endif()
endif()

IF (WIN32)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}  ${SIMD_FLAGS}")
    set(CMAKE_EXE_LINKER_FLAGS "-fuse-ld=lld ${CMAKE_EXE_LINKER_FLAGS}")
    set(CMAKE_SHARED_LINKER_FLAGS "-fuse-ld=lld ${CMAKE_SHARED_LINKER_FLAGS}")
    set(CMAKE_MODULE_LINKER_FLAGS "-fuse-ld=lld ${CMAKE_MODULE_LINKER_FLAGS}")
    set(WINDOWS_SPECIFIC_LINK_LIBRARIES "imm32")
else()
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wnon-virtual-dtor -pedantic ${SIMD_FLAGS}")
ENDIF()

IF (UNIX AND ${CMAKE_VERSION} VERSION_GREATER "3.11.0")
    cmake_policy (SET CMP0072 NEW)
ENDIF()
cmake_policy (SET CMP0077 NEW)
set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)

option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
option(LIBS_EXTERNAL_ASSIMP "Provide external assimp library." OFF)
option(LIBS_EXTERNAL_BULLET "Provide external bullet library." OFF)

#Assimp options
set(ASSIMP_NO_EXPORT ON)
set(ASSIMP_BUILD_TESTS OFF)
set(ASSIMP_INSTALL OFF)
set(ASSIMP_BUILD_ASSIMP_TOOLS OFF)
set(ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT ON)
#Assimp options

#Bullet options
set(USE_DOUBLE_PRECISION OFF)
set(BUILD_SHARED_LIBS OFF)
set(BUILD_BULLET3 OFF)
set(BUILD_CPU_DEMOS OFF)
set(USE_GRAPHICAL_BENCHMARK OFF)
set(BULLET2_MULTITHREADING OFF)
set(BULLET2_USE_OPEN_MP_MULTITHREADING OFF)
set(USE_GLUT OFF)
set(BUILD_ENET OFF)
set(BUILD_CLSOCKET OFF)
set(BUILD_PYBULLET OFF)
set(BUILD_CPU_DEMOS OFF)
#Bullet options


# suppress new entries if they were deleted and subproject is disabled
if (NOT LIBS_EXTERNAL_ASSIMP)
    option(ASSIMP_BUILD_TESTS "If the test suite for Assimp is built in addition to the library." OFF)
    option(ASSIMP_INSTALL "Disable this if you want to use assimp as a submodule." OFF)
    option(ASSIMP_NO_EXPORT "Disable Assimp's export functionality." ON)
endif()

if (NOT LIBS_EXTERNAL_BULLET)
    OPTION(USE_GRAPHICAL_BENCHMARK "Use Graphical Benchmark" OFF)
    OPTION(ENABLE_VHACD "Use VHACD in BulletRobotics and pybullet" OFF)
    OPTION(BUILD_EGL "Build OpenGL/EGL" OFF)
endif()

include(libs/CmakeLists.txt)
include_directories(libs/ImGui)
include_directories(${CMAKE_SOURCE_DIR}/src)

file(GLOB_RECURSE SOURCE_FILES src/*.cpp)
list(FILTER SOURCE_FILES EXCLUDE REGEX "ProfilerSystem\\.cpp$")

add_executable(LimonEngine ${SOURCE_FILES})

INCLUDE(FindPkgConfig)

find_package(SDL3 REQUIRED)
find_package(SDL3_image REQUIRED)

include_directories(${SDL3_INCLUDE_DIR}
                    ${SDL3_IMAGE_INCLUDE_DIR})

if (NOT SDL3_image_FOUND)
    message(ERROR " SDL3_Image not found!")
endif (NOT SDL3_image_FOUND)

if(WINDOWS)
    find_package(FREETYPE REQUIRED)
else()
    find_package(Freetype REQUIRED)
endif()
INCLUDE_DIRECTORIES(${FREETYPE_INCLUDE_DIRS})

if (NOT FREETYPE_FOUND)
    message(ERROR " FREETYPE not found!")
endif (NOT FREETYPE_FOUND)

find_package(TinyXML2 REQUIRED)
if (NOT TinyXML2_FOUND)
    message(ERROR " TinyXML2 not found!")
endif (NOT TinyXML2_FOUND)
INCLUDE_DIRECTORIES(${TinyXML2_INCLUDE_DIRS})

find_package(GLEW REQUIRED)
INCLUDE_DIRECTORIES(${GLEW_INCLUDE_DIRS})

find_package(OpenGL REQUIRED)
INCLUDE_DIRECTORIES(${OpenGL_INCLUDE_DIRS})

if (NOT OPENGL_FOUND)
    message(ERROR " OPENGL not found!")
endif (NOT OPENGL_FOUND)

iF(LIBS_EXTERNAL_BULLET)
    message("Using System Bullet")
    find_package(Bullet REQUIRED)
    INCLUDE_DIRECTORIES(SYSTEM ${BULLET_INCLUDE_DIRS})
    message("Bullet Include: ${BULLET_LIBRARIES}")
ELSE ()
    message("Using local Bullet")
    # Set Bullet build options
    set(BUILD_BULLET2_DEMOS OFF CACHE BOOL "Disable Bullet demos" FORCE)
    set(BUILD_OPENGL3_DEMOS OFF CACHE BOOL "Disable OpenGL3 demos" FORCE)
    set(BUILD_BULLET3 OFF CACHE BOOL "Disable Bullet3" FORCE)
    set(BUILD_EXTRAS OFF CACHE BOOL "Disable Bullet extras" FORCE)
    set(BUILD_UNIT_TESTS OFF CACHE BOOL "Disable unit tests" FORCE)
    set(INSTALL_LIBS OFF CACHE BOOL "Disable installation" FORCE)
    set(USE_GLUT OFF CACHE BOOL "Disable GLUT" FORCE)

    message("Using local Bullet from: ${CMAKE_SOURCE_DIR}/libs/bullet")
ENDIF ()
if (NOT BULLET_FOUND)
    message(ERROR " Bullet not found!")
endif (NOT BULLET_FOUND)

find_package(glm REQUIRED)
if (NOT glm_FOUND)
    message(ERROR " GLM not found!")
endif (NOT glm_FOUND)
INCLUDE_DIRECTORIES(SYSTEM ${GLM_INCLUDE_DIRS})

if (LIBS_EXTERNAL_ASSIMP)
    set(LIBS_ASSIMP_INCLUDE_DIR "" CACHE PATH "The main include path")
    set(LIBS_ASSIMP_CONFIG_DIR "" CACHE PATH "The include path with generated config.h")
    set(LIBS_ASSIMP_LIBRARY_DIR "" CACHE PATH "")

    # Let's leave the choice of usage between system-provided libraries and custom-built
    if (LIBS_ASSIMP_INCLUDE_DIR STREQUAL "" OR LIBS_ASSIMP_CONFIG_DIR STREQUAL "" OR LIBS_ASSIMP_LIBRARY_DIR STREQUAL "")
        message(STATUS "Using system Assimp")
        find_package(assimp REQUIRED)
        if (NOT assimp_FOUND)
            message(ERROR " Assimp not found!")
        endif ()
        INCLUDE_DIRECTORIES(SYSTEM ${ASSIMP_INCLUDE_DIRS})

        # TODO test on Apple
        if (APPLE)
            set(ASSIMP_LIBRARIES "/usr/local/lib/libassimp.5.dylib")
        endif(APPLE)
    else()
        message(STATUS "Using external Assimp")
        target_include_directories(LimonEngine PRIVATE "libs/assimp/include")
        target_include_directories(LimonEngine PRIVATE ${LIBS_ASSIMP_INCLUDE_DIR} ${LIBS_ASSIMP_CONFIG_DIR})
        target_link_directories(LimonEngine PRIVATE ${LIBS_ASSIMP_LIBRARY_DIR})
    endif()
endif()


add_custom_target(copyData
        COMMAND ${CMAKE_COMMAND} -E copy_directory
        ${CMAKE_SOURCE_DIR}/Engine ${CMAKE_BINARY_DIR}/Engine)
add_dependencies(LimonEngine copyData)

TARGET_LINK_LIBRARIES(LimonEngine ProfilerSystemLib ImGui ImGuizmo OpenAL meshoptimizer nodeGraph assimp pybind11::embed SDOC.quic TracyClient TracyServer ${WINDOWS_SPECIFIC_LINK_LIBRARIES} ${TinyXML2_LIBRARIES} ${BULLET_LIBRARIES} SDL3::SDL3 ${FREETYPE_LIBRARIES} SDL3_image::SDL3_image)

# Optional: Wayland fullscreen viewport scaling fix (Linux/Pi only)
if(UNIX AND NOT APPLE)
    pkg_check_modules(WAYLAND_CLIENT QUIET wayland-client)
    if(WAYLAND_CLIENT_FOUND)
        message(STATUS "wayland-client found -- Wayland fullscreen viewport fix enabled")
        target_compile_definitions(LimonEngine PRIVATE HAS_WAYLAND)
        target_include_directories(LimonEngine PRIVATE ${WAYLAND_CLIENT_INCLUDE_DIRS})
        target_link_libraries(LimonEngine ${WAYLAND_CLIENT_LIBRARIES})
    else()
        message(STATUS "wayland-client not found -- Wayland fullscreen viewport fix disabled")
    endif()
endif()
target_precompile_headers(LimonEngine PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/stdafx.h)

IF (WIN32)
    target_sources(LimonEngine PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/resources/limonEngine.rc")
ENDIF()

add_library(LimonAPI STATIC
        src/limonAPI/TriggerInterface.cpp
        src/limonAPI/PlayerExtensionInterface.cpp
        src/limonAPI/ActorInterface.cpp
        src/limonAPI/LimonAPI.cpp
        src/limonAPI/InputStates.cpp
        src/limonAPI/ProfileScope.cpp
        src/limonAPI/LimonConverter.h
        src/limonAPI/LimonTypes.h
        src/Options.cpp
        )
disable_postfixes(LimonAPI)
# All consumers of LimonAPI (backends, plugins) get TracyClient.dll linked in and
# TRACY_IMPORTS defined automatically via this INTERFACE dependency.
target_link_libraries(LimonAPI INTERFACE TracyClient)

file(GLOB API_HEADERS
        "src/limonAPI/*.h"
        )

file(GLOB API_UTIL_HEADERS
        "src/limonAPI/util/*.h"
)


target_precompile_headers(LimonAPI PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/stdafx.h)

set_property(TARGET LimonAPI PROPERTY POSITION_INDEPENDENT_CODE ON)
add_custom_command(TARGET LimonAPI POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_DIR}/LimonAPI/
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/LimonAPI/include/limonAPI/
    COMMAND ${CMAKE_COMMAND} -E copy ${API_HEADERS} ${CMAKE_BINARY_DIR}/LimonAPI/include/limonAPI/
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/LimonAPI/include/limonAPI/util/
    COMMAND ${CMAKE_COMMAND} -E copy ${API_UTIL_HEADERS} ${CMAKE_BINARY_DIR}/LimonAPI/include/limonAPI/util
    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/src/limonAPI/CMakeLists.txt ${CMAKE_BINARY_DIR}/LimonAPI/
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/LimonAPI/lib
    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/$<TARGET_FILE_NAME:LimonAPI> ${CMAKE_BINARY_DIR}/LimonAPI/lib
    COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/LimonAPI/src
    COMMAND ${CMAKE_COMMAND} -E tar "cfv" "LimonAPI.zip" --format=zip -- ${CMAKE_BINARY_DIR}/LimonAPI
    COMMAND echo "Building api project done"
)

add_library(customTriggers SHARED
        samples/CoinPickUpOnTrigger.cpp
        samples/MayanCoinPickup.cpp
        samples/MayanLever.cpp
        samples/DoorAnimationAction.cpp
        samples/ShooterPlayerExtension.cpp
        samples/HumanEnemy.cpp
        samples/CowboyShooterExtension.cpp
        samples/CowboyEnemyAI.cpp
        samples/WesternMenuPlayerExtension.cpp
        samples/WesternMenuPlayerExtension.h
        samples/KillCowboyPlayer.cpp
        samples/WesternStoryStartupAction.cpp
        samples/WesternStoryAtGraveAction.cpp
        samples/WesternStoryAtUndertakerAction.cpp
        samples/WesternStoryAtSaloonAction.cpp
        samples/WesternStoryAtTrainAction.cpp
        samples/WesternStoryNewGameAction.cpp
        samples/SSAOKernelRenderMethod.cpp
        samples/WaterRenderMethod.cpp
        samples/OptionsDisplayAction.cpp
        )
disable_postfixes(customTriggers)

TARGET_LINK_LIBRARIES(customTriggers LimonAPI)
add_dependencies(LimonEngine customTriggers)

set_target_properties(customTriggers PROPERTIES VERSION ${PROJECT_VERSION})
set_target_properties(customTriggers PROPERTIES SOVERSION 1)

# SHARED BACKEND FILES
set(GRAPHICS_BASE_SOURCES
        src/limonAPI/Graphics/GraphicsProgram.cpp
        src/limonAPI/Graphics/GraphicsProgramPreprocessor.cpp
        src/Assets/GraphicsProgramAsset.cpp
)

# --- 1. OpenGL Backend ---
add_library(OpenGLGraphicsBackend SHARED
        ${GRAPHICS_BASE_SOURCES}
        GraphicBackends/OpenGLGraphics.cpp
)
disable_postfixes(OpenGLGraphicsBackend)
target_precompile_headers(OpenGLGraphicsBackend PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/stdafx.h)

TARGET_LINK_LIBRARIES(OpenGLGraphicsBackend LimonAPI GLEW::GLEW ${OPENGL_LIBRARIES})

set_target_properties(OpenGLGraphicsBackend PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION 1)
add_dependencies(LimonEngine OpenGLGraphicsBackend)
# --- END OpenGL Backend ---

# --- 2. OpenGLES Backend ---
add_library(OpenGLESGraphicsBackend SHARED
        ${GRAPHICS_BASE_SOURCES}
        GraphicBackends/OpenGLESGraphics.cpp
)
disable_postfixes(OpenGLESGraphicsBackend)
target_precompile_headers(OpenGLESGraphicsBackend PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/stdafx.h)

if(WIN32)
    # On windows, WGL ES will resolve them ,nothing else needed.
    TARGET_LINK_LIBRARIES(OpenGLESGraphicsBackend LimonAPI GLEW::GLEW ${OPENGL_LIBRARIES})
else()
    # Raspberry Pi / Linux needs native ES libraries
    TARGET_LINK_LIBRARIES(OpenGLESGraphicsBackend LimonAPI GLEW::GLEW GLESv2 EGL)
endif()

set_target_properties(OpenGLESGraphicsBackend PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION 1)
add_dependencies(LimonEngine OpenGLESGraphicsBackend)
# --- END OpenGLES Backend ---

# Add the definition to all targets
include(BundlePython)
find_python_environment()
file(RELATIVE_PATH PYTHON_BUNDLE_ZIP_RELATIVE "${CMAKE_BINARY_DIR}" "${PYTHON_BUNDLE_ZIP}")
add_compile_definitions(PYTHON_BUNDLE_ZIP="${PYTHON_BUNDLE_ZIP_RELATIVE}")
message("Python bundle will be in ${PYTHON_BUNDLE_ZIP_RELATIVE} (relative to build directory)")
# Only bundle Python if PYTHON_BUNDLE_ZIP doesn't exist
if(NOT EXISTS "${PYTHON_BUNDLE_ZIP}")
    message(STATUS "Python bundle not found at ${PYTHON_BUNDLE_ZIP}, creating...")
    if(TARGET LimonEngine)
        bundle_python_environment(LimonEngine)
    endif()
else()
    message(STATUS "Using existing Python bundle at ${PYTHON_BUNDLE_ZIP}")
endif()


#cotire(LimonEngine)