自定义Godot服务

简介

Godot implements multi-threading as servers. Servers are daemons which manage data, process it, and push the result. Servers implement the mediator pattern which interprets resource ID and process data for the engine and other modules. In addition, the server claims ownership for its RID allocations.

本指南假设读者知道如何创建C++模块和Godot数据类型。如果没有，请参考 自定义C++模块。

参考

可以做什么？

  • 添加人工智能。
  • 添加自定义异步线程。
  • 添加对新输入设备的支持。
  • 添加写线程。
  • 添加自定义VoIP协议。
  • 以及更多…

创建Godot服务

至少，服务必须具有静态实例、睡眠计时器、线程循环、初始化状态、和清理过程。

  1. #ifndef HILBERT_HOTEL_H
  2. #define HILBERT_HOTEL_H
  4. #include "core/list.h"
  5. #include "core/object.h"
  6. #include "core/os/thread.h"
  7. #include "core/os/mutex.h"
  8. #include "core/rid.h"
  9. #include "core/set.h"
  10. #include "core/variant.h"
  12. class HilbertHotel : public Object {
  13.         GDCLASS(HilbertHotel, Object);
  15.         static HilbertHotel *singleton;
  16.         static void thread_func(void *p_udata);
  18. private:
  19.         bool thread_exited;
  20.         mutable bool exit_thread;
  21.         Thread *thread;
  22.         Mutex *mutex;
  24. public:
  25.         static HilbertHotel *get_singleton();
  26.         Error init();
  27.         void lock();
  28.         void unlock();
  29.         void finish();
  31. protected:
  32.         static void _bind_methods();
  34. private:
  35.         uint64_t counter;
  36.         RID_Owner<InfiniteBus> bus_owner;
  37.         // https://github.com/godotengine/godot/blob/master/core/rid.h#L196
  38.         Set<RID> buses;
  39.         void _emit_occupy_room(uint64_t room, RID rid);
  41. public:
  42.         RID create_bus();
  43.         Variant get_bus_info(RID id);
  44.         bool empty();
  45.         bool delete_bus(RID id);
  46.         void clear();
  47.         void register_rooms();
  48.         HilbertHotel();
  49. };
  51. #endif
  1. #include "hilbert_hotel.h"
  3. #include "core/dictionary.h"
  4. #include "core/list.h"
  5. #include "core/os/os.h"
  6. #include "core/variant.h"
  8. #include "prime_225.h"
  10. void HilbertHotel::thread_func(void *p_udata) {
  12.         HilbertHotel *ac = (HilbertHotel *) p_udata;
  13.         uint64_t msdelay = 1000;
  15.         while (!ac->exit_thread) {
  16.                 if (!ac->empty()) {
  17.                         ac->lock();
  18.                         ac->register_rooms();
  19.                         ac->unlock();
  20.                 }
  21.                 OS::get_singleton()->delay_usec(msdelay * 1000);
  22.         }
  23. }
  25. Error HilbertHotel::init() {
  26.         thread_exited = false;
  27.         counter = 0;
  28.         mutex = Mutex::create();
  29.         thread = Thread::create(HilbertHotel::thread_func, this);
  30.         return OK;
  31. }
  33. HilbertHotel *HilbertHotel::singleton = NULL;
  35. HilbertHotel *HilbertHotel::get_singleton() {
  36.         return singleton;
  37. }
  39. void HilbertHotel::register_rooms() {
  40.         for (Set<RID>::Element *e = buses.front(); e; e = e->next()) {
  41.                 auto bus = bus_owner.getornull(e->get());
  43.                 if (bus) {
  44.                         uint64_t room = bus->next_room();
  45.                         _emit_occupy_room(room, bus->get_self());
  46.                 }
  47.         }
  48. }
  50. void HilbertHotel::unlock() {
  51.         if (!thread || !mutex) {
  52.                 return;
  53.         }
  55.         mutex->unlock();
  56. }
  58. void HilbertHotel::lock() {
  59.         if (!thread || !mutex) {
  60.                 return;
  61.         }
  63.         mutex->lock();
  64. }
  66. void HilbertHotel::_emit_occupy_room(uint64_t room, RID rid) {
  67.         _HilbertHotel::get_singleton()->_occupy_room(room, rid);
  68. }
  70. Variant HilbertHotel::get_bus_info(RID id) {
  71.         InfiniteBus *)bus = bus_owner.getornull(id);
  73.         if (bus) {
  74.                 Dictionary d;
  75.                 d["prime"] = bus->get_bus_num();
  76.                 d["current_room"] = bus->get_current_room();
  77.                 return d;
  78.         }
  80.         return Variant();
  81. }
  83. void HilbertHotel::finish() {
  84.         if (!thread) {
  85.                 return;
  86.         }
  88.         exit_thread = true;
  89.         Thread::wait_to_finish(thread);
  91.         memdelete(thread);
  93.         if (mutex) {
  94.                 memdelete(mutex);
  95.         }
  97.         thread = NULL;
  98. }
  100. RID HilbertHotel::create_bus() {
  101.         lock();
  102.         InfiniteBus *ptr = memnew(InfiniteBus(PRIME[counter++]));
  103.         RID ret = bus_owner.make_rid(ptr);
  104.         ptr->set_self(ret);
  105.         buses.insert(ret);
  106.         unlock();
  108.         return ret;
  109. }
  111. // https://github.com/godotengine/godot/blob/master/core/rid.h#L187
  112. bool HilbertHotel::delete_bus(RID id) {
  113.         if (bus_owner.owns(id)) {
  114.                 lock();
  115.                 InfiniteBus *b = bus_owner.get(id);
  116.                 bus_owner.free(id);
  117.                 buses.erase(id);
  118.                 memdelete(b);
  119.                 unlock();
  120.                 return true;
  121.         }
  123.         return false;
  124. }
  126. void HilbertHotel::clear() {
  127.         for (Set<RID>::Element *e = buses.front(); e; e = e->next()) {
  128.                 delete_bus(e->get());
  129.         }
  130. }
  132. bool HilbertHotel::empty() {
  133.         return buses.size() <= 0;
  134. }
  136. void HilbertHotel::_bind_methods() {
  137. }
  139. HilbertHotel::HilbertHotel() {
  140.         singleton = this;
  141. }
  1. /* prime_225.h */
  3. #include "core/int_types.h"
  5. const uint64_t PRIME[225] = {
  6.                 2,3,5,7,11,13,17,19,23,
  7.                 29,31,37,41,43,47,53,59,61,
  8.                 67,71,73,79,83,89,97,101,103,
  9.                 107,109,113,127,131,137,139,149,151,
  10.                 157,163,167,173,179,181,191,193,197,
  11.                 199,211,223,227,229,233,239,241,251,
  12.                 257,263,269,271,277,281,283,293,307,
  13.                 311,313,317,331,337,347,349,353,359,
  14.                 367,373,379,383,389,397,401,409,419,
  15.                 421,431,433,439,443,449,457,461,463,
  16.                 467,479,487,491,499,503,509,521,523,
  17.                 541,547,557,563,569,571,577,587,593,
  18.                 599,601,607,613,617,619,631,641,643,
  19.                 647,653,659,661,673,677,683,691,701,
  20.                 709,719,727,733,739,743,751,757,761,
  21.                 769,773,787,797,809,811,821,823,827,
  22.                 829,839,853,857,859,863,877,881,883,
  23.                 887,907,911,919,929,937,941,947,953,
  24.                 967,971,977,983,991,997,1009,1013,1019,
  25.                 1021,1031,1033,1039,1049,1051,1061,1063,1069,
  26.                 1087,1091,1093,1097,1103,1109,1117,1123,1129,
  27.                 1151,1153,1163,1171,1181,1187,1193,1201,1213,
  28.                 1217,1223,1229,1231,1237,1249,1259,1277,1279,
  29.                 1283,1289,1291,1297,1301,1303,1307,1319,1321,
  30.                 1327,1361,1367,1373,1381,1399,1409,1423,1427
  31. };

