探索CMake与Unity的完美结合 如何在游戏开发中高效整合CMake构建系统与Unity引擎提升开发效率

威震华夏关云长

引言

在现代游戏开发领域，Unity引擎已经成为许多开发者的首选工具，其强大的跨平台能力和丰富的功能集使得游戏开发变得更加高效。然而，随着项目规模的扩大和复杂度的增加，Unity自带的构建系统在某些方面可能显得力不从心。与此同时，CMake作为一个成熟的跨平台构建工具，在管理复杂项目和依赖关系方面表现出色。本文将深入探讨如何将CMake与Unity完美结合，以提升游戏开发的效率和质量。

CMake基础

CMake是一个开源、跨平台的构建自动化工具，它使用名为CMakeLists.txt的配置文件来生成标准的构建文件（如Makefile或Visual Studio项目）。CMake的主要优势在于其跨平台性和灵活性，它能够为不同的平台和编译器生成相应的构建文件。

CMake的基本语法

一个简单的CMakeLists.txt文件通常包含以下基本元素：

2. # 指定CMake最低版本要求
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目名称
6. project(MyProject)
8. # 添加可执行文件
9. add_executable(MyProject main.cpp)
11. # 链接库
12. target_link_libraries(MyProject some_library)

复制代码

CMake的常用命令

• add_library: 添加库文件
• add_executable: 添加可执行文件
• target_include_directories: 添加包含目录
• target_link_libraries: 链接库文件
• find_package: 查找并加载外部项目设置

Unity构建系统概述

Unity引擎提供了自己的构建系统，用于管理项目资源和生成最终的游戏包。Unity的构建系统主要关注以下几个方面：

1. 资源管理：处理纹理、模型、音频等游戏资源
2. 场景构建：将Unity场景转换为可执行的游戏内容
3. 脚本编译：将C#脚本编译为中间语言或原生代码
4. 平台特定优化：针对不同平台进行优化和打包

Unity构建系统的局限性

尽管Unity的构建系统在大多数情况下表现良好，但它也存在一些局限性：

1. 依赖管理限制：Unity对外部C/C++库的管理不够灵活
2. 构建自定义性不足：难以实现复杂的构建流程和条件编译
3. 跨平台构建复杂性：为多个平台构建时，配置管理变得复杂
4. 持续集成挑战：与CI/CD系统集成时可能需要额外的工作

整合CMake与Unity的动机

将CMake与Unity结合使用可以带来以下优势：

1. 更好的依赖管理：CMake提供了强大的依赖管理功能，可以轻松集成第三方库
2. 跨平台构建能力：CMake的跨平台特性使得为不同平台构建原生插件变得更加简单
3. 自动化构建流程：可以创建更复杂、更自动化的构建流程
4. 与现有工具链集成：更容易与现有的开发工具和CI/CD系统集成
5. 模块化开发：支持更模块化的代码组织方式

整合方法

原生插件开发中使用CMake

Unity允许开发者使用C/C++编写原生插件，以扩展引擎功能或提高性能。使用CMake管理这些原生插件的构建过程可以大大提高开发效率。

首先，我们需要创建一个基本的项目结构：

2. MyUnityProject/
3. ├── Assets/
4. │   └── Plugins/
5. │       └── MyNativePlugin/
6. │           ├── include/
7. │           │   └── my_plugin.h
8. │           └── src/
9. │               └── my_plugin.cpp
10. ├── ProjectSettings/
11. └── native_plugins/
12.     └── MyNativePlugin/
13.         ├── CMakeLists.txt
14.         └── build/

复制代码

在native_plugins/MyNativePlugin/CMakeLists.txt中，我们可以定义构建规则：

2. cmake_minimum_required(VERSION 3.15)
3. project(MyNativePlugin)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加源文件
10. add_library(MyNativePlugin SHARED
11.     ../../Assets/Plugins/MyNativePlugin/src/my_plugin.cpp
12. )
14. # 添加包含目录
15. target_include_directories(MyNativePlugin PUBLIC
16.     ../../Assets/Plugins/MyNativePlugin/include
17. )
19. # 根据目标平台设置不同的输出目录
20. if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
21.     set_target_properties(MyNativePlugin PROPERTIES
22.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Windows/x86_64"
23.         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Windows/x86_64"
24.     )
25. elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
26.     set_target_properties(MyNativePlugin PROPERTIES
27.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/macOS/x86_64"
28.     )
29. elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
30.     set_target_properties(MyNativePlugin PROPERTIES
31.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Linux/x86_64"
32.     )
33. elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
34.     set_target_properties(MyNativePlugin PROPERTIES
35.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Android/${ANDROID_ABI}"
36.     )
37. elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS")
38.     set_target_properties(MyNativePlugin PROPERTIES
39.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/iOS"
40.     )
41. endif()

