mirrors/yuzu
2
1
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-07-04 23:31:19 +01:00
Code Issues Releases Activity
yuzu/src/CMakeLists.txt

166 lines
6.4 KiB
Text
Raw Normal View History

CMake cleanup Several cleanups to the buildsystem: - Do better factoring of common libs between platforms. - Add support to building on Windows. - Remove Qt4 support. - Re-sort file lists and add missing headers.
2014-08-24 02:22:05 +01:00
# Enable modules to include each other's files
include_directories(.)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
# CMake seems to only define _DEBUG on Windows
set_property(DIRECTORY APPEND PROPERTY
COMPILE_DEFINITIONS $<$<CONFIG:Debug>:_DEBUG> $<$<NOT:$<CONFIG:Debug>>:NDEBUG>)
# Set compilation flags
if (MSVC)
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
set(CMAKE_CONFIGURATION_TYPES Debug Release CACHE STRING "" FORCE)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
# Silence "deprecation" warnings
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
add_definitions(-D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
# Avoid windows.h junk
add_definitions(-DNOMINMAX)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
# Avoid windows.h from including some usually unused libs like winsocks.h, since this might cause some redefinition errors.
add_definitions(-DWIN32_LEAN_AND_MEAN)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
CMakeLists: Ensure we specify Unicode as the codepage on Windows Previously we were building with MBCS, which is pretty undesirable. We want the application to be Unicode-aware in general. Currently, we make the command line variant of yuzu use ANSI variants of the non-standard getopt functions that we link in for Windows, given we only have an ANSI option-set. We should really replace getopt with a library that we make all build types of yuzu link in, but this will have to do for the time being.
2019-04-15 22:32:47 +01:00
# Ensure that projects build with Unicode support.
add_definitions(-DUNICODE -D_UNICODE)
src/CMakeLists: Add /Zc:externConstexpr to the MSVC build flags The C++ standard allows constexpr variables declared with the extern keyword to have external linkage. Previously MSVC wasn't abiding by this. This just makes the compiler more standards compliant during builds. Given we currently don't make use of anything that would break by this, this is safe to enable.
2019-05-07 19:06:20 +01:00
# /W3 - Level 3 warnings
# /MP - Multi-threaded compilation
# /Zi - Output debugging information
CMakeLists: Specify /Zm200 when compiling in MSVC This increases the memory heap size for constructing precompiled headers to 2x the default.
2021-12-07 00:14:29 +00:00
# /Zm - Specifies the precompiled header memory allocation limit
src/CMakeLists: Add /Zc:externConstexpr to the MSVC build flags The C++ standard allows constexpr variables declared with the extern keyword to have external linkage. Previously MSVC wasn't abiding by this. This just makes the compiler more standards compliant during builds. Given we currently don't make use of anything that would break by this, this is safe to enable.
2019-05-07 19:06:20 +01:00
# /Zo - Enhanced debug info for optimized builds
# /permissive- - Enables stricter C++ standards conformance checks
# /EHsc - C++-only exception handling semantics
CMakeLists: Add /utf-8 compile option for MSVC Ensures that the source and execution character sets are in UTF-8
2021-03-05 06:46:56 +00:00
# /utf-8 - Set source and execution character sets to UTF-8
CMakeLists: Specify /volatile:iso for MSVC By default, MSVC doesn't use standards-compliant volatile semantics. This makes it behave in a standards-compliant manner, making expectations more uniform across compilers.
2019-05-09 20:49:27 +01:00
# /volatile:iso - Use strict standards-compliant volatile semantics.
src/CMakeLists: Add /Zc:externConstexpr to the MSVC build flags The C++ standard allows constexpr variables declared with the extern keyword to have external linkage. Previously MSVC wasn't abiding by this. This just makes the compiler more standards compliant during builds. Given we currently don't make use of anything that would break by this, this is safe to enable.
2019-05-07 19:06:20 +01:00
# /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
# /Zc:inline - Let codegen omit inline functions in object files
# /Zc:throwingNew - Let codegen assume `operator new` (without std::nothrow) will never return null
CMakeLists: Document the /GT compile option
2021-10-29 01:43:46 +01:00
# /GT - Supports fiber safety for data allocated using static thread-local storage
src/CMakeLists: Vertically order compilation flags Makes it much nicer to visually scan the options. This also starts the flag descriptions from the same column for the same reason.
2019-05-07 19:02:29 +01:00
add_compile_options(
/MP
/Zi
CMakeLists: Specify /Zm200 when compiling in MSVC This increases the memory heap size for constructing precompiled headers to 2x the default.
2021-12-07 00:14:29 +00:00
/Zm200
src/CMakeLists: Vertically order compilation flags Makes it much nicer to visually scan the options. This also starts the flag descriptions from the same column for the same reason.
2019-05-07 19:02:29 +01:00
/Zo
/permissive-
/EHsc
/std:c++latest
CMakeLists: Add /utf-8 compile option for MSVC Ensures that the source and execution character sets are in UTF-8
2021-03-05 06:46:56 +00:00
/utf-8
CMakeLists: Specify /volatile:iso for MSVC By default, MSVC doesn't use standards-compliant volatile semantics. This makes it behave in a standards-compliant manner, making expectations more uniform across compilers.
2019-05-09 20:49:27 +01:00
/volatile:iso
src/CMakeLists: Add /Zc:externConstexpr to the MSVC build flags The C++ standard allows constexpr variables declared with the extern keyword to have external linkage. Previously MSVC wasn't abiding by this. This just makes the compiler more standards compliant during builds. Given we currently don't make use of anything that would break by this, this is safe to enable.
2019-05-07 19:06:20 +01:00
/Zc:externConstexpr
src/CMakeLists: Vertically order compilation flags Makes it much nicer to visually scan the options. This also starts the flag descriptions from the same column for the same reason.
2019-05-07 19:02:29 +01:00
/Zc:inline
/Zc:throwingNew
Build System: Build with JCC Erratum Mitigation
2021-09-13 21:30:30 +01:00
/GT
General: Make ignoring a discarded return value an error Allows our CI to catch more potential bugs. This also removes the [[nodiscard]] attribute of IOFile's Open member function. There are cases where a file may want to be opened, but have the status of it checked at a later time.
2020-10-30 03:30:42 +00:00
CMakeLists: Disable all warnings for external headers This lets us avoid needing to wrap external headers with #pragma warning directives for warnings we treat as errors and avoids generating warnings for external code. Thanks to MerryMage for pointing this out.
2021-06-28 19:23:41 +01:00
# External headers diagnostics
/experimental:external # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
/external:anglebrackets # Treats all headers included by #include <header>, where the header file is enclosed in angle brackets (< >), as external headers
/external:W0 # Sets the default warning level to 0 for external headers, effectively turning off warnings for external headers
General: Make ignoring a discarded return value an error Allows our CI to catch more potential bugs. This also removes the [[nodiscard]] attribute of IOFile's Open member function. There are cases where a file may want to be opened, but have the status of it checked at a later time.
2020-10-30 03:30:42 +00:00
# Warnings
/W3
CMakeLists: Enforce C4018, C4267, C4305, C4389
2021-06-28 08:55:21 +01:00
/we4018 # 'expression': signed/unsigned mismatch
/we4062 # Enumerator 'identifier' in a switch of enum 'enumeration' is not handled
cmake: Enforce C4101 This matches GCC's -Wunused-variable
2021-01-10 06:16:25 +00:00
/we4101 # 'identifier': unreferenced local variable
CMakeLists: Enforce C4189 This supplements C4101 by detecting initialized but unreferenced local variables
2021-07-03 10:51:31 +01:00
/we4189 # 'identifier': local variable is initialized but not referenced
cmake: Enforce C4062, C4265, C4388, and C5038 This should match some warnings we treat as errors on gcc and clang, caching bugs early and reducing the number of instances where we have to edit commits to make CI happy when developing from Windows.
2021-01-09 03:21:53 +00:00
/we4265 # 'class': class has virtual functions, but destructor is not virtual
CMakeLists: Enforce C4018, C4267, C4305, C4389
2021-06-28 08:55:21 +01:00
/we4267 # 'var': conversion from 'size_t' to 'type', possible loss of data
/we4305 # 'context': truncation from 'type1' to 'type2'
/we4388 # 'expression': signed/unsigned mismatch
/we4389 # 'operator': signed/unsigned mismatch
CMakeLists: Enforce C4505 and C5245 These are similar to Wunused-function on gcc/clang
2022-04-08 04:00:04 +01:00
/we4505 # 'function': unreferenced local function has been removed
CMakeLists: Enforce C4018, C4267, C4305, C4389
2021-06-28 08:55:21 +01:00
/we4547 # 'operator': operator before comma has no effect; expected operator with side-effect
General: Catch more expressions with no effect on MSVC MSVC lets us fine-tune catching expressions with no side-effects a little more.
2020-10-30 03:36:44 +00:00
/we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
/we4555 # Expression has no effect; expected expression with side-effect
CMakeLists: Enforce C4715 on MSVC This is similar to -Werror=return-type
2021-05-17 08:46:40 +01:00
/we4715 # 'function': not all control paths return a value
General: Make ignoring a discarded return value an error Allows our CI to catch more potential bugs. This also removes the [[nodiscard]] attribute of IOFile's Open member function. There are cases where a file may want to be opened, but have the status of it checked at a later time.
2020-10-30 03:30:42 +00:00
/we4834 # Discarding return value of function with 'nodiscard' attribute
cmake: Enforce C4062, C4265, C4388, and C5038 This should match some warnings we treat as errors on gcc and clang, caching bugs early and reducing the number of instances where we have to edit commits to make CI happy when developing from Windows.
2021-01-09 03:21:53 +00:00
/we5038 # data member 'member1' will be initialized after data member 'member2'
CMakeLists: Enforce C4505 and C5245 These are similar to Wunused-function on gcc/clang
2022-04-08 04:00:04 +01:00
/we5245 # 'function': unreferenced function with internal linkage has been removed
src/CMakeLists: Vertically order compilation flags Makes it much nicer to visually scan the options. This also starts the flag descriptions from the same column for the same reason.
2019-05-07 19:02:29 +01:00
)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
Build System: Build with JCC Erratum Mitigation
2021-09-13 21:30:30 +01:00
if (ARCHITECTURE_x86_64)
add_compile_options(/QIntel-jcc-erratum)
endif()
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
# /GS- - No stack buffer overflow checks
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
add_compile_options("$<$<CONFIG:Release>:/GS->")
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
set(CMAKE_EXE_LINKER_FLAGS_DEBUG "/DEBUG /MANIFEST:NO" CACHE STRING "" FORCE)
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
else()
CMakeLists: Explicitly specify -Wall for the non-MSVC case Ensures that -Wall is always active as a compilation flag.
2019-05-04 07:06:55 +01:00
add_compile_options(
-Wall
cmake: Enforce -Warray-bounds and -Wmissing-field-initializers globally
2021-01-24 20:31:29 +00:00
-Werror=array-bounds
CMakeLists: Specify -Wextra on linux builds Allows reporting more cases where logic errors may exist, such as implicit fallthrough cases, etc. We currently ignore unused parameters, since we currently have many cases where this is intentional (virtual interfaces). While we're at it, we can also tidy up any existing code that causes warnings. This also uncovered a few bugs as well.
2020-04-15 20:59:23 +01:00
-Werror=implicit-fallthrough
CMakeLists: Make missing declarations a compile-time error Ensures that our code always has its linkage explicit.
2020-04-17 04:23:57 +01:00
-Werror=missing-declarations
cmake: Enforce -Warray-bounds and -Wmissing-field-initializers globally
2021-01-24 20:31:29 +00:00
-Werror=missing-field-initializers
CMakeLists: Make -Wreorder a compile-time error This can result in silent logic bugs within code, and given the amount of times these kind of warnings are caused, they should be flagged at compile-time so no new code is submitted with them.
2020-04-15 18:28:28 +01:00
-Werror=reorder
CMakeLists: Treat -Wsign-compare as an error on GCC/Clang Treats (un)signed comparison mismatches as errors to be consistent with MSVC
2021-07-06 17:48:49 +01:00
-Werror=sign-compare
cmake: Enforce -Werror=switch and -Werror=unused-variable
2021-01-13 06:52:30 +00:00
-Werror=switch
cmake: Enforce -Wuninitialized
2020-12-30 05:58:58 +00:00
-Werror=uninitialized
cmake: Enforce -Wunused-function code-base wide
2021-01-15 06:09:30 +00:00
-Werror=unused-function
General: Make ignoring a discarded return value an error Allows our CI to catch more potential bugs. This also removes the [[nodiscard]] attribute of IOFile's Open member function. There are cases where a file may want to be opened, but have the status of it checked at a later time.
2020-10-30 03:30:42 +00:00
-Werror=unused-result
cmake: Enforce -Werror=switch and -Werror=unused-variable
2021-01-13 06:52:30 +00:00
-Werror=unused-variable
CMakeLists: Specify -Wextra on linux builds Allows reporting more cases where logic errors may exist, such as implicit fallthrough cases, etc. We currently ignore unused parameters, since we currently have many cases where this is intentional (virtual interfaces). While we're at it, we can also tidy up any existing code that causes warnings. This also uncovered a few bugs as well.
2020-04-15 20:59:23 +01:00
-Wextra
CMakeLists: Enable -Wmissing-declarations on Linux builds Allows catching cases where internal linkage isn't specified for helper functions when they should be marked as such.
2020-04-17 03:06:58 +01:00
-Wmissing-declarations
CMakeLists: Explicitly specify -Wall for the non-MSVC case Ensures that -Wall is always active as a compilation flag.
2019-05-04 07:06:55 +01:00
-Wno-attributes
CMakeLists: disable -Winvalid-offsetof This Clang warning complains when offsetof is used on a non-standard-layout type (i.e. any class using various C++ features), even though it works fine (and is not undefined behavior as of C++17).
2020-11-23 22:24:37 +00:00
-Wno-invalid-offsetof
CMakeLists: Specify -Wextra on linux builds Allows reporting more cases where logic errors may exist, such as implicit fallthrough cases, etc. We currently ignore unused parameters, since we currently have many cases where this is intentional (virtual interfaces). While we're at it, we can also tidy up any existing code that causes warnings. This also uncovered a few bugs as well.
2020-04-15 20:59:23 +01:00
-Wno-unused-parameter
CMakeLists: Explicitly specify -Wall for the non-MSVC case Ensures that -Wall is always active as a compilation flag.
2019-05-04 07:06:55 +01:00
)
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
Build System: Fix GCC & MINGW Build.
2020-06-27 15:52:23 +01:00
if (ARCHITECTURE_x86_64)
add_compile_options("-mcx16")
endif()
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
add_compile_options("-stdlib=libc++")
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
endif()
# Set file offset size to 64 bits.
#
# On modern Unixes, this is typically already the case. The lone exception is
# glibc, which may default to 32 bits. glibc allows this to be configured
# by setting _FILE_OFFSET_BITS.
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
add_definitions(-D_FILE_OFFSET_BITS=64)
endif()
if (MINGW)
add_definitions(-DMINGW_HAS_SECURE_API)
if (MINGW_STATIC_BUILD)
add_definitions(-DQT_STATICPLUGIN)
CMakeLists: Move off of modifying CMAKE_*-related flags Modifying CMAKE_* related flags directly applies those changes to every single CMake target. This includes even the targets we have in the externals directory. So, if we ever increased our warning levels, or enabled particular ones, or enabled any other compilation setting, then this would apply to externals as well, which is often not desirable. This makes our compilation flag setup less error prone by only applying our settings to our targets and leaving the externals alone entirely. This also means we don't end up clobbering any provided flags on the command line either, allowing users to specifically use the flags they want.
2019-03-16 06:12:13 +00:00
add_compile_options("-static")
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
endif()
endif()
CMake: Create thin archives on Linux This significantly reduces unnecessary disk writes and space usage when building Citra. libcore.a is now only ~1MB rather than several hundred megabytes.
2019-06-30 12:29:52 +01:00
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR MINGW)
# GNU ar: Create thin archive files.
# Requires binutils-2.19 or later.
set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> qTP <TARGET> <LINK_FLAGS> <OBJECTS>")
set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> qcTP <TARGET> <LINK_FLAGS> <OBJECTS>")
set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> qTP <TARGET> <LINK_FLAGS> <OBJECTS>")
endif()
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
endif()
adding initial project layout
2013-08-30 04:35:09 +01:00
add_subdirectory(common)
add_subdirectory(core)
audio_core: Add initial code for keeping track of audout state.
2018-07-27 01:01:37 +01:00
add_subdirectory(audio_core)
updated CMakeLists
2014-04-10 04:09:05 +01:00
add_subdirectory(video_core)
InputCommon: add Keyboard
2017-01-21 09:53:03 +00:00
add_subdirectory(input_common)
shader: Initial recompiler work
2021-01-09 06:30:07 +00:00
add_subdirectory(shader_recompiler)
cmake: make tests optional
2022-01-11 23:36:20 +00:00
if (YUZU_TESTS)
add_subdirectory(tests)
endif()
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
Dependencies: Remove GLFW, Add SDL2 citra: Remove GLFW, Add SDL2 FindSDL2: Do not CACHE SDL2_* variables if library is not found EmuWindow_SDL2: Set minimal client area at initialisation time EmuWindow_SDL2: Corrections EmuWindow_SDL2: Fix no decorations on startup on OS X cmake: windows_copy_files
2016-03-01 17:24:18 +00:00
if (ENABLE_SDL2)
Massive removal of unused modules
2018-01-12 02:21:20 +00:00
add_subdirectory(yuzu_cmd)
CMake cleanup Several cleanups to the buildsystem: - Do better factoring of common libs between platforms. - Add support to building on Windows. - Remove Qt4 support. - Re-sort file lists and add missing headers.
2014-08-24 02:22:05 +01:00
endif()
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
CMake cleanup Several cleanups to the buildsystem: - Do better factoring of common libs between platforms. - Add support to building on Windows. - Remove Qt4 support. - Re-sort file lists and add missing headers.
2014-08-24 02:22:05 +01:00
if (ENABLE_QT)
Massive removal of unused modules
2018-01-12 02:21:20 +00:00
add_subdirectory(yuzu)
web_service: Add CMake flag to enable.
2017-07-09 22:52:18 +01:00
endif()
CMakeLists: Move compilation flags into the src directory We generally shouldn't be hijacking CMAKE_CXX_FLAGS, etc as a means to append flags to the targets, since this adds the compilation flags to everything, including our externals, which can result in weird issues and makes the build hierarchy fragile. Instead, we want to just apply these compilation flags to our targets, and let those managing external libraries to properly specify their compilation flags. This also results in us not getting as many warnings, as we don't raise the warning level on every external target.
2019-03-16 05:45:08 +00:00
Port web_service from Citra
2018-09-16 19:05:51 +01:00
if (ENABLE_WEB_SERVICE)
add_subdirectory(web_service)
endif()
Reference in a new issue Copy permalink