Move to VCPKG

README.md

@@ -1,94 +1,109 @@
 # MO2 CMake Common
 
-This repository contains CMake macro and functions that are used in most MO2
-repository to build uibase, modorganizer itself and plugins (C++/Python).
+This repository contains useful CMake macro and functions that are used to ease creating
+CMake configuration for most of MO2 repositories (e.g.,
+[uibase](https://github.com/ModOrganizer2/modorganizer-uibase),
+[plugin_python](https://github.com/ModOrganizer2/modorganizer-plugin_python) or
+[ModOrganizer2](https://github.com/ModOrganizer2/modorganizer) itself).
 
 ## Getting Started
 
-To get started, simply include the `mo2.cmake` file in your project:
-
-```cmake
-# this can safely be included multiple time
-include(path_to_cmake_common/mo2.cmake)
+### 1. With VCPKG
+
+Add [MO2 VCPKG registry](https://github.com/ModOrganizer2/vcpkg-registry) to your
+`vcpkg-configuration.json`:
+
+```json
+{
+  "default-registry": {
+    "kind": "git",
+    "repository": "https://github.com/Microsoft/vcpkg",
+    "baseline": "f61a294e765b257926ae9e9d85f96468a0af74e7"
+  },
+  "registries": [
+    {
+      "kind": "git",
+      "repository": "https://github.com/ModOrganizer2/vcpkg-registry",
+      "baseline": "27d8adbfe9e4ce88a875be3a45fadab69869eb60",
+      "packages": ["mo2-cmake"]
+    }
+  ]
+}
 ```
 
-This will set some (not too intrusive) variables and define many useful functions,
-all prefixed with `mo2_`.
-
-The basic MO2 plugin/executable CMake will then look like this:
+Add `mo2-cmake` to your VCPKG dependencies (`vcpkg.json`) and then import the utilities
+with `find_package` in your CMake configuration:
 
 ```cmake
-# this is for a C++ plugin
-add_library(my_plugin SHARED)
-
-# configure the plugin - this will also set the sources of the plugin
-# based on the file in the current directory (and subdirectory)
-mo2_configure_plugin(my_plugin)
-
-# install the target to MO2 installation path, typically in the
-# plugins/ folder
-mo2_install_target(my_plugin)
+find_package(mo2-cmake CONFIG REQUIRED)
 ```
 
-## Configuring
-
-The main entry-points are the the configure functions:
-
-- C++
-  - `mo2_configure_target` - this is the "base" configuration,
-    which should not be used most of the time (this one is called by
-    other functions),
-  - `mo2_configure_uibase` - specific for uibase, should not be used
-    elsewhere,
-  - `mo2_configure_plugin` - configuration for a C++ plugin,
-  - `mo2_configure_library` - configuration for static or shared libraries,
-  - `mo2_configure_executable` - configuration for executables, including the main
-    MO2 executable,
-  - `mo2_configure_tests` - configuration for tests.
-- Python
-  - `mo2_configure_python`.
-
-The function are documented so you can look at the documentation to see what arguments
-are available.
-
-### Dependencies
-
-You can add dependencies to the target by using the standard `target_link_libraries`,
-but this might be difficult when looking for MO2 dependencies, such as other libraries
-or Qt.
-
-The `mo2_configure_XXX` accept `PRIVATE_DEPENDS` and `PUBLIC_DEPENDS` parameters that
-can be used to add dependencies to the target in an easier way.
-These parameters accept 3 types of dependencies:
-
-- Qt dependencies, that should be specified as `Qt::COMPONENTS`, e.g., `Qt::Core` or
-  `Qt::Widgets`. Note that the `Qt::` is version-independent, MO2 will add the proper
-  version for you.
-- Boost dependencies - For header only libraries, you can simply pass `boost`, for
-  non-header only libraries, you can pass `boost::COMPONENT`, e.g., `boost::threads`.
-- MO2 dependencies - Those are either components available via the MO2 build system,
-  such as `zlib` or `libbsarch`, or other MO2 components such as `game_gamebryo`.
-
-## Installing
-
-For C++ plugin, you need to call `mo2_install_target` to install the plugins or
-executable in MO2 installation directory.
-Where the target should be installed is defined in the `mo2_configure_XXX` function
-(which should be called before `mo2_install_target`).
-
-Installing Python plugins does not require extra call apart from `mo2_configure_python`.
-
-## Examples
-
-All MO2 repositories use these functions, so you can look at any repository to get
-details on how to use them.
-Here are entry points for the various type of plugins:
-
-- [`game_skyrimse`](https://github.com/ModOrganizer2/modorganizer-game_skyrimSE/)
-  for a plugin that depends on a static library built by MO2.
-- [`game_gamebryo`](https://github.com/ModOrganizer2/modorganizer-game_gamebryo/)
-  for a static library example.
-- [`installer_wizard`](https://github.com/ModOrganizer2/modorganizer-installer_wizard)
-  for a Python plugin (module).
-- [`fnistool`](https://github.com/ModOrganizer2/modorganizer-fnistool/) for a Python
-  plugin (simple file).
+### 2. Manually
+
+Clone this repository somewhere and then `include(mo2.cmake)` in your CMake
+configuration files.
+
+## Usage
+
+Be aware that using these utilities will automatically set some (not too intrusive)
+global variable on your project.
+
+In order to properly use this package, you should set `CMAKE_INSTALL_PREFIX` to a valid
+location.
+There are two possible way of using this package controlled by the `MO2_INSTALL_IS_BIN`
+option:
+
+- if `MO2_INSTALL_IS_BIN` is `OFF` (default), this assumes a layout with a `bin`,
+  `lib`, `include` and `pdb` folder under `CMAKE_INSTALL_PREFIX`,
+- if `MO2_INSTALL_IS_BIN` is `ON` (default when building standalone), this assumes
+  that `CMAKE_INSTALL_PREFIX` point directly to the equivalent `bin` folder.
+
+Importing the utilities will make the following variables available:
+
+- `MO2_QT_VERSION` - The Qt version used by MO2, as `major.minor.patch`.
+- `MO2_QT_MAJOR_VERSION`, `MO2_QT_MINOR_VERSION` and `MO2_QT_PATCH_VERSION` -
+  Respectively the major, minor and patch version of Qt used by MO2.
+- `MO2_PYTHON_VERSION` - The Python version used by MO2 as `major.minor` (patch version
+  should not be relevant).
+
+All functions are prefixed by `mo2_` and should not conflict with other existing
+functions.
+
+### Generic Utilities
+
+- `mo2_set_if_not_defined` - Set a variable to a given value if the variable is not
+  defined.
+- `mo2_add_subdirectories` -
+- `mo2_find_python_executable` - Find Python executable.
+- `mo2_find_git_hash` - Find the hash of the current git HEAD.
+- `mo2_find_qt_executable` - Find a given Qt executable.
+- `mo2_set_project_to_run_from_install` - Configure the debug executable for a VS project.
+- `mo2_add_filter` - Add a source group filter.
+- `mo2_deploy_qt_for_tests` - Deploy Qt DLLs, etc., for tests.
+- `mo2_deploy_qt` - Deploy Qt DLLs for ModOrganizer2.
+- `mo2_add_lupdate` - Create a target to run Qt `lupdate`.
+- `mo2_add_lrelease` - Create a target to Qt `lrelease`.
+- `mo2_add_translations` - Add targets to generate translations for the given target.
+
+### C++ Utilities
+
+TODO:
+
+- `mo2_configure_warnings` - Utility function configure warnings for a target.
+- `mo2_configure_sources` - Glob and configure sources, including Qt-related files
+  (.ui, etc.) for a target.
+- `mo2_configure_msvc` - Set some MSVC-specific flag for a target.
+- (Deprecated) `mo2_configure_target` - Combine the above function + Extra stuff.
+- (Deprecated) `mo2_configure_plugin`
+- `mo2_configure_tests` - TO BE CHANGED
+- `mo2_install_plugin` - Install a plugin.
+
+### Python Utilities
+
+- `mo2_python_uifiles` - Add a target to generate `.py` files from `.ui` files.
+- `mo2_python_pip_install` - Install Python packages.
+- `mo2_python_requirements` - Install plugin requirements from a `plugin-requirements.txt`
+  file, ready to ship.
+- `mo2_configure_python_module` - Configure a Python module plugin.
+- (Deprecated) `mo2_configure_python_simple` - Configure a Python single file plugin.
+- `mo2_configure_python` - Wrapper for the two above functions.

mo2-cmake-config.cmake

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.22)
+
+include(${CMAKE_CURRENT_LIST_DIR}/mo2.cmake)

mo2.cmake

@@ -1,52 +1,44 @@
 cmake_minimum_required(VERSION 3.22)
 
-if (DEFINED MO2_INCLUDED)
+if (DEFINED MO2_DEFINED)
 	return()
 endif()
 
+option(MO2_INSTALL_IS_BIN
+	"if set, CMAKE_INSTALL_PREFIX is assumed to point to bin rather than one level below")
+
+if (MO2_INSTALL_IS_BIN)
+	set(MO2_INSTALL_BIN ".")
+else()
+	set(MO2_INSTALL_BIN "bin")
+endif()
+
+include(${CMAKE_CURRENT_LIST_DIR}/mo2_versions.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/mo2_utils.cmake)
 
-# setup path for find_package(), etc.
-mo2_required_variable(NAME BOOST_ROOT TYPE PATH)
-mo2_required_variable(NAME QT_ROOT TYPE PATH)
-mo2_required_variable(NAME PYTHON_ROOT TYPE PATH)
-mo2_required_variable(NAME CMAKE_INSTALL_PREFIX TYPE PATH)
-
-get_filename_component(MO2_BUILD_PATH "${CMAKE_CURRENT_LIST_DIR}/../.." REALPATH)
-get_filename_component(MO2_SUPER_PATH "${MO2_BUILD_PATH}/modorganizer_super" REALPATH)
-get_filename_component(MO2_UIBASE_PATH "${MO2_SUPER_PATH}/uibase" REALPATH)
-get_filename_component(MO2_INSTALL_PATH "${MO2_SUPER_PATH}/../../install" REALPATH)
-get_filename_component(MO2_INSTALL_LIBS_PATH "${MO2_INSTALL_PATH}/libs" REALPATH)
-
-list(APPEND CMAKE_PREFIX_PATH
-	${QT_ROOT}/lib/cmake
-	${BOOST_ROOT}/build
-	${MO2_BUILD_PATH}/googletest/build/lib/cmake/GTest)
-
-# find Qt major version and set QT_DEFAULT_MAJOR_VERSION to avoid issues
-# when including LinguistTools without a QtCore
-mo2_find_qt_version(QT_VERSION)
-string(REPLACE "." ";" QT_VERSION_LIST ${QT_VERSION})
-list(GET QT_VERSION_LIST 0 QT_MAJOR_VERSION)
-
-# we add the Qt DLL to the paths for some tools
-set(ENV{PATH} "${QT_ROOT}/bin;$ENV{PATH}")
-
-# custom property, used to keep track of the type of target
-define_property(
-	TARGET PROPERTY MO2_TARGET_TYPE INHERITED
-	BRIEF_DOCS  "Target type for MO2 C++ target."
-	FULL_DOCS "Automatically set when using mo2_configure_XXX functions.")
-
-set(Boost_USE_STATIC_RUNTIME OFF)
-set(Boost_USE_STATIC_LIBS ON)
+# this makes VS install everything when building solution
 set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1)
 
+# this find Python globally rather than virtual environments, even when one is active
+set(Python_FIND_VIRTUALENV STANDARD)
+
+# this set the imported location of targets for missing configurations - this silents
+# many CMP0111 warnings from CMake
+set(CMAKE_MAP_IMPORTED_CONFIG_MINSIZEREL MinSizeRel RelWithDebInfo Release None)
+set(CMAKE_MAP_IMPORTED_CONFIG_RELWITHDEBINFO RelWithDebInfo Release MinSizeRel None)
+set(CMAKE_MAP_IMPORTED_CONFIG_RELEASE Release RelWithDebInfo MinSizeRel None)
+
+# allow setting folder property on targets for better organization in VS
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# put code generated by Qt in a autogen group in VS
 set_property(GLOBAL PROPERTY AUTOGEN_SOURCE_GROUP autogen)
 set_property(GLOBAL PROPERTY AUTOMOC_SOURCE_GROUP autogen)
 set_property(GLOBAL PROPERTY AUTORCC_SOURCE_GROUP autogen)
 
+# put targets generated by Qt into a autogen folder (this is not the same as the above)
+set(QT_TARGETS_FOLDER autogen)
+
 include(${CMAKE_CURRENT_LIST_DIR}/mo2_cpp.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/mo2_python.cmake)