复制代码

为了简化构建过程，我们可以创建一个构建脚本。以下是一个Python示例，用于自动化CMake构建过程：

2. import os
3. import subprocess
4. import platform
5. from pathlib import Path
7. def build_native_plugin(plugin_name, build_type="Release"):
8.     plugin_dir = Path(f"native_plugins/{plugin_name}")
9.     build_dir = plugin_dir / "build"
10.    
11.     # 创建构建目录
12.     build_dir.mkdir(exist_ok=True)
13.    
14.     # 确定平台特定的生成器
15.     generators = {
16.         "Windows": "Visual Studio 16 2019",
17.         "Darwin": "Xcode",
18.         "Linux": "Unix Makefiles"
19.     }
20.    
21.     generator = generators.get(platform.system(), "Unix Makefiles")
22.    
23.     # 运行CMake配置
24.     cmake_configure = [
25.         "cmake",
26.         "..",
27.         f"-G{generator}",
28.         f"-DCMAKE_BUILD_TYPE={build_type}"
29.     ]
30.    
31.     # 如果是Android，添加额外的参数
32.     if "ANDROID_NDK_ROOT" in os.environ:
33.         cmake_configure.extend([
34.             f"-DCMAKE_TOOLCHAIN_FILE={os.environ['ANDROID_NDK_ROOT']}/build/cmake/android.toolchain.cmake",
35.             "-DANDROID_ABI=arm64-v8a"
36.         ])
37.    
38.     subprocess.run(cmake_configure, cwd=build_dir, check=True)
39.    
40.     # 运行构建
41.     cmake_build = ["cmake", "--build", ".", f"--config={build_type}"]
42.     subprocess.run(cmake_build, cwd=build_dir, check=True)
44. if __name__ == "__main__":
45.     build_native_plugin("MyNativePlugin")

复制代码

外部库管理

在游戏开发中，我们经常需要使用各种第三方库，如物理引擎、音频处理库等。CMake的FetchContent模块使得管理这些依赖变得非常简单。

以下是一个使用FetchContent来集成第三方库的示例：

2. cmake_minimum_required(VERSION 3.14)
3. project(MyUnityNativePlugin)
5. # 启用FetchContent
6. include(FetchContent)
8. # 声明依赖
9. FetchContent_Declare(
10.     json
11.     GIT_REPOSITORY https://github.com/nlohmann/json.git
12.     GIT_TAG v3.10.5
13. )
15. # 获取依赖
16. FetchContent_MakeAvailable(json)
18. # 声明另一个依赖
19. FetchContent_Declare(
20.     spdlog
21.     GIT_REPOSITORY https://github.com/gabime/spdlog.git
22.     GIT_TAG v1.9.2
23. )
25. # 获取依赖
26. FetchContent_MakeAvailable(spdlog)
28. # 添加我们的插件
29. add_library(MyUnityNativePlugin SHARED
30.     src/plugin.cpp
31. )
33. # 链接依赖
34. target_link_libraries(MyUnityNativePlugin
35.     PRIVATE
36.     nlohmann_json::nlohmann_json
37.     spdlog::spdlog
38. )
40. # 添加包含目录
41. target_include_directories(MyUnityNativePlugin
42.     PRIVATE
43.     ${CMAKE_CURRENT_SOURCE_DIR}/include
44. )

复制代码

对于一些不提供CMake支持的库，我们可以编写自定义的Find模块：

