自定义C++模块

模块(Modules)

Godot 允许通过模块化的方式对引擎进行扩展.您可以创建新的模块,然后启用/禁用它.这允许在每个级别添加新的引擎功能,而无需修改内核,可以将其拆分以供在不同模块中使用和重用.

模块位于构建系统的 modules/ 子目录下.默认情况下,有几十个模块被启用,如GDScript(是的,它不是基础引擎的一部分)、Mono运行时、正则表达式模块和其他.可以根据需要创建和组合尽可能多的新模块.SCons构建系统将清晰地处理它.

可以做什么？

尽管我们建议使用脚本编写游戏的大部分代码(因为这能够节省大量的时间),但使用 C++ 进行开发也是完全可行的.在以下情况下,添加C ++模块可能会很有用:

  • 将外部库绑定到Godot(例如PhysX、FMOD等).

  • 优化游戏的核心部分.

  • 为引擎和/或编辑器添加新功能.

  • 移植现有的游戏项目.

  • 使用 C++ 编写整个新游戏,因为您离不开 C++.

创新新模块

在创建模块之前,请确保下载Godot的源代码并进行编译.文档中有相关教程.

要创建一个新模块,首先我们要在 modules/ 文件夹下创建一个新目录.如果要单独维护模块,则可以在版本控制系统(VCS)检出到模块中并使用它.

示例模块将被称为 求和器(summator),并放置在Godot源代码树的内部(C:\godot 指的是Godot源代码所在的位置):

  1. C:\godot> cd modules
  2. C:\godot\modules> mkdir summator
  3. C:\godot\modules> cd summator
  4. C:\godot\modules\summator>

在内部,我们将创建一个简单的 summator 类:

  1. /* summator.h */
  3. #ifndef SUMMATOR_H
  4. #define SUMMATOR_H
  6. #include "core/reference.h"
  8. class Summator : public Reference {
  9.     GDCLASS(Summator, Reference);
  11.     int count;
  13. protected:
  14.     static void _bind_methods();
  16. public:
  17.     void add(int p_value);
  18.     void reset();
  19.     int get_total() const;
  21.     Summator();
  22. };
  24. #endif // SUMMATOR_H

然后是cpp文件.

  1. /* summator.cpp */
  3. #include "summator.h"
  5. void Summator::add(int p_value) {
  6.     count += p_value;
  7. }
  9. void Summator::reset() {
  10.     count = 0;
  11. }
  13. int Summator::get_total() const {
  14.     return count;
  15. }
  17. void Summator::_bind_methods() {
  18.     ClassDB::bind_method(D_METHOD("add", "value"), &Summator::add);
  19.     ClassDB::bind_method(D_METHOD("reset"), &Summator::reset);
  20.     ClassDB::bind_method(D_METHOD("get_total"), &Summator::get_total);
  21. }
  23. Summator::Summator() {
  24.     count = 0;
  25. }

然后,需要以某种方式注册新类,因此需要再创建两个文件:

  1. register_types.h
  2. register_types.cpp

重要

这些文件必须在您的模块的顶层文件夹中( SCsub 和 config.py 文件旁边),这样模块才能被正确注册.

这些文件应包含以下内容:

  1. /* register_types.h */
  3. void register_summator_types();
  4. void unregister_summator_types();
  5. /* yes, the word in the middle must be the same as the module folder name */
  1. /* register_types.cpp */
  3. #include "register_types.h"
  5. #include "core/class_db.h"
  6. #include "summator.h"
  8. void register_summator_types() {
  9.     ClassDB::register_class<Summator>();
  10. }
  12. void unregister_summator_types() {
  13.    // Nothing to do here in this example.
  14. }

接下来,我们需要创建一个 SCsub 文件,以便构建系统编译此模块:

  1. # SCsub
  3. Import('env')
  5. env.add_source_files(env.modules_sources, "*.cpp") # Add all cpp files to the build

使用多个源文件,您还可以将每个文件分别添加到Python字符串列表中:

  1. src_list = ["summator.cpp", "other.cpp", "etc.cpp"]
  2. env.add_source_files(env.modules_sources, src_list)

