extension/src/openvic-extension/register_types.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

#include "register_types.hpp"

#include <godot_cpp/classes/engine.hpp>

#include "openvic-extension/classes/GFXButtonStateTexture.hpp"
#include "openvic-extension/classes/GFXSpriteTexture.hpp"
#include "openvic-extension/classes/GFXMaskedFlagTexture.hpp"
#include "openvic-extension/classes/GFXPieChartTexture.hpp"
#include "openvic-extension/classes/GUIListBox.hpp"
#include "openvic-extension/classes/GUINode.hpp"
#include "openvic-extension/classes/GUIOverlappingElementsBox.hpp"
#include "openvic-extension/classes/GUIScrollbar.hpp"
#include "openvic-extension/classes/GUITextLabel.hpp"
#include "openvic-extension/classes/MapMesh.hpp"
#include "openvic-extension/singletons/AssetManager.hpp"
#include "openvic-extension/singletons/Checksum.hpp"
#include "openvic-extension/singletons/GameSingleton.hpp"
#include "openvic-extension/singletons/LoadLocalisation.hpp"
#include "openvic-extension/singletons/MenuSingleton.hpp"
#include "openvic-extension/singletons/ModelSingleton.hpp"
#include "openvic-extension/singletons/SoundSingleton.hpp"

using namespace godot;
using namespace OpenVic;

static Checksum* _checksum_singleton = nullptr;
static LoadLocalisation* _load_localisation = nullptr;
static GameSingleton* _game_singleton = nullptr;
static MenuSingleton* _menu_singleton = nullptr;
static ModelSingleton* _model_singleton = nullptr;
static AssetManager* _asset_manager_singleton = nullptr;
static SoundSingleton* _sound_singleton = nullptr;

void initialize_openvic_types(ModuleInitializationLevel p_level) {
   if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
      return;
   }

   ClassDB::register_class<Checksum>();
   _checksum_singleton = memnew(Checksum);
   Engine::get_singleton()->register_singleton("Checksum", Checksum::get_singleton());

   ClassDB::register_class<LoadLocalisation>();
   _load_localisation = memnew(LoadLocalisation);
   Engine::get_singleton()->register_singleton("LoadLocalisation", LoadLocalisation::get_singleton());

   ClassDB::register_class<GameSingleton>();
   _game_singleton = memnew(GameSingleton);
   Engine::get_singleton()->register_singleton("GameSingleton", GameSingleton::get_singleton());

   ClassDB::register_class<MenuSingleton>();
   _menu_singleton = memnew(MenuSingleton);
   Engine::get_singleton()->register_singleton("MenuSingleton", MenuSingleton::get_singleton());

   ClassDB::register_class<ModelSingleton>();
   _model_singleton = memnew(ModelSingleton);
   Engine::get_singleton()->register_singleton("ModelSingleton", ModelSingleton::get_singleton());

   ClassDB::register_class<AssetManager>();
   _asset_manager_singleton = memnew(AssetManager);
   Engine::get_singleton()->register_singleton("AssetManager", AssetManager::get_singleton());

   ClassDB::register_class<SoundSingleton>();
   _sound_singleton = memnew(SoundSingleton);
   Engine::get_singleton()->register_singleton("SoundSingleton", SoundSingleton::get_singleton());

   ClassDB::register_class<MapMesh>();
   ClassDB::register_abstract_class<GFXCorneredTileSupportingTexture>();

   /* Depend on GFXCorneredTileSupportingTexture */
   ClassDB::register_class<GFXButtonStateTexture>();
   ClassDB::register_abstract_class<GFXButtonStateHavingTexture>();

   /* Depend on GFXButtonStateHavingTexture */
   ClassDB::register_class<GFXSpriteTexture>();
   ClassDB::register_class<GFXMaskedFlagTexture>();

   ClassDB::register_class<GFXPieChartTexture>();
   ClassDB::register_class<GUIListBox>();
   ClassDB::register_class<GUINode>();
   ClassDB::register_class<GUIOverlappingElementsBox>();
   ClassDB::register_class<GUIScrollbar>();
   ClassDB::register_class<GUITextLabel>();
}

void uninitialize_openvic_types(ModuleInitializationLevel p_level) {
   if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
      return;
   }

   Engine::get_singleton()->unregister_singleton("Checksum");
   memdelete(_checksum_singleton);

   Engine::get_singleton()->unregister_singleton("LoadLocalisation");
   memdelete(_load_localisation);

   Engine::get_singleton()->unregister_singleton("GameSingleton");
   memdelete(_game_singleton);

   Engine::get_singleton()->unregister_singleton("MenuSingleton");
   memdelete(_menu_singleton);

   Engine::get_singleton()->unregister_singleton("ModelSingleton");
   memdelete(_model_singleton);

   Engine::get_singleton()->unregister_singleton("AssetManager");
   memdelete(_asset_manager_singleton);

   Engine::get_singleton()->unregister_singleton("SoundSingleton");
   memdelete(_sound_singleton);
}

extern "C" {
   // Initialization.
   GDExtensionBool GDE_EXPORT openvic_library_init(
      GDExtensionInterfaceGetProcAddress p_get_proc_address, GDExtensionClassLibraryPtr p_library,
      GDExtensionInitialization* r_initialization
   ) {
      GDExtensionBinding::InitObject init_obj(p_get_proc_address, p_library, r_initialization);

      init_obj.register_initializer(initialize_openvic_types);
      init_obj.register_terminator(uninitialize_openvic_types);
      init_obj.set_minimum_library_initialization_level(MODULE_INITIALIZATION_LEVEL_SCENE);

      return init_obj.init();
   }
}