2. # FindMyCustomLib.cmake
3. find_path(MY_CUSTOM_LIB_INCLUDE_DIR
4.     NAMES my_custom_lib.h
5.     PATHS
6.     ${CMAKE_SOURCE_DIR}/third_party/my_custom_lib/include
7.     /usr/include
8.     /usr/local/include
9. )
11. find_library(MY_CUSTOM_LIB_LIBRARY
12.     NAMES my_custom_lib
13.     PATHS
14.     ${CMAKE_SOURCE_DIR}/third_party/my_custom_lib/lib
15.     /usr/lib
16.     /usr/local/lib
17. )
19. include(FindPackageHandleStandardArgs)
20. find_package_handle_standard_args(MyCustomLib
21.     DEFAULT_MSG
22.     MY_CUSTOM_LIB_INCLUDE_DIR
23.     MY_CUSTOM_LIB_LIBRARY
24. )
26. mark_as_advanced(
27.     MY_CUSTOM_LIB_INCLUDE_DIR
28.     MY_CUSTOM_LIB_LIBRARY
29. )

复制代码

然后在主CMakeLists.txt中使用：

2. list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
3. find_package(MyCustomLib REQUIRED)
5. target_include_directories(MyUnityNativePlugin
6.     PRIVATE
7.     ${MY_CUSTOM_LIB_INCLUDE_DIR}
8. )
10. target_link_libraries(MyUnityNativePlugin
11.     PRIVATE
12.     ${MY_CUSTOM_LIB_LIBRARY}
13. )

复制代码

自动化构建流程

将CMake与Unity结合的另一个重要方面是自动化构建流程。我们可以通过编写脚本来实现从代码提交到最终游戏包的自动化构建。

Unity支持通过命令行进行构建，我们可以利用这一点来创建自动化构建流程：

2. # Unity命令行构建示例
3. Unity.exe \
4.     -batchmode \
5.     -quit \
6.     -projectPath "path/to/your/project" \
7.     -executeMethod "BuildScript.PerformBuild" \
8.     -logFile "build.log"

复制代码

对应的Unity C#脚本：

2. using UnityEditor;
3. using UnityEngine;
5. public class BuildScript
6. {
7.     public static void PerformBuild()
8.     {
9.         // 构建原生插件
10.         System.Diagnostics.Process.Start("python", "build_native_plugins.py");
11.         
12.         // 等待原生插件构建完成
13.         System.Threading.Thread.Sleep(5000);
14.         
15.         // 获取构建场景
16.         string[] scenes = new string[] { "Assets/Scenes/MainScene.unity" };
17.         
18.         // 构建玩家
19.         BuildPipeline.BuildPlayer(scenes, "Builds/MyGame.exe", BuildTarget.StandaloneWindows64, BuildOptions.None);
20.     }
21. }

复制代码

虽然CMake主要用于代码构建，但我们也可以用它来管理一些Unity资源，例如将外部资源复制到Unity项目目录：

2. # 复制外部资源到Unity项目
3. function(copy_resources_to_unity resource_dir target_dir)
4.     file(GLOB_RECURSE resources "${resource_dir}/*")
5.     foreach(resource ${resources})
6.         file(RELATIVE_PATH rel_path "${resource_dir}" "${resource}")
7.         set(target_path "${target_dir}/${rel_path}")
8.         
9.         get_filename_component(target_dir "${target_path}" DIRECTORY)
10.         file(MAKE_DIRECTORY "${target_dir}")
11.         
12.         configure_file("${resource}" "${target_path}" COPYONLY)
13.     endforeach()
14. endfunction()
16. # 使用函数复制资源
17. copy_resources_to_unity(
18.     "${CMAKE_SOURCE_DIR}/external_assets"
19.     "${CMAKE_SOURCE_DIR}/../Assets/Resources"
20. )

复制代码

实际案例

让我们通过一个实际案例来展示如何将CMake与Unity结合使用。假设我们要开发一个使用OpenCV进行图像处理的Unity应用。

项目结构

2. UnityCVProject/
3. ├── Assets/
4. │   ├── Plugins/
5. │   │   └── OpenCVPlugin/
6. │   │       ├── include/
7. │   │       │   └── opencv_wrapper.h
8. │   │       └── src/
9. │   │           └── opencv_wrapper.cpp
10. │   └── Scripts/
11. │       └── OpenCVController.cs
12. ├── ProjectSettings/
13. └── native_plugins/
14.     └── OpenCVPlugin/
15.         ├── CMakeLists.txt
16.         └── build/

复制代码

CMakeLists.txt