使用循环和逻辑语句,这使得使用Python来构建文件列表有了强大的可行性.请看Godot默认的一些模块的例子.

要添加供编译器查看的包含目录,可以将其追加到环境的路径中:

  1. env.Append(CPPPATH=["mylib/include"]) # this is a relative path
  2. env.Append(CPPPATH=["#myotherlib/include"]) # this is an 'absolute' path

If you want to add custom compiler flags when building your module, you need to clone env first, so it won’t add those flags to whole Godot build (which can cause errors). Example SCsub with custom flags:

  1. # SCsub
  3. Import('env')
  5. module_env = env.Clone()
  6. module_env.add_source_files(env.modules_sources, "*.cpp")
  7. # Append CCFLAGS flags for both C and C++ code.
  8. module_env.Append(CCFLAGS=['-O2'])
  9. # If you need to, you can:
  10. # - Append CFLAGS for C code only.
  11. # - Append CXXFLAGS for C++ code only.

最后是模块的配置文件,这是一个简单的python脚本,必须命名为 config.py:

  1. # config.py
  3. def can_build(env, platform):
  4.     return True
  6. def configure(env):
  7.     pass

询问模块是否可以针对特定平台进行构建(在这种情况下,``True`` 表示它将针对每个平台进行构建).

就是这样. 希望它不太复杂！ 您的模块应如下所示:

  1. godot/modules/summator/config.py
  2. godot/modules/summator/summator.h
  3. godot/modules/summator/summator.cpp
  4. godot/modules/summator/register_types.h
  5. godot/modules/summator/register_types.cpp
  6. godot/modules/summator/SCsub

然后,您可以压缩它并与其他所有人分享该模块.当针对每个平台进行构建时(上一节中的说明),您的模块将包括在内.

注解

对于子类之类的东西,C ++模块中的参数限制为5. 通过包含头文件``core/method_bind_ext.gen.inc``,可以将其增加到13个.

使用模块

现在,您可以通过任何脚本使用新创建的模块:

  1. var s = Summator.new()
  2. s.add(10)
  3. s.add(20)
  4. s.add(30)
  5. print(s.get_total())
  6. s.reset()

输出将是 60 .

参见

前面的Summator例子对于小型的自定义模块来说是很好的,但是如果你想使用一个更大的外部库呢？请参考 绑定到外部库,了解有关绑定外部库的细节.

警告

如果要从正在运行的项目(而不仅仅是从编辑器)访问模块,则还必须重新编译计划使用的每个导出模板,然后在每个导出预设中指定自定义模板的路径. 否则,由于未在导出模板中编译模块,因此在运行项目时会出现错误. 有关更多信息,请参见:编译`Compiling <toc-devel-compiling>`页面.

从外部编译模块

编译一个模块需要将模块的源代码直接移到引擎的 modules/ 目录下.虽然这是最直接的编译模块的方法,但是有几个原因说明为什么这样做不实用:

  1. 每次编译引擎时,不管有没有模块,都必须手动复制模块源码,或者在编译过程中使用类似 module_summator_enabled=no 的编译选项,采取额外的步骤手动禁用模块.创建符号链接也是一种解决方案,但你可能还需要克服操作系统的限制,比如如果通过脚本来做,需要符号链接的权限.

  2. 根据你是否需要使用引擎的源代码,直接添加到 modules/ 的模块文件会改变工作树,以至于使用VCS(比如 git )被证明是很麻烦的,因为你需要通过过滤变化来确保只提交与引擎相关的代码.

所以,如果你觉得需要自定义模块的独立结构,把 “summator”模块移到引擎的父目录下:

  1. mkdir ../modules
  2. mv modules/summator ../modules

通过提供 custom_modules 构建选项来编译我们的引擎,该选项接受一个以逗号分隔的包含自定义C++模块的目录路径列表,类似于下面:

  1. scons custom_modules=../modules

构建系统将检测到 ./modules 目录下的所有模块并进行相应的编译,包括 “summator” 模块.

警告

传递给 custom_modules 的任何路径都将在内部转换为绝对路径,以区分自定义模块和内置模块,这意味着像生成模块文档这样的事情可能会依赖于你机器上的特定路径结构.

参见

