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

引言

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

CMake基础

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

CMake的基本语法

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

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

CMake的常用命令

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

Unity构建系统概述

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

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

Unity构建系统的局限性

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

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

整合CMake与Unity的动机

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

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

整合方法

原生插件开发中使用CMake

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

创建CMake管理的原生插件

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

MyUnityProject/ ├── Assets/ │ └── Plugins/ │ └── MyNativePlugin/ │ ├── include/ │ │ └── my_plugin.h │ └── src/ │ └── my_plugin.cpp ├── ProjectSettings/ └── native_plugins/ └── MyNativePlugin/ ├── CMakeLists.txt └── build/

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

cmake_minimum_required(VERSION 3.15) project(MyNativePlugin) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 添加源文件 add_library(MyNativePlugin SHARED ../../Assets/Plugins/MyNativePlugin/src/my_plugin.cpp ) # 添加包含目录 target_include_directories(MyNativePlugin PUBLIC ../../Assets/Plugins/MyNativePlugin/include ) # 根据目标平台设置不同的输出目录 if(CMAKE_SYSTEM_NAME STREQUAL "Windows") set_target_properties(MyNativePlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Windows/x86_64" RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Windows/x86_64" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") set_target_properties(MyNativePlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/macOS/x86_64" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") set_target_properties(MyNativePlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Linux/x86_64" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Android") set_target_properties(MyNativePlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/Android/${ANDROID_ABI}" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS") set_target_properties(MyNativePlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/MyNativePlugin/iOS" ) endif()

构建脚本

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

import os import subprocess import platform from pathlib import Path def build_native_plugin(plugin_name, build_type="Release"): plugin_dir = Path(f"native_plugins/{plugin_name}") build_dir = plugin_dir / "build" # 创建构建目录 build_dir.mkdir(exist_ok=True) # 确定平台特定的生成器 generators = { "Windows": "Visual Studio 16 2019", "Darwin": "Xcode", "Linux": "Unix Makefiles" } generator = generators.get(platform.system(), "Unix Makefiles") # 运行CMake配置 cmake_configure = [ "cmake", "..", f"-G{generator}", f"-DCMAKE_BUILD_TYPE={build_type}" ] # 如果是Android，添加额外的参数 if "ANDROID_NDK_ROOT" in os.environ: cmake_configure.extend([ f"-DCMAKE_TOOLCHAIN_FILE={os.environ['ANDROID_NDK_ROOT']}/build/cmake/android.toolchain.cmake", "-DANDROID_ABI=arm64-v8a" ]) subprocess.run(cmake_configure, cwd=build_dir, check=True) # 运行构建 cmake_build = ["cmake", "--build", ".", f"--config={build_type}"] subprocess.run(cmake_build, cwd=build_dir, check=True) if __name__ == "__main__": build_native_plugin("MyNativePlugin")

外部库管理

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

使用FetchContent管理依赖

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

cmake_minimum_required(VERSION 3.14) project(MyUnityNativePlugin) # 启用FetchContent include(FetchContent) # 声明依赖 FetchContent_Declare( json GIT_REPOSITORY https://github.com/nlohmann/json.git GIT_TAG v3.10.5 ) # 获取依赖 FetchContent_MakeAvailable(json) # 声明另一个依赖 FetchContent_Declare( spdlog GIT_REPOSITORY https://github.com/gabime/spdlog.git GIT_TAG v1.9.2 ) # 获取依赖 FetchContent_MakeAvailable(spdlog) # 添加我们的插件 add_library(MyUnityNativePlugin SHARED src/plugin.cpp ) # 链接依赖 target_link_libraries(MyUnityNativePlugin PRIVATE nlohmann_json::nlohmann_json spdlog::spdlog ) # 添加包含目录 target_include_directories(MyUnityNativePlugin PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include )

自定义Find模块

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

# FindMyCustomLib.cmake find_path(MY_CUSTOM_LIB_INCLUDE_DIR NAMES my_custom_lib.h PATHS ${CMAKE_SOURCE_DIR}/third_party/my_custom_lib/include /usr/include /usr/local/include ) find_library(MY_CUSTOM_LIB_LIBRARY NAMES my_custom_lib PATHS ${CMAKE_SOURCE_DIR}/third_party/my_custom_lib/lib /usr/lib /usr/local/lib ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(MyCustomLib DEFAULT_MSG MY_CUSTOM_LIB_INCLUDE_DIR MY_CUSTOM_LIB_LIBRARY ) mark_as_advanced( MY_CUSTOM_LIB_INCLUDE_DIR MY_CUSTOM_LIB_LIBRARY )