2. cmake_minimum_required(VERSION 3.15)
3. project(OpenCVPlugin)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 查找OpenCV
10. find_package(OpenCV REQUIRED)
12. # 添加插件库
13. add_library(OpenCVPlugin SHARED
14.     ../../Assets/Plugins/OpenCVPlugin/src/opencv_wrapper.cpp
15. )
17. # 添加包含目录
18. target_include_directories(OpenCVPlugin PUBLIC
19.     ../../Assets/Plugins/OpenCVPlugin/include
20.     ${OpenCV_INCLUDE_DIRS}
21. )
23. # 链接OpenCV库
24. target_link_libraries(OpenCVPlugin
25.     ${OpenCV_LIBS}
26. )
28. # 设置输出目录
29. if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
30.     set_target_properties(OpenCVPlugin PROPERTIES
31.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/Windows/x86_64"
32.         RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/Windows/x86_64"
33.     )
34. elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
35.     set_target_properties(OpenCVPlugin PROPERTIES
36.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/macOS/x86_64"
37.     )
38. elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
39.     set_target_properties(OpenCVPlugin PROPERTIES
40.         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/Linux/x86_64"
41.     )
42. endif()

复制代码

C++包装器代码

opencv_wrapper.h:

2. #pragma once
4. #ifdef _WIN32
5.     #define API_EXPORT __declspec(dllexport)
6. #else
7.     #define API_EXPORT
8. #endif
10. extern "C" {
11.     // 初始化OpenCV
12.     API_EXPORT bool InitializeOpenCV();
13.    
14.     // 处理图像数据
15.     API_EXPORT bool ProcessImage(unsigned char* imageData, int width, int height, int channels);
16.    
17.     // 检测人脸
18.     API_EXPORT int DetectFaces(unsigned char* imageData, int width, int height, int channels,
19.                               int* facesX, int* facesY, int* facesWidth, int* facesHeight,
20.                               int maxFaces);
21.    
22.     // 释放资源
23.     API_EXPORT void ReleaseOpenCV();
24. }

复制代码

opencv_wrapper.cpp:

2. #include "opencv_wrapper.h"
3. #include <opencv2/opencv.hpp>
4. #include <opencv2/objdetect.hpp>
6. static cv::CascadeClassifier faceCascade;
8. extern "C" {
9.     API_EXPORT bool InitializeOpenCV() {
10.         try {
11.             // 加载人脸检测级联分类器
12.             std::string cascadePath = "haarcascade_frontalface_default.xml";
13.             if (!faceCascade.load(cascadePath)) {
14.                 return false;
15.             }
16.             return true;
17.         } catch (...) {
18.             return false;
19.         }
20.     }
21.    
22.     API_EXPORT bool ProcessImage(unsigned char* imageData, int width, int height, int channels) {
23.         try {
24.             // 将输入数据转换为OpenCV Mat
25.             cv::Mat inputImage(height, width, CV_MAKETYPE(CV_8U, channels), imageData);
26.             
27.             // 示例处理：转换为灰度图
28.             cv::Mat grayImage;
29.             cv::cvtColor(inputImage, grayImage, cv::COLOR_BGR2GRAY);
30.             
31.             // 应用高斯模糊
32.             cv::GaussianBlur(grayImage, grayImage, cv::Size(5, 5), 0);
33.             
34.             // 边缘检测
35.             cv::Mat edges;
36.             cv::Canny(grayImage, edges, 50, 150);
37.             
38.             // 将处理后的图像复制回输入数据
39.             cv::Mat outputImage;
40.             cv::cvtColor(edges, outputImage, cv::COLOR_GRAY2BGR);
41.             std::memcpy(imageData, outputImage.data, width * height * channels);
42.             
43.             return true;
44.         } catch (...) {
45.             return false;
46.         }
47.     }
48.    
49.     API_EXPORT int DetectFaces(unsigned char* imageData, int width, int height, int channels,
50.                               int* facesX, int* facesY, int* facesWidth, int* facesHeight,
51.                               int maxFaces) {
52.         try {
53.             // 将输入数据转换为OpenCV Mat
54.             cv::Mat inputImage(height, width, CV_MAKETYPE(CV_8U, channels), imageData);
55.             
56.             // 转换为灰度图
57.             cv::Mat grayImage;
58.             cv::cvtColor(inputImage, grayImage, cv::COLOR_BGR2GRAY);
59.             
60.             // 检测人脸
61.             std::vector<cv::Rect> faces;
62.             faceCascade.detectMultiScale(grayImage, faces, 1.1, 3, 0, cv::Size(30, 30));
63.             
64.             // 复制检测结果到输出数组
65.             int detectedFaces = (faces.size() < maxFaces) ? faces.size() : maxFaces;
66.             for (int i = 0; i < detectedFaces; i++) {
67.                 facesX[i] = faces[i].x;
68.                 facesY[i] = faces[i].y;
69.                 facesWidth[i] = faces[i].width;
70.                 facesHeight[i] = faces[i].height;
71.             }
72.             
73.             return detectedFaces;
74.         } catch (...) {
75.             return 0;
76.         }
77.     }
78.    
79.     API_EXPORT void ReleaseOpenCV() {
80.         // 清理资源
81.         faceCascade.~CascadeClassifier();
82.     }
83. }