自定义托管资源数据

Godot服务实现了中介模式。所有数据类型都继承 RID_Data 。`RID_Owner <MyRID_Data> 在调用 make_rid 时拥有对象。仅在调试模式期间，RID_Owner维护RID列表。实际上，RID类似于编写面向对象的C代码。

  1. class InfiniteBus : public RID_Data {
  2.         RID self;
  4. private:
  5.         uint64_t prime_num;
  6.         uint64_t num;
  8. public:
  9.         uint64_t next_room() {
  10.                 return prime_num * num++;
  11.         }
  13.         uint64_t get_bus_num() const {
  14.                 return prime_num;
  15.         }
  17.         uint64_t get_current_room() const {
  18.                 return prime_num * num;
  19.         }
  21.         _FORCE_INLINE_ void set_self(const RID &p_self) {
  22.                 self = p_self;
  23.         }
  25.         _FORCE_INLINE_ RID get_self() const {
  26.                 return self;
  27.         }
  29.         InfiniteBus(uint64_t prime) : prime_num(prime), num(1) {};
  30.         ~InfiniteBus() {};
  31. }

参考

在GDScript中注册类

服务在 register_types.cpp 中分配。构造函数设置静态实例，init() 创建托管线程； unregister_types.cpp 清理服务。

由于Godot服务类创建了一个实例并将其绑定到静态单例，因此绑定该类可能不会引用正确的实例。因此，必须创建一个虚拟类来引用正确的Godot服务。

在 register_server_types() 中，Engine :: get_singleton() -> add_singleton 用于在GDScript中注册虚拟类。

  1. /* register_types.cpp */
  3. #include "register_types.h"
  5. #include "core/class_db.h"
  6. #include "core/engine.h"
  8. #include "hilbert_hotel.h"
  10. static HilbertHotel *hilbert_hotel = NULL;
  11. static _HilbertHotel *_hilbert_hotel = NULL;
  13. void register_hilbert_hotel_types() {
  14.         hilbert_hotel = memnew(HilbertHotel);
  15.         hilbert_hotel->init();
  16.         _hilbert_hotel = memnew(_HilbertHotel);
  17.         ClassDB::register_class<_HilbertHotel>();
  18.         Engine::get_singleton()->add_singleton(Engine::Singleton("HilbertHotel", _HilbertHotel::get_singleton()));
  19. }
  21. void unregister_hilbert_hotel_types() {
  22.         if (hilbert_hotel) {
  23.                 hilbert_hotel->finish();
  24.                 memdelete(hilbert_hotel);
  25.         }
  27.         if (_hilbert_hotel) {
  28.                 memdelete(_hilbert_hotel);
  29.         }
  30. }
  1. /* register_types.h */
  3. /* Yes, the word in the middle must be the same as the module folder name */
  4. void register_hilbert_hotel_types();
  5. void unregister_hilbert_hotel_types();

绑定方法

虚拟类将单例方法绑定到GDScript。在大多数情况下，虚拟类方法封装在内。

  1. Variant _HilbertHotel::get_bus_info(RID id) {
  2.         return HilbertHotel::get_singleton()->get_bus_info(id);
  3. }

绑定信号

可以通过调用GDScript虚拟对象向GDScript发出信号。

  1. void HilbertHotel::_emit_occupy_room(uint64_t room, RID rid) {
  2.         _HilbertHotel::get_singleton()->_occupy_room(room, rid);
  3. }
  1. class _HilbertHotel : public Object {
  2.         GDCLASS(_HilbertHotel, Object);
  4.         friend class HilbertHotel;
  5.         static _HilbertHotel *singleton;
  7. protected:
  8.         static void _bind_methods();
  10. private:
  11.         void _occupy_room(int room_number, RID bus);
  13. public:
  14.         RID create_bus();
  15.         void connect_signals();
  16.         bool delete_bus(RID id);
  17.         static _HilbertHotel *get_singleton();
  18.         Variant get_bus_info(RID id);
  20.         _HilbertHotel();
  21.         ~_HilbertHotel();
  22. };
  24. #endif
  1. _HilbertHotel *_HilbertHotel::singleton = NULL;
  2. _HilbertHotel *_HilbertHotel::get_singleton() { return singleton; }
  4. RID _HilbertHotel::create_bus() {
  5.         return HilbertHotel::get_singleton()->create_bus();
  6. }
  8. bool _HilbertHotel::delete_bus(RID rid) {
  9.         return HilbertHotel::get_singleton()->delete_bus(rid);
  10. }
  12. void _HilbertHotel::_occupy_room(int room_number, RID bus) {
  13.         emit_signal("occupy_room", room_number, bus);
  14. }
  16. Variant _HilbertHotel::get_bus_info(RID id) {
  17.         return HilbertHotel::get_singleton()->get_bus_info(id);
  18. }
  20. void _HilbertHotel::_bind_methods() {
  21.         ClassDB::bind_method(D_METHOD("get_bus_info", "r_id"), &_HilbertHotel::get_bus_info);
  22.         ClassDB::bind_method(D_METHOD("create_bus"), &_HilbertHotel::create_bus);
  23.         ClassDB::bind_method(D_METHOD("delete_bus"), &_HilbertHotel::delete_bus);
  24.         ADD_SIGNAL(MethodInfo("occupy_room", PropertyInfo(Variant::INT, "room_number"), PropertyInfo(Variant::_RID, "r_id")));
  25. }
  27. void _HilbertHotel::connect_signals() {
  28.         HilbertHotel::get_singleton()->connect("occupy_room", _HilbertHotel::get_singleton(), "_occupy_room");
  29. }
  31. _HilbertHotel::_HilbertHotel() {
  32.         singleton = this;
  33. }
  35. _HilbertHotel::~_HilbertHotel() {
  36. }

MessageQueue

为了将命令发送到SceneTree中，MessageQueue是线程安全的缓冲区，用于将其他线程的设置和调用方法排队。要对命令进行排队，请获取目标对象RID并使用 push_call、 push_set、或 push_notification 执行所需的行为。每当执行 SceneTree::idle 或 SceneTree::iteration 时，都会刷新队列。

参考：

总结

这是GDScript示例代码：

  1. extends Node
  3. func _ready():
  4.     print("Start debugging")
  5.     HilbertHotel.connect("occupy_room", self, "_print_occupy_room")
  6.     var rid = HilbertHotel.create_bus()
  7.     OS.delay_msec(2000)
  8.     HilbertHotel.create_bus()
  9.     OS.delay_msec(2000)
  10.     HilbertHotel.create_bus()
  11.     OS.delay_msec(2000)
  12.     print(HilbertHotel.get_bus_info(rid))
  13.     HilbertHotel.delete_bus(rid)
  14.     print("Ready done")
  16. func _print_occupy_room(room_number, r_id):
  17.     print("Room number: "  + str(room_number) + ", RID: " + str(r_id))
  18.     print(HilbertHotel.get_bus_info(r_id))

注意