构建系统介绍 - 自定义模块构建选项.

改善开发的构建系统

到目前为止,我们定义了一个干净简单的SCsub,它允许我们将新模块的源文件添加为Godot二进制文件的一部分.

那么当我们要构建游戏的发行版,并希望将所有模块都放在一个二进制文件中时,这种静态方法就很好.

然而,代价是每一个变化都意味着游戏的全面重新编译.即使SCons能够检测并重新编译已经改变的文件,找到这些文件并最终链接到最终的二进制文件是一个漫长而消耗的部分.

避免这种成本的解决方案是将我们自己的模块构建为共享库,该库在启动游戏二进制文件时将动态加载.

  1. # SCsub
  3. Import('env')
  5. sources = [
  6.     "register_types.cpp",
  7.     "summator.cpp"
  8. ]
  10. # First, create a custom env for the shared library.
  11. module_env = env.Clone()
  13. # Position-independent code is required for a shared library.
  14. module_env.Append(CCFLAGS=['-fPIC'])
  16. # Don't inject Godot's dependencies into our shared library.
  17. module_env['LIBS'] = []
  19. # Define the shared library. By default, it would be built in the module's
  20. # folder, however it's better to output it into `bin` next to the
  21. # Godot binary.
  22. shared_lib = module_env.SharedLibrary(target='#bin/summator', source=sources)
  24. # Finally, notify the main build environment it now has our shared library
  25. # as a new dependency.
  27. # LIBPATH and LIBS need to be set on the real "env" (not the clone)
  28. # to link the specified libraries to the Godot executable.
  30. env.Append(LIBPATH=['#bin'])
  32. # SCons wants the name of the library with it custom suffixes
  33. # (e.g. ".x11.tools.64") but without the final ".so".
  34. shared_lib_shim = shared_lib[0].name.rsplit('.', 1)[0]
  35. env.Append(LIBS=[shared_lib_shim])

一旦编译完成,我们应该有一个 bin 目录,其中包含 godot* 可执行文件和 libsummator*.so .然而,鉴于.so不在一个标准的目录中(如 /usr/lib ),我们必须在运行时用 LD_LIBRARY_PATH 环境变量帮助可执行文件找到它:

  1. export LD_LIBRARY_PATH="$PWD/bin/"
  2. ./bin/godot*

注解

你必须 export 环境变量,否则你将无法从编辑器中播放你的项目.

最重要的是,能够选择将我们的模块编译为共享库(用于开发)还是作为Godot二进制文件的一部分(用于发行版)将是一件很不错的事情.为此,我们可以使用 ARGUMENT 命令定义要传递给SCons的自定义标志:

  1. # SCsub
  3. Import('env')
  5. sources = [
  6.     "register_types.cpp",
  7.     "summator.cpp"
  8. ]
  10. module_env = env.Clone()
  11. module_env.Append(CCFLAGS=['-O2'])
  12. module_env.Append(CXXFLAGS=['-std=c++11'])
  14. if ARGUMENTS.get('summator_shared', 'no') == 'yes':
  15.     # Shared lib compilation
  16.     module_env.Append(CCFLAGS=['-fPIC'])
  17.     module_env['LIBS'] = []
  18.     shared_lib = module_env.SharedLibrary(target='#bin/summator', source=sources)
  19.     shared_lib_shim = shared_lib[0].name.rsplit('.', 1)[0]
  20.     env.Append(LIBS=[shared_lib_shim])
  21.     env.Append(LIBPATH=['#bin'])
  22. else:
  23.     # Static compilation
  24.     module_env.add_source_files(env.modules_sources, sources)

现在默认情况下,``scons`` 命令会将我们的模块构建为Godot二进制文件的一部分,并在传递 summator_shared=yes 时构建为共享库.

最后,你甚至可以通过在SCons命令中明确指定你的共享模块为目标来进一步加快构建速度:

  1. scons summator_shared=yes platform=x11 bin/libsummator.x11.tools.64.so

编写自定义文档

编写文档看起来可能是一项无聊的任务,但仍然强烈建议您为新创建的模块编写文档,以便使用这个模块的其他人从中受益.更不用说,您一年后可能与无法区分它与其他人写的代码,所以对未来的您自己好一点吧！