复制代码

Unity C#脚本

OpenCVController.cs:

2. using UnityEngine;
3. using System;
4. using System.Runtime.InteropServices;
6. public class OpenCVController : MonoBehaviour
7. {
8.     // 导入本地插件函数
9.     [DllImport("OpenCVPlugin")]
10.     private static extern bool InitializeOpenCV();
11.    
12.     [DllImport("OpenCVPlugin")]
13.     private static extern bool ProcessImage(byte[] imageData, int width, int height, int channels);
14.    
15.     [DllImport("OpenCVPlugin")]
16.     private static extern int DetectFaces(byte[] imageData, int width, int height, int channels,
17.                                          int[] facesX, int[] facesY, int[] facesWidth, int[] facesHeight,
18.                                          int maxFaces);
19.    
20.     [DllImport("OpenCVPlugin")]
21.     private static extern void ReleaseOpenCV();
22.    
23.     public Texture2D inputTexture;
24.     public Material outputMaterial;
25.    
26.     private bool isInitialized = false;
27.    
28.     void Start()
29.     {
30.         // 初始化OpenCV
31.         isInitialized = InitializeOpenCV();
32.         
33.         if (!isInitialized)
34.         {
35.             Debug.LogError("Failed to initialize OpenCV");
36.         }
37.     }
38.    
39.     void Update()
40.     {
41.         if (isInitialized && Input.GetKeyDown(KeyCode.Space))
42.         {
43.             // 处理图像
44.             ProcessCurrentTexture();
45.         }
46.     }
47.    
48.     void ProcessCurrentTexture()
49.     {
50.         // 获取纹理数据
51.         byte[] imageData = inputTexture.GetRawTextureData();
52.         int width = inputTexture.width;
53.         int height = inputTexture.height;
54.         int channels = 4; // RGBA
55.         
56.         // 处理图像
57.         bool success = ProcessImage(imageData, width, height, channels);
58.         
59.         if (success)
60.         {
61.             // 将处理后的数据加载回纹理
62.             inputTexture.LoadRawTextureData(imageData);
63.             inputTexture.Apply();
64.             
65.             // 应用到材质
66.             if (outputMaterial != null)
67.             {
68.                 outputMaterial.mainTexture = inputTexture;
69.             }
70.         }
71.         else
72.         {
73.             Debug.LogError("Failed to process image");
74.         }
75.     }
76.    
77.     public Rect[] DetectFacesInTexture()
78.     {
79.         if (!isInitialized)
80.         {
81.             Debug.LogError("OpenCV not initialized");
82.             return new Rect[0];
83.         }
84.         
85.         // 获取纹理数据
86.         byte[] imageData = inputTexture.GetRawTextureData();
87.         int width = inputTexture.width;
88.         int height = inputTexture.height;
89.         int channels = 4; // RGBA
90.         
91.         // 准备输出数组
92.         const int maxFaces = 10;
93.         int[] facesX = new int[maxFaces];
94.         int[] facesY = new int[maxFaces];
95.         int[] facesWidth = new int[maxFaces];
96.         int[] facesHeight = new int[maxFaces];
97.         
98.         // 检测人脸
99.         int detectedFaces = DetectFaces(imageData, width, height, channels,
100.                                        facesX, facesY, facesWidth, facesHeight,
101.                                        maxFaces);
102.         
103.         // 转换为Rect数组
104.         Rect[] result = new Rect[detectedFaces];
105.         for (int i = 0; i < detectedFaces; i++)
106.         {
107.             // 转换坐标系（OpenCV使用左上角为原点，Unity使用左下角为原点）
108.             float y = height - (facesY[i] + facesHeight[i]);
109.             result[i] = new Rect(facesX[i], y, facesWidth[i], facesHeight[i]);
110.         }
111.         
112.         return result;
113.     }
114.    
115.     void OnDestroy()
116.     {
117.         // 释放资源
118.         if (isInitialized)
119.         {
120.             ReleaseOpenCV();
121.         }
122.     }
123. }

