-
Notifications
You must be signed in to change notification settings - Fork 129
/
CMakeLists.txt
338 lines (290 loc) · 13 KB
/
CMakeLists.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
cmake_minimum_required(VERSION 3.25 FATAL_ERROR)
set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT Embedded)
cmake_policy(SET CMP0141 NEW)
set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build libraries static" FORCE)
# Docs flags
if (GEODE_BUILDING_DOCS)
set(GEODE_DISABLE_CLI_CALLS ON)
set(GEODE_DISABLE_PRECOMPILED_HEADERS ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(GEODE_DONT_BUILD_TEST_MODS ON)
endif()
option(GEODE_USE_BREAKPAD "Enables the use of the Breakpad library for crash dumps." ON)
# Read version
file(READ VERSION GEODE_VERSION)
string(STRIP "${GEODE_VERSION}" GEODE_VERSION)
set(GEODE_VERSION "${GEODE_VERSION}" CACHE INTERNAL "Geode version")
set(GEODE_VERSION_FULL "${GEODE_VERSION}" CACHE INTERNAL "Geode version full")
# Check if version has a tag like v1.0.0-alpha
string(FIND ${GEODE_VERSION} "-" GEODE_VERSION_HAS_TAG)
if (NOT ${GEODE_VERSION_HAS_TAG} EQUAL "-1")
string(REGEX MATCH "[a-z]+(\.[0-9]+)?$" GEODE_VERSION_TAG ${GEODE_VERSION})
string(SUBSTRING "${GEODE_VERSION}" 0 ${GEODE_VERSION_HAS_TAG} GEODE_VERSION)
string(FIND ${GEODE_VERSION_TAG} "." GEODE_VERSION_TAG_HAS_NUMBER)
# Extract tag type and number from tag
if (NOT ${GEODE_VERSION_TAG_HAS_NUMBER} EQUAL "-1")
string(SUBSTRING "${GEODE_VERSION_TAG}" 0 ${GEODE_VERSION_TAG_HAS_NUMBER} GEODE_VERSION_TAG_TYPE)
math(EXPR GEODE_VERSION_TAG_HAS_NUMBER "${GEODE_VERSION_TAG_HAS_NUMBER} + 1")
string(SUBSTRING "${GEODE_VERSION_TAG}" ${GEODE_VERSION_TAG_HAS_NUMBER} -1 GEODE_VERSION_TAG_NUMBER)
else()
set(GEODE_VERSION_TAG_TYPE "${GEODE_VERSION_TAG}")
set(GEODE_VERSION_TAG_NUMBER "")
endif()
# Capitalize first letter of tag type
string(SUBSTRING ${GEODE_VERSION_TAG_TYPE} 0 1 FIRST_LETTER)
string(TOUPPER ${FIRST_LETTER} FIRST_LETTER)
string(REGEX REPLACE "^.(.*)" "${FIRST_LETTER}\\1" GEODE_VERSION_TAG_TYPE "${GEODE_VERSION_TAG_TYPE}")
message(STATUS "Version: ${GEODE_VERSION}, tag: ${GEODE_VERSION_TAG} (type: ${GEODE_VERSION_TAG_TYPE}, number: ${GEODE_VERSION_TAG_NUMBER})")
else()
set(GEODE_VERSION_TAG "")
set(GEODE_VERSION_TAG_TYPE "")
set(GEODE_VERSION_TAG_NUMBER "")
message(STATUS "Version: ${GEODE_VERSION}")
endif()
include(cmake/CPM.cmake)
if (NOT DEFINED CPM_SOURCE_CACHE)
message(NOTICE "Not using CPM cache (CPM_SOURCE_CACHE). "
"It is recommended to use it to improve configure times.")
endif()
# Allow users to have their own copy of bindings that can be overwritten with a CMake option.
# If the option is not provided, by default just clone bindings with CPM and use that
if (DEFINED ENV{GEODE_BINDINGS_REPO_PATH})
set(temp $ENV{GEODE_BINDINGS_REPO_PATH})
# this is so stupid i hate windows paths
string(REPLACE "\\" "/" GEODE_BINDINGS_REPO_PATH ${temp})
endif()
if (NOT GEODE_BINDINGS_REPO_PATH)
message(STATUS
"No override path for bindings provided, using CPM to clone default. "
"If you would like to use a separate clone of the bindings repo "
"(for example in order to be able to efficiently change and "
"contribute new bindings) then set GEODE_BINDINGS_REPO_PATH to where you have "
"cloned the repository (system environment variables are supported)."
)
CPMAddPackage(NAME "bindings"
GITHUB_REPOSITORY "geode-sdk/bindings"
GIT_TAG "main"
DOWNLOAD_ONLY YES
NO_CACHE YES
)
set(GEODE_BINDINGS_REPO_PATH ${bindings_SOURCE_DIR})
else()
message(STATUS "Using ${GEODE_BINDINGS_REPO_PATH} for bindings repo")
endif()
project(geode-sdk VERSION ${GEODE_VERSION} LANGUAGES CXX C)
if (NOT GEODE_DONT_USE_CCACHE)
message(STATUS "Looking for ccache/sccache")
if (DEFINED CMAKE_C_COMPILER_LAUNCHER OR DEFINED CMAKE_CXX_COMPILER_LAUNCHER)
message(STATUS "Looking for ccache/sccache - detecting variant")
if (DEFINED CMAKE_C_COMPILER_LAUNCHER AND DEFINED CMAKE_CXX_COMPILER_LAUNCHER AND
CMAKE_C_COMPILER_LAUNCHER STREQUAL CMAKE_CXX_COMPILER_LAUNCHER)
if (CMAKE_CXX_COMPILER_LAUNCHER MATCHES "sccache(|.exe)$")
message(STATUS "Looking for ccache/sccache - detected sccache")
set(GEODE_CCACHE_VARIANT "sccache")
elseif(CMAKE_CXX_COMPILER_LAUNCHER MATCHES "ccache(|.exe)$")
message(STATUS "Looking for ccache/sccache - detected ccache")
set(GEODE_CCACHE_VARIANT "ccache")
else()
message(STATUS "Looking for ccache/sccache - none (custom compiler launcher: {CMAKE_C_COMPILER_LAUNCHER}, {CMAKE_CXX_COMPILER_LAUNCHER})")
endif()
else()
message(STATUS "Looking for ccache/sccache - skipped (custom compiler launcher: {CMAKE_C_COMPILER_LAUNCHER}, {CMAKE_CXX_COMPILER_LAUNCHER})")
endif()
elseif (CMAKE_GENERATOR MATCHES "Visual Studio")
message(STATUS "Looking for ccache/sccache - skipped (Visual Studio generator)")
else()
find_program(GEODE_CCACHE NAMES sccache ccache)
if (GEODE_CCACHE)
if (${GEODE_CCACHE} MATCHES "sccache(|.exe)$")
set(GEODE_CCACHE_VARIANT "sccache")
else()
set(GEODE_CCACHE_VARIANT "ccache")
endif()
message(STATUS "Looking for ccache/sccache - found ${GEODE_CCACHE_VARIANT}")
message(NOTICE "Compiler launcher not set but ccache/sccache was found. "
"Setting compiler launcher to that")
set(CMAKE_C_COMPILER_LAUNCHER ${GEODE_CCACHE})
set(CMAKE_CXX_COMPILER_LAUNCHER ${GEODE_CCACHE})
else()
message(STATUS "Looking for ccache/sccache - not found")
endif()
unset(GEODE_CCACHE)
endif()
else()
message(STATUS "Not looking for ccache because GEODE_DONT_USE_CCACHE was ON")
endif()
if (DEFINED GEODE_CCACHE_VARIANT)
if (NOT DEFINED GEODE_DISABLE_PRECOMPILED_HEADERS)
if (${GEODE_CCACHE_VARIANT} STREQUAL "sccache" AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if (APPLE AND DEFINED CMAKE_OSX_ARCHITECTURES AND (CMAKE_OSX_ARCHITECTURES STREQUAL "arm64;x86_64" OR CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64;arm64"))
message(NOTICE "Using ${GEODE_CCACHE_VARIANT} with ${CMAKE_CXX_COMPILER_ID} while building multiple architectures, PCH will be disabled due to issues with sccache.")
message("(You can override this by setting GEODE_DISABLE_PRECOMPILED_HEADERS to ON).")
set(GEODE_DISABLE_PRECOMPILED_HEADERS ON)
else()
message(NOTICE "Using ${GEODE_CCACHE_VARIANT} with ${CMAKE_CXX_COMPILER_ID}, PCH will be enabled.")
set(GEODE_DISABLE_PRECOMPILED_HEADERS OFF)
endif()
else()
message(NOTICE "Using ${GEODE_CCACHE_VARIANT} with ${CMAKE_CXX_COMPILER_ID}, PCH will be disabled.")
set(GEODE_DISABLE_PRECOMPILED_HEADERS ON)
endif()
endif()
else()
if (APPLE)
# when building for multiple architectures, a caching compiler is not recommended
message(NOTICE "Not using a caching compiler (ccache/sccache).")
else()
message(NOTICE "Not using a caching compiler (ccache/sccache). "
"It is recommended to install one to improve build times.")
message(NOTICE "We recommend sccache, check its README for installation instructions, "
"normally you can just use your usual package manager (e.g. 'scoop install sccache').")
endif()
if (NOT DEFINED GEODE_DISABLE_PRECOMPILED_HEADERS)
message(NOTICE "Because of this, PCH will be enabled.")
set(GEODE_DISABLE_PRECOMPILED_HEADERS OFF)
endif()
endif()
if (NOT DEFINED GEODE_DISABLE_PRECOMPILED_HEADERS)
set(GEODE_DISABLE_PRECOMPILED_HEADERS OFF)
endif()
if (GEODE_DISABLE_PRECOMPILED_HEADERS)
message(STATUS "Pre-compiled headers - OFF")
else()
message(STATUS "Pre-compiled headers - ON")
endif()
add_library(${PROJECT_NAME} INTERFACE)
# Rerun CMake on VERSION file change
set_target_properties(${PROJECT_NAME} PROPERTIES CMAKE_CONFIGURE_DEPENDS VERSION)
target_compile_definitions(${PROJECT_NAME} INTERFACE -DPROJECT_NAME=${CMAKE_PROJECT_NAME})
set(GEODE_BIN_PATH ${CMAKE_CURRENT_SOURCE_DIR}/bin)
set(GEODE_LOADER_PATH ${CMAKE_CURRENT_SOURCE_DIR}/loader)
set(GEODE_ROOT_PATH ${CMAKE_CURRENT_SOURCE_DIR})
include(cmake/Platform.cmake)
include(cmake/GeodeFile.cmake)
if (NOT DEFINED GEODE_GD_VERSION)
set(GEODE_GD_VERSION 2.2074)
set(GEODE_COMP_GD_VERSION 22074)
endif()
target_compile_definitions(
${PROJECT_NAME} INTERFACE
GEODE_GD_VERSION=${GEODE_GD_VERSION}
GEODE_COMP_GD_VERSION=${GEODE_COMP_GD_VERSION}
GEODE_GD_VERSION_STRING="${GEODE_GD_VERSION}"
)
if (WIN32)
# This allows you to compile in debug mode
# add_compile_definitions(_HAS_ITERATOR_DEBUGGING=0)
add_definitions(-D_HAS_ITERATOR_DEBUGGING=0)
target_compile_definitions(${PROJECT_NAME} INTERFACE _HAS_ITERATOR_DEBUGGING=0)
target_link_libraries(${PROJECT_NAME} INTERFACE delayimp ws2_32)
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND
CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
# target x86 on windows with clang
target_compile_options(${PROJECT_NAME} INTERFACE --target=x86_64-pc-windows-msvc)
target_link_options(${PROJECT_NAME} INTERFACE --target=x86_64-pc-windows-msvc)
add_compile_options(--target=x86_64-pc-windows-msvc)
add_link_options(--target=x86_64-pc-windows-msvc)
endif()
endif()
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# force an error on a missing return type, as this is unfortunately a common mistake people make
target_compile_options(${PROJECT_NAME} INTERFACE -Werror=return-type)
endif()
# if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
# set_property(TARGET ${PROJECT_NAME} PROPERTY LINKER_TYPE LLD)
# target_link_options(${PROJECT_NAME} INTERFACE -fuse-ld=lld)
# endif ()
# We do not support anything below SDK 23
if (ANDROID)
string(REGEX MATCH "[0-9]+" ANDROID_PLATFORM_NUMBER "${ANDROID_PLATFORM}")
if (ANDROID_PLATFORM_NUMBER LESS 23)
message(FATAL_ERROR "Specified target Android SDK version is too low (${ANDROID_PLATFORM_NUMBER}), must be 23 or higher")
endif()
endif()
set(MAT_JSON_AS_INTERFACE ON)
CPMAddPackage("gh:geode-sdk/[email protected]")
CPMAddPackage("gh:geode-sdk/[email protected]")
CPMAddPackage("gh:fmtlib/fmt#11.0.2")
target_compile_definitions(${PROJECT_NAME} INTERFACE MAT_JSON_DYNAMIC=1)
# this is needed for cross compilation on linux,
# since fmtlib will fail to compile otherwise
if (GEODE_DISABLE_FMT_CONSTEVAL)
message(VERBOSE "Disabling FMT_CONSTEVAL")
target_compile_definitions(fmt PUBLIC -DFMT_CONSTEVAL=)
endif()
# Tulip hook (hooking)
if (PROJECT_IS_TOP_LEVEL AND NOT GEODE_BUILDING_DOCS)
set(TULIP_LINK_SOURCE ON)
endif()
set(CMAKE_WARN_DEPRECATED OFF CACHE BOOL "" FORCE)
# Allow users to have their own copy of TulipHook that can be overwritten with a CMake option.
# If the option is not provided, by default just clone TulipHook with CPM and use that
if (DEFINED ENV{GEODE_TULIPHOOK_REPO_PATH})
set(temp $ENV{GEODE_TULIPHOOK_REPO_PATH})
# this is so stupid i hate windows paths
string(REPLACE "\\" "/" GEODE_TULIPHOOK_REPO_PATH ${temp})
endif()
if (DEFINED GEODE_TULIPHOOK_REPO_PATH)
message(STATUS "Using ${GEODE_TULIPHOOK_REPO_PATH} for TulipHook")
add_subdirectory(${GEODE_TULIPHOOK_REPO_PATH} ${GEODE_TULIPHOOK_REPO_PATH}/build)
else()
CPMAddPackage("gh:geode-sdk/[email protected]")
endif()
set(CMAKE_WARN_DEPRECATED ON CACHE BOOL "" FORCE)
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(-Wno-everything SUPPORTS_W_NO_EVERYTHING)
if (SUPPORTS_W_NO_EVERYTHING)
# Silence warnings from dependencies
if (TARGET capstone)
target_compile_options(capstone PRIVATE -Wno-everything)
endif()
endif()
target_sources(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/entry.cpp)
add_subdirectory(${GEODE_BINDINGS_REPO_PATH} ${CMAKE_BINARY_DIR}/bindings)
if (NOT GEODE_DISABLE_PRECOMPILED_HEADERS)
target_precompile_headers(GeodeBindings INTERFACE
"$<$<COMPILE_LANGUAGE:CXX>:${GEODE_LOADER_PATH}/include/Geode/Bindings.hpp>"
)
endif()
target_include_directories(GeodeBindings PUBLIC
${GEODE_LOADER_PATH}/include
${GEODE_LOADER_PATH}/include/Geode/cocos/include
${GEODE_LOADER_PATH}/include/Geode/cocos/extensions
${GEODE_LOADER_PATH}/include/Geode/fmod
)
target_link_directories(GeodeBindings PUBLIC ${GEODE_LOADER_PATH}/include/link)
target_link_libraries(GeodeBindings PUBLIC fmt TulipHookInclude mat-json GeodeResult)
target_link_libraries(${PROJECT_NAME} INTERFACE GeodeBindings)
if (NOT EXISTS ${GEODE_BIN_PATH})
file(MAKE_DIRECTORY ${GEODE_BIN_PATH})
endif()
if (NOT EXISTS ${GEODE_BIN_PATH}/${PROJECT_VERSION} AND EXISTS ${GEODE_BIN_PATH}/nightly/)
set(GEODE_LINK_NIGHTLY 1)
endif()
if (${GEODE_LINK_NIGHTLY})
set(GEODE_PLATFORM_BIN_PATH ${GEODE_BIN_PATH}/nightly/${GEODE_PLATFORM_BINARY})
else()
set(GEODE_PLATFORM_BIN_PATH ${GEODE_BIN_PATH}/${PROJECT_VERSION}/${GEODE_PLATFORM_BINARY})
endif()
if (PROJECT_IS_TOP_LEVEL)
add_subdirectory(loader)
target_link_libraries(${PROJECT_NAME} INTERFACE geode-loader)
if (SUPPORTS_W_NO_EVERYTHING)
target_compile_options(geode-loader PRIVATE -Wno-inconsistent-missing-override)
endif()
elseif (EXISTS ${GEODE_PLATFORM_BIN_PATH})
target_link_libraries(${PROJECT_NAME} INTERFACE "${GEODE_PLATFORM_BIN_PATH}")
if (NOT GEODE_DISABLE_PRECOMPILED_HEADERS)
target_precompile_headers(${PROJECT_NAME} INTERFACE
"$<$<COMPILE_LANGUAGE:CXX>:${GEODE_LOADER_PATH}/include/Geode/DefaultInclude.hpp>"
"$<$<COMPILE_LANGUAGE:CXX>:${GEODE_LOADER_PATH}/include/Geode/Geode.hpp>"
# please stop adding modify here its not here because it makes windows compilation take longer than geode 1.0 release date
)
endif()
else()
message(FATAL_ERROR
"No valid loader binary to link to! Install pre-built binaries with `geode sdk install-binaries`, "
"or build Geode from source and add `set(GEODE_LINK_NIGHTLY ON)` to your CMakeLists.txt "
"in the line before calling add_subdirectory for Geode."
)
endif()