为了设置模块的自定义文档,有几个步骤:

  1. 在模块的根目录中创建一个新目录.目录名称可以是任何名称,但是在本节中,我们将使用 doc_classes 名称.

  2. 现在,我们需要编辑 config.py ,添加以下片段:

    1. def get_doc_path():
    2.     return "doc_classes"
    4. def get_doc_classes():
    5.     return [
    6.         "Summator",
    7.     ]

构建系统使用 get_doc_path() 函数来确定文档的位置.在这种情况下,它们将位于 modules/summator/doc_classes 目录下.如果你不定义这个,你的模块的文档路径将退回到主 doc/classes 目录.

get_doc_classes() 方法对于构建系统知道哪些注册的类属于该模块是必要的.你需要在这里列出你所有的类.你没有列出的类最终将出现主 doc/classes 目录中.

小技巧

你可以用 Git 来检查是否漏掉了一些类,用 git status 检查未跟踪的文件.例如:

  1. user@host:~/godot$ git status

输出示例:

  1. Untracked files:
  2.     (use "git add <file>..." to include in what will be committed)
  4.     doc/classes/MyClass2D.xml
  5.     doc/classes/MyClass4D.xml
  6.     doc/classes/MyClass5D.xml
  7.     doc/classes/MyClass6D.xml
  8.     ...
  1. 现在我们可以生成文档:

我们可以通过运行Godot的doctool,即 godot -doctool <path> ,它将以XML格式转储引擎API引用到给定的 <path> .

在我们的例子中,将把它指向克隆的版本库的根目录.你可以把它指向另一个文件夹,然后复制需要的文件.

运行命令:

  1. user@host:~/godot/bin$ ./bin/<godot_binary> --doctool .

现在,如果进入 godot/modules/summator/doc_classes 文件夹,会看到它包含一个在 get_doc_classes 函数中引用的 Summator.xml 文件,或者其他类.

编译以下文件 为类参考手册贡献 并重新编译引擎.

一旦编译过程完成,这些文档将可以在引擎的内置文档系统中访问.

为了保持文档的更新,你所要做的就是简单地修改其中一个XML文件,然后从现在开始重新编译引擎.

如果你改变了模块的API,可以重新提取文档,它们会包含你之前添加的东西.当然如果你把它指向 godot 文件夹,请确保不会因为在新的文档上提取旧引擎构建的旧文档而损失工作.

请注意,如果你对提供的 <path> 没有写访问权限,可能会遇到类似下面的错误:

  1. ERROR: Can't write doc file: docs/doc/classes/@GDScript.xml
  2.    At: editor/doc/doc_data.cpp:956

添加自定义编辑器图标

与如何在模块中编写独立的文档类似,您也可以为类创建自己的自定义图标,以使其出现在编辑器中.

有关创建要集成到引擎中的编辑器图标的实际过程,首先请参考 编辑器图标.

创建图标后,请执行以下步骤:

  1. 在名为 icons 的模块的根目录中创建一个新目录.这是引擎查找模块的编辑器图标的默认路径.

  2. 将新创建的 svg 图标(已优化或未优化)移动到该文件夹中.

  3. 重新编译引擎并运行编辑器.现在,相应的图标将出现在编辑器的界面中合适的位置中.

如果您想将图标存储在模块内的其他位置,请将以下代码段添加到 config.py 以覆盖默认路径:

  1. def get_icons_path():
  2.     return "path/to/icons"

总结

记得:

  • 对于继承使用 GDCLASS 宏,因此Godot可以封装它

  • 使用 _bind_methods 将您的函数绑定到脚本,并允许它们充当信号的回调.

但这还不是全部,取决于您做什么,您会得到一些(希望是积极的)惊喜.

  • 如果从 Node (或任何派生的节点类型,例如Sprite)继承,则新类将显示在编辑器的”添加节点”对话框的继承树中.

  • 如果您从 Resource 继承,则它将出现在资源列表中,并且所有暴露的属性在保存/加载时都可以序列化.

  • 通过同样的逻辑,您可以扩展编辑器,以及引擎中几乎所有领域.