复制代码

构建脚本

build_opencv_plugin.py:

2. import os
3. import subprocess
4. import platform
5. from pathlib import Path
7. def build_opencv_plugin(build_type="Release"):
8.     plugin_dir = Path("native_plugins/OpenCVPlugin")
9.     build_dir = plugin_dir / "build"
10.    
11.     # 创建构建目录
12.     build_dir.mkdir(exist_ok=True)
13.    
14.     # 确定平台特定的生成器
15.     generators = {
16.         "Windows": "Visual Studio 16 2019",
17.         "Darwin": "Xcode",
18.         "Linux": "Unix Makefiles"
19.     }
20.    
21.     generator = generators.get(platform.system(), "Unix Makefiles")
22.    
23.     # 设置OpenCV_DIR环境变量（如果需要）
24.     opencv_dir = os.environ.get("OPENCV_DIR", "")
25.    
26.     # 运行CMake配置
27.     cmake_configure = [
28.         "cmake",
29.         "..",
30.         f"-G{generator}",
31.         f"-DCMAKE_BUILD_TYPE={build_type}"
32.     ]
33.    
34.     if opencv_dir:
35.         cmake_configure.append(f"-DOpenCV_DIR={opencv_dir}")
36.    
37.     subprocess.run(cmake_configure, cwd=build_dir, check=True)
38.    
39.     # 运行构建
40.     cmake_build = ["cmake", "--build", ".", f"--config={build_type}"]
41.     subprocess.run(cmake_build, cwd=build_dir, check=True)
42.    
43.     # 复制OpenCV运行时库（Windows）
44.     if platform.system() == "Windows" and opencv_dir:
45.         opencv_bin_dir = Path(opencv_dir) / "bin"
46.         if opencv_bin_dir.exists():
47.             target_dir = Path("Assets/Plugins/OpenCVPlugin/Windows/x86_64")
48.             for dll in opencv_bin_dir.glob("opencv_*.dll"):
49.                 subprocess.run(["copy", str(dll), str(target_dir)], shell=True)
51. if __name__ == "__main__":
52.     build_opencv_plugin()

复制代码

最佳实践

在将CMake与Unity结合使用时，以下是一些最佳实践：

1. 项目结构组织

保持清晰的项目结构对于维护大型项目至关重要。建议采用以下结构：

2. UnityProject/
3. ├── Assets/
4. │   ├── Plugins/
5. │   │   └── Native/
6. │   │       ├── Plugin1/
7. │   │       │   ├── include/
8. │   │       │   └── src/
9. │   │       └── Plugin2/
10. │   │           ├── include/
11. │   │           └── src/
12. │   └── Scripts/
13. ├── ProjectSettings/
14. ├── native_plugins/
15. │   ├── Plugin1/
16. │   │   ├── CMakeLists.txt
17. │   │   └── build/
18. │   └── Plugin2/
19. │       ├── CMakeLists.txt
20. │       └── build/
21. └── cmake/
22.     ├── FindSomeLibrary.cmake
23.     └── Utils.cmake

复制代码

2. 平台特定配置

使用CMake的条件语句处理不同平台的特定需求：

2. # 平台特定配置
3. if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
4.     add_definitions(-DPLATFORM_WINDOWS)
5.     # Windows特定库
6.     target_link_libraries(MyPlugin
7.         some_windows_lib
8.     )
9. elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
10.     add_definitions(-DPLATFORM_MACOS)
11.     # macOS特定框架
12.     target_link_libraries(MyPlugin
13.         "-framework Foundation"
14.         "-framework CoreGraphics"
15.     )
16. elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
17.     add_definitions(-DPLATFORM_LINUX)
18.     # Linux特定库
19.     target_link_libraries(MyPlugin
20.         some_linux_lib
21.     )
22. elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
23.     add_definitions(-DPLATFORM_ANDROID)
24.     # Android特定库
25.     target_link_libraries(MyPlugin
26.         log
27.         android
28.     )
29. elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS")
30.     add_definitions(-DPLATFORM_IOS)
31.     # iOS特定框架
32.     target_link_libraries(MyPlugin
33.         "-framework Foundation"
34.         "-framework UIKit"
35.     )
36. endif()