然后在主CMakeLists.txt中使用：

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") find_package(MyCustomLib REQUIRED) target_include_directories(MyUnityNativePlugin PRIVATE ${MY_CUSTOM_LIB_INCLUDE_DIR} ) target_link_libraries(MyUnityNativePlugin PRIVATE ${MY_CUSTOM_LIB_LIBRARY} )

自动化构建流程

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

Unity命令行构建

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

# Unity命令行构建示例 Unity.exe -batchmode -quit -projectPath "path/to/your/project" -executeMethod "BuildScript.PerformBuild" -logFile "build.log"

对应的Unity C#脚本：

using UnityEditor; using UnityEngine; public class BuildScript { public static void PerformBuild() { // 构建原生插件 System.Diagnostics.Process.Start("python", "build_native_plugins.py"); // 等待原生插件构建完成 System.Threading.Thread.Sleep(5000); // 获取构建场景 string[] scenes = new string[] { "Assets/Scenes/MainScene.unity" }; // 构建玩家 BuildPipeline.BuildPlayer(scenes, "Builds/MyGame.exe", BuildTarget.StandaloneWindows64, BuildOptions.None); } }

使用CMake管理Unity资源

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

# 复制外部资源到Unity项目 function(copy_resources_to_unity resource_dir target_dir) file(GLOB_RECURSE resources "${resource_dir}/*") foreach(resource ${resources}) file(RELATIVE_PATH rel_path "${resource_dir}" "${resource}") set(target_path "${target_dir}/${rel_path}") get_filename_component(target_dir "${target_path}" DIRECTORY) file(MAKE_DIRECTORY "${target_dir}") configure_file("${resource}" "${target_path}" COPYONLY) endforeach() endfunction() # 使用函数复制资源 copy_resources_to_unity( "${CMAKE_SOURCE_DIR}/external_assets" "${CMAKE_SOURCE_DIR}/../Assets/Resources" )

实际案例

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

项目结构

UnityCVProject/ ├── Assets/ │ ├── Plugins/ │ │ └── OpenCVPlugin/ │ │ ├── include/ │ │ │ └── opencv_wrapper.h │ │ └── src/ │ │ └── opencv_wrapper.cpp │ └── Scripts/ │ └── OpenCVController.cs ├── ProjectSettings/ └── native_plugins/ └── OpenCVPlugin/ ├── CMakeLists.txt └── build/

CMakeLists.txt

cmake_minimum_required(VERSION 3.15) project(OpenCVPlugin) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 查找OpenCV find_package(OpenCV REQUIRED) # 添加插件库 add_library(OpenCVPlugin SHARED ../../Assets/Plugins/OpenCVPlugin/src/opencv_wrapper.cpp ) # 添加包含目录 target_include_directories(OpenCVPlugin PUBLIC ../../Assets/Plugins/OpenCVPlugin/include ${OpenCV_INCLUDE_DIRS} ) # 链接OpenCV库 target_link_libraries(OpenCVPlugin ${OpenCV_LIBS} ) # 设置输出目录 if(CMAKE_SYSTEM_NAME STREQUAL "Windows") set_target_properties(OpenCVPlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/Windows/x86_64" RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/Windows/x86_64" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") set_target_properties(OpenCVPlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/macOS/x86_64" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") set_target_properties(OpenCVPlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/../../Assets/Plugins/OpenCVPlugin/Linux/x86_64" ) endif()

C++包装器代码

opencv_wrapper.h:

#pragma once #ifdef _WIN32 #define API_EXPORT __declspec(dllexport) #else #define API_EXPORT #endif extern "C" { // 初始化OpenCV API_EXPORT bool InitializeOpenCV(); // 处理图像数据 API_EXPORT bool ProcessImage(unsigned char* imageData, int width, int height, int channels); // 检测人脸 API_EXPORT int DetectFaces(unsigned char* imageData, int width, int height, int channels, int* facesX, int* facesY, int* facesWidth, int* facesHeight, int maxFaces); // 释放资源 API_EXPORT void ReleaseOpenCV(); }

opencv_wrapper.cpp:

#include "opencv_wrapper.h" #include <opencv2/opencv.hpp> #include <opencv2/objdetect.hpp> static cv::CascadeClassifier faceCascade; extern "C" { API_EXPORT bool InitializeOpenCV() { try { // 加载人脸检测级联分类器 std::string cascadePath = "haarcascade_frontalface_default.xml"; if (!faceCascade.load(cascadePath)) { return false; } return true; } catch (...) { return false; } } API_EXPORT bool ProcessImage(unsigned char* imageData, int width, int height, int channels) { try { // 将输入数据转换为OpenCV Mat cv::Mat inputImage(height, width, CV_MAKETYPE(CV_8U, channels), imageData); // 示例处理：转换为灰度图 cv::Mat grayImage; cv::cvtColor(inputImage, grayImage, cv::COLOR_BGR2GRAY); // 应用高斯模糊 cv::GaussianBlur(grayImage, grayImage, cv::Size(5, 5), 0); // 边缘检测 cv::Mat edges; cv::Canny(grayImage, edges, 50, 150); // 将处理后的图像复制回输入数据 cv::Mat outputImage; cv::cvtColor(edges, outputImage, cv::COLOR_GRAY2BGR); std::memcpy(imageData, outputImage.data, width * height * channels); return true; } catch (...) { return false; } } API_EXPORT int DetectFaces(unsigned char* imageData, int width, int height, int channels, int* facesX, int* facesY, int* facesWidth, int* facesHeight, int maxFaces) { try { // 将输入数据转换为OpenCV Mat cv::Mat inputImage(height, width, CV_MAKETYPE(CV_8U, channels), imageData); // 转换为灰度图 cv::Mat grayImage; cv::cvtColor(inputImage, grayImage, cv::COLOR_BGR2GRAY); // 检测人脸 std::vector<cv::Rect> faces; faceCascade.detectMultiScale(grayImage, faces, 1.1, 3, 0, cv::Size(30, 30)); // 复制检测结果到输出数组 int detectedFaces = (faces.size() < maxFaces) ? faces.size() : maxFaces; for (int i = 0; i < detectedFaces; i++) { facesX[i] = faces[i].x; facesY[i] = faces[i].y; facesWidth[i] = faces[i].width; facesHeight[i] = faces[i].height; } return detectedFaces; } catch (...) { return 0; } } API_EXPORT void ReleaseOpenCV() { // 清理资源 faceCascade.~CascadeClassifier(); } }

Unity C#脚本

OpenCVController.cs:

using UnityEngine; using System; using System.Runtime.InteropServices; public class OpenCVController : MonoBehaviour { // 导入本地插件函数 [DllImport("OpenCVPlugin")] private static extern bool InitializeOpenCV(); [DllImport("OpenCVPlugin")] private static extern bool ProcessImage(byte[] imageData, int width, int height, int channels); [DllImport("OpenCVPlugin")] private static extern int DetectFaces(byte[] imageData, int width, int height, int channels, int[] facesX, int[] facesY, int[] facesWidth, int[] facesHeight, int maxFaces); [DllImport("OpenCVPlugin")] private static extern void ReleaseOpenCV(); public Texture2D inputTexture; public Material outputMaterial; private bool isInitialized = false; void Start() { // 初始化OpenCV isInitialized = InitializeOpenCV(); if (!isInitialized) { Debug.LogError("Failed to initialize OpenCV"); } } void Update() { if (isInitialized && Input.GetKeyDown(KeyCode.Space)) { // 处理图像 ProcessCurrentTexture(); } } void ProcessCurrentTexture() { // 获取纹理数据 byte[] imageData = inputTexture.GetRawTextureData(); int width = inputTexture.width; int height = inputTexture.height; int channels = 4; // RGBA // 处理图像 bool success = ProcessImage(imageData, width, height, channels); if (success) { // 将处理后的数据加载回纹理 inputTexture.LoadRawTextureData(imageData); inputTexture.Apply(); // 应用到材质 if (outputMaterial != null) { outputMaterial.mainTexture = inputTexture; } } else { Debug.LogError("Failed to process image"); } } public Rect[] DetectFacesInTexture() { if (!isInitialized) { Debug.LogError("OpenCV not initialized"); return new Rect[0]; } // 获取纹理数据 byte[] imageData = inputTexture.GetRawTextureData(); int width = inputTexture.width; int height = inputTexture.height; int channels = 4; // RGBA // 准备输出数组 const int maxFaces = 10; int[] facesX = new int[maxFaces]; int[] facesY = new int[maxFaces]; int[] facesWidth = new int[maxFaces]; int[] facesHeight = new int[maxFaces]; // 检测人脸 int detectedFaces = DetectFaces(imageData, width, height, channels, facesX, facesY, facesWidth, facesHeight, maxFaces); // 转换为Rect数组 Rect[] result = new Rect[detectedFaces]; for (int i = 0; i < detectedFaces; i++) { // 转换坐标系（OpenCV使用左上角为原点，Unity使用左下角为原点） float y = height - (facesY[i] + facesHeight[i]); result[i] = new Rect(facesX[i], y, facesWidth[i], facesHeight[i]); } return result; } void OnDestroy() { // 释放资源 if (isInitialized) { ReleaseOpenCV(); } } }

构建脚本

build_opencv_plugin.py:

import os import subprocess import platform from pathlib import Path def build_opencv_plugin(build_type="Release"): plugin_dir = Path("native_plugins/OpenCVPlugin") build_dir = plugin_dir / "build" # 创建构建目录 build_dir.mkdir(exist_ok=True) # 确定平台特定的生成器 generators = { "Windows": "Visual Studio 16 2019", "Darwin": "Xcode", "Linux": "Unix Makefiles" } generator = generators.get(platform.system(), "Unix Makefiles") # 设置OpenCV_DIR环境变量（如果需要） opencv_dir = os.environ.get("OPENCV_DIR", "") # 运行CMake配置 cmake_configure = [ "cmake", "..", f"-G{generator}", f"-DCMAKE_BUILD_TYPE={build_type}" ] if opencv_dir: cmake_configure.append(f"-DOpenCV_DIR={opencv_dir}") subprocess.run(cmake_configure, cwd=build_dir, check=True) # 运行构建 cmake_build = ["cmake", "--build", ".", f"--config={build_type}"] subprocess.run(cmake_build, cwd=build_dir, check=True) # 复制OpenCV运行时库（Windows） if platform.system() == "Windows" and opencv_dir: opencv_bin_dir = Path(opencv_dir) / "bin" if opencv_bin_dir.exists(): target_dir = Path("Assets/Plugins/OpenCVPlugin/Windows/x86_64") for dll in opencv_bin_dir.glob("opencv_*.dll"): subprocess.run(["copy", str(dll), str(target_dir)], shell=True) if __name__ == "__main__": build_opencv_plugin()

最佳实践

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

1. 项目结构组织

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

UnityProject/ ├── Assets/ │ ├── Plugins/ │ │ └── Native/ │ │ ├── Plugin1/ │ │ │ ├── include/ │ │ │ └── src/ │ │ └── Plugin2/ │ │ ├── include/ │ │ └── src/ │ └── Scripts/ ├── ProjectSettings/ ├── native_plugins/ │ ├── Plugin1/ │ │ ├── CMakeLists.txt │ │ └── build/ │ └── Plugin2/ │ ├── CMakeLists.txt │ └── build/ └── cmake/ ├── FindSomeLibrary.cmake └── Utils.cmake

2. 平台特定配置

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

# 平台特定配置 if(CMAKE_SYSTEM_NAME STREQUAL "Windows") add_definitions(-DPLATFORM_WINDOWS) # Windows特定库 target_link_libraries(MyPlugin some_windows_lib ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") add_definitions(-DPLATFORM_MACOS) # macOS特定框架 target_link_libraries(MyPlugin "-framework Foundation" "-framework CoreGraphics" ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") add_definitions(-DPLATFORM_LINUX) # Linux特定库 target_link_libraries(MyPlugin some_linux_lib ) elseif(CMAKE_SYSTEM_NAME STREQUAL "Android") add_definitions(-DPLATFORM_ANDROID) # Android特定库 target_link_libraries(MyPlugin log android ) elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS") add_definitions(-DPLATFORM_IOS) # iOS特定框架 target_link_libraries(MyPlugin "-framework Foundation" "-framework UIKit" ) endif()

3. 构建类型配置

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

# 设置编译选项 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") # MSVC编译器选项 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2") else() # GCC/Clang编译器选项 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g") set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3") endif() # 添加预处理器定义 target_compile_definitions(MyPlugin PRIVATE $<$<CONFIG:Debug>:DEBUG_MODE=1> $<$<CONFIG:Release>:NDEBUG> )

4. 依赖管理

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

# 使用FetchContent管理依赖 include(FetchContent) # 声明并获取依赖 FetchContent_Declare( fmt GIT_REPOSITORY https://github.com/fmtlib/fmt.git GIT_TAG 9.1.0 ) FetchContent_MakeAvailable(fmt) # 链接依赖 target_link_libraries(MyPlugin PRIVATE fmt::fmt )

5. 自动化测试

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

# 启用测试 enable_testing() # 添加测试 add_executable(MyPluginTests tests/test_main.cpp tests/test_my_plugin.cpp ) # 链接插件 target_link_libraries(MyPluginTests PRIVATE MyPlugin ) # 添加测试用例 add_test(NAME MyPluginBasicTest COMMAND MyPluginTests)

性能优化

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

1. 条件编译

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

# 功能开关 option(ENABLE_FEATURE_X "Enable feature X" ON) if(ENABLE_FEATURE_X) target_sources(MyPlugin PRIVATE src/feature_x.cpp ) target_compile_definitions(MyPlugin PRIVATE FEATURE_X_ENABLED ) endif()

2. 优化构建过程

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

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

3. 内存管理优化

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

// 示例：使用共享内存减少数据复制 extern "C" { // 分配共享内存 API_EXPORT void* AllocateSharedMemory(size_t size); // 释放共享内存 API_EXPORT void FreeSharedMemory(void* ptr); // 在共享内存中处理数据 API_EXPORT bool ProcessInSharedMemory(void* data, size_t size); }

4. 多线程处理

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

#include <thread> #include <vector> extern "C" { API_EXPORT void ProcessDataParallel(void* data, size_t size, int numThreads) { std::vector<std::thread> threads; size_t chunkSize = size / numThreads; for (int i = 0; i < numThreads; ++i) { threads.emplace_back([data, chunkSize, i, numThreads]() { size_t start = i * chunkSize; size_t end = (i == numThreads - 1) ? size : start + chunkSize; ProcessDataChunk(static_cast<char*>(data) + start, end - start); }); } for (auto& thread : threads) { thread.join(); } } }

常见问题与解决方案

1. 平台特定问题

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

解决方案：

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

# 示例：处理Windows运行时库 if(CMAKE_SYSTEM_NAME STREQUAL "Windows") # 静态链接运行时库 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd") # 确保运行时库被复制到输出目录 add_custom_command(TARGET MyPlugin POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_RUNTIME_DLLS:MyPlugin>" $<TARGET_FILE_DIR:MyPlugin> COMMAND_EXPAND_LISTS ) endif()

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

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

解决方案：

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

// C#示例：高效处理大数组 using System; using System.Runtime.InteropServices; public class NativeArrayHandler : IDisposable { private IntPtr nativeArrayPtr; private int size; public NativeArrayHandler(int size) { this.size = size; nativeArrayPtr = Marshal.AllocHGlobal(size * Marshal.SizeOf(typeof(float))); } public void CopyFrom(float[] source) { Marshal.Copy(source, 0, nativeArrayPtr, size); } public void CopyTo(float[] destination) { Marshal.Copy(nativeArrayPtr, destination, 0, size); } public IntPtr GetPointer() { return nativeArrayPtr; } public void Dispose() { if (nativeArrayPtr != IntPtr.Zero) { Marshal.FreeHGlobal(nativeArrayPtr); nativeArrayPtr = IntPtr.Zero; } } }

3. CMake构建缓存问题

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

解决方案：

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

# 清理并重新构建示例 rm -rf build mkdir build cd build cmake .. make

4. Android构建问题

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

解决方案：

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

# Android ABI特定配置 if(ANDROID) message(STATUS "Building for Android ABI: ${ANDROID_ABI}") # ABI特定设置 if(ANDROID_ABI STREQUAL "armeabi-v7a") target_compile_options(MyPlugin PRIVATE -mfloat-abi=softfp -mfpu=neon) elseif(ANDROID_ABI STREQUAL "arm64-v8a") target_compile_options(MyPlugin PRIVATE -march=armv8-a) endif() endif()