复制代码

3. 构建类型配置

为不同的构建类型（Debug、Release等）设置适当的编译选项：

2. # 设置编译选项
3. if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
4.     # MSVC编译器选项
5.     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi")
6.     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2")
7. else()
8.     # GCC/Clang编译器选项
9.     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g")
10.     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
11. endif()
13. # 添加预处理器定义
14. target_compile_definitions(MyPlugin
15.     PRIVATE
16.     $<$<CONFIG:Debug>:DEBUG_MODE=1>
17.     $<$<CONFIG:Release>:NDEBUG>
18. )

复制代码

4. 依赖管理

使用CMake的FetchContent模块或ExternalProject模块管理外部依赖：

2. # 使用FetchContent管理依赖
3. include(FetchContent)
5. # 声明并获取依赖
6. FetchContent_Declare(
7.     fmt
8.     GIT_REPOSITORY https://github.com/fmtlib/fmt.git
9.     GIT_TAG 9.1.0
10. )
12. FetchContent_MakeAvailable(fmt)
14. # 链接依赖
15. target_link_libraries(MyPlugin
16.     PRIVATE
17.     fmt::fmt
18. )

复制代码

5. 自动化测试

为原生插件编写自动化测试，确保其正确性：

2. # 启用测试
3. enable_testing()
5. # 添加测试
6. add_executable(MyPluginTests
7.     tests/test_main.cpp
8.     tests/test_my_plugin.cpp
9. )
11. # 链接插件
12. target_link_libraries(MyPluginTests
13.     PRIVATE
14.     MyPlugin
15. )
17. # 添加测试用例
18. add_test(NAME MyPluginBasicTest COMMAND MyPluginTests)

复制代码

性能优化

将CMake与Unity结合使用不仅可以提高开发效率，还可以通过以下方式优化性能：

1. 条件编译

使用CMake的条件编译功能，根据平台或功能需求包含或排除特定代码：

2. # 功能开关
3. option(ENABLE_FEATURE_X "Enable feature X" ON)
5. if(ENABLE_FEATURE_X)
6.     target_sources(MyPlugin
7.         PRIVATE
8.         src/feature_x.cpp
9.     )
10.     target_compile_definitions(MyPlugin
11.         PRIVATE
12.         FEATURE_X_ENABLED
13.     )
14. endif()

复制代码

2. 优化构建过程

通过并行构建和增量构建优化构建过程：

2. # 启用并行构建
3. if(NOT DEFINED CMAKE_BUILD_PARALLEL_LEVEL)
4.     set(CMAKE_BUILD_PARALLEL_LEVEL 4)
5. endif()
7. # 使用预编译头（如果支持）
8. if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
9.     target_precompile_headers(MyPlugin
10.         PRIVATE
11.         include/pch.h
12.     )
13. endif()

复制代码

3. 内存管理优化

在原生插件中实现高效的内存管理，减少与Unity之间的数据复制：

2. // 示例：使用共享内存减少数据复制
3. extern "C" {
4.     // 分配共享内存
5.     API_EXPORT void* AllocateSharedMemory(size_t size);
6.    
7.     // 释放共享内存
8.     API_EXPORT void FreeSharedMemory(void* ptr);
9.    
10.     // 在共享内存中处理数据
11.     API_EXPORT bool ProcessInSharedMemory(void* data, size_t size);
12. }

复制代码

4. 多线程处理

利用多线程提高原生插件的性能：

2. #include <thread>
3. #include <vector>
5. extern "C" {
6.     API_EXPORT void ProcessDataParallel(void* data, size_t size, int numThreads) {
7.         std::vector<std::thread> threads;
8.         size_t chunkSize = size / numThreads;
9.         
10.         for (int i = 0; i < numThreads; ++i) {
11.             threads.emplace_back([data, chunkSize, i, numThreads]() {
12.                 size_t start = i * chunkSize;
13.                 size_t end = (i == numThreads - 1) ? size : start + chunkSize;
14.                 ProcessDataChunk(static_cast<char*>(data) + start, end - start);
15.             });
16.         }
17.         
18.         for (auto& thread : threads) {
19.             thread.join();
20.         }
21.     }
22. }

复制代码

常见问题与解决方案

1. 平台特定问题

问题：在不同平台上构建时遇到链接错误或运行时错误。

解决方案：

• 使用CMake的条件语句处理平台差异
• 确保所有依赖库都正确链接
• 检查运行时库是否正确部署

2. # 示例：处理Windows运行时库
3. if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
4.     # 静态链接运行时库
5.     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
6.     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
7.    
8.     # 确保运行时库被复制到输出目录
9.     add_custom_command(TARGET MyPlugin POST_BUILD
10.         COMMAND ${CMAKE_COMMAND} -E copy_if_different
11.         "$<TARGET_RUNTIME_DLLS:MyPlugin>"
12.         $<TARGET_FILE_DIR:MyPlugin>
13.         COMMAND_EXPAND_LISTS
14.     )
15. endif()

复制代码

2. Unity与原生插件之间的数据传递

问题：在Unity和原生插件之间传递大量数据时性能低下。

解决方案：

• 使用指针和内存映射减少数据复制
• 使用Marshal类在C#中高效处理内存

2. // C#示例：高效处理大数组
3. using System;
4. using System.Runtime.InteropServices;
6. public class NativeArrayHandler : IDisposable
7. {
8.     private IntPtr nativeArrayPtr;
9.     private int size;
10.    
11.     public NativeArrayHandler(int size)
12.     {
13.         this.size = size;
14.         nativeArrayPtr = Marshal.AllocHGlobal(size * Marshal.SizeOf(typeof(float)));
15.     }
16.    
17.     public void CopyFrom(float[] source)
18.     {
19.         Marshal.Copy(source, 0, nativeArrayPtr, size);
20.     }
21.    
22.     public void CopyTo(float[] destination)
23.     {
24.         Marshal.Copy(nativeArrayPtr, destination, 0, size);
25.     }
26.    
27.     public IntPtr GetPointer()
28.     {
29.         return nativeArrayPtr;
30.     }
31.    
32.     public void Dispose()
33.     {
34.         if (nativeArrayPtr != IntPtr.Zero)
35.         {
36.             Marshal.FreeHGlobal(nativeArrayPtr);
37.             nativeArrayPtr = IntPtr.Zero;
38.         }
39.     }
40. }

复制代码

3. CMake构建缓存问题

问题：修改CMake配置后，构建没有按预期更新。

解决方案：

• 清理构建目录并重新配置
• 使用CMake的-H和-B选项明确指定源目录和构建目录

2. # 清理并重新构建示例
3. rm -rf build
4. mkdir build
5. cd build
6. cmake ..
7. make

复制代码

4. Android构建问题

问题：在为Android构建原生插件时遇到ABI兼容性问题。

解决方案：

• 为每个目标ABI单独构建
• 使用CMake的ANDROID_ABI变量

2. # Android ABI特定配置
3. if(ANDROID)
4.     message(STATUS "Building for Android ABI: ${ANDROID_ABI}")
5.    
6.     # ABI特定设置
7.     if(ANDROID_ABI STREQUAL "armeabi-v7a")
8.         target_compile_options(MyPlugin PRIVATE -mfloat-abi=softfp -mfpu=neon)
9.     elseif(ANDROID_ABI STREQUAL "arm64-v8a")
10.         target_compile_options(MyPlugin PRIVATE -march=armv8-a)
11.     endif()
12. endif()

复制代码

结论与展望

将CMake与Unity结合使用可以显著提高游戏开发的效率，特别是在处理复杂的原生插件和依赖关系时。通过本文介绍的方法，开发者可以：

1. 更高效地管理原生插件的构建过程
2. 简化第三方库的集成
3. 实现跨平台构建的一致性
4. 自动化构建流程，提高开发效率

随着游戏项目变得越来越复杂，这种结合方式将变得更加重要。未来，我们可以期待Unity与CMake的集成变得更加紧密，可能会出现专门针对Unity的CMake模块或工具，进一步简化这一过程。

总之，CMake与Unity的结合为游戏开发者提供了一个强大而灵活的构建解决方案，能够帮助团队更高效地开发高质量的游戏产品。通过遵循本文介绍的最佳实践和解决方案，开发者可以充分利用这两个工具的优势，提升游戏开发的效率和质量。