Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-04-13 15:20:47 +02:00
Code Issues Packages Projects Releases Wiki Activity

Now modules make use of the new registration levels.

Browse Source
This commit is contained in:
Relintai 2023-01-15 17:04:00 +01:00
parent 50e98d6a10
commit 227e32b67c
55 changed files with 1154 additions and 906 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
editor_modules/cvtt/register_types.cpp
View File

@ -35,8 +35,10 @@
#include "image_compress_cvtt.h" #include "image_compress_cvtt.h"
void register_cvtt_types(ModuleRegistrationLevel p_level) { void register_cvtt_types(ModuleRegistrationLevel p_level) {
Image::set_compress_bptc_func(image_compress_cvtt); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
Image::_image_decompress_bptc = image_decompress_cvtt; Image::set_compress_bptc_func(image_compress_cvtt);
Image::_image_decompress_bptc = image_decompress_cvtt;
}
} }
void unregister_cvtt_types(ModuleRegistrationLevel p_level) {} void unregister_cvtt_types(ModuleRegistrationLevel p_level) {}

14
editor_modules/etc/register_types.cpp
View File

@ -36,13 +36,17 @@
static Ref<ResourceFormatPKM> resource_loader_pkm; static Ref<ResourceFormatPKM> resource_loader_pkm;
void register_etc_types(ModuleRegistrationLevel p_level) { void register_etc_types(ModuleRegistrationLevel p_level) {
resource_loader_pkm.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ResourceLoader::add_resource_format_loader(resource_loader_pkm); resource_loader_pkm.instance();
ResourceLoader::add_resource_format_loader(resource_loader_pkm);
_register_etc_compress_func(); _register_etc_compress_func();
}
} }
void unregister_etc_types(ModuleRegistrationLevel p_level) { void unregister_etc_types(ModuleRegistrationLevel p_level) {
ResourceLoader::remove_resource_format_loader(resource_loader_pkm); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
resource_loader_pkm.unref(); ResourceLoader::remove_resource_format_loader(resource_loader_pkm);
resource_loader_pkm.unref();
}
} }

48
editor_modules/gltf/register_types.cpp
View File

@ -52,30 +52,34 @@ static void _editor_init() {
void register_gltf_types(ModuleRegistrationLevel p_level) { void register_gltf_types(ModuleRegistrationLevel p_level) {
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
ClassDB::APIType prev_api = ClassDB::get_current_api(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
ClassDB::set_current_api(ClassDB::API_EDITOR); ClassDB::APIType prev_api = ClassDB::get_current_api();
ClassDB::register_class<EditorSceneImporterGLTF>(); ClassDB::set_current_api(ClassDB::API_EDITOR);
ClassDB::register_class<GLTFMesh>(); ClassDB::register_class<EditorSceneImporterGLTF>();
EditorPlugins::add_by_type<SceneExporterGLTFPlugin>(); ClassDB::register_class<GLTFMesh>();
ClassDB::set_current_api(prev_api); EditorPlugins::add_by_type<SceneExporterGLTFPlugin>();
EditorNode::add_init_callback(_editor_init); ClassDB::set_current_api(prev_api);
EditorNode::add_init_callback(_editor_init);
}
#endif #endif
ClassDB::register_class<GLTFSpecGloss>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<GLTFNode>(); ClassDB::register_class<GLTFSpecGloss>();
ClassDB::register_class<GLTFAnimation>(); ClassDB::register_class<GLTFNode>();
ClassDB::register_class<GLTFBufferView>(); ClassDB::register_class<GLTFAnimation>();
ClassDB::register_class<GLTFAccessor>(); ClassDB::register_class<GLTFBufferView>();
ClassDB::register_class<GLTFTexture>(); ClassDB::register_class<GLTFAccessor>();
ClassDB::register_class<GLTFTextureSampler>(); ClassDB::register_class<GLTFTexture>();
ClassDB::register_class<GLTFSkeleton>(); ClassDB::register_class<GLTFTextureSampler>();
ClassDB::register_class<GLTFSkin>(); ClassDB::register_class<GLTFSkeleton>();
ClassDB::register_class<GLTFCamera>(); ClassDB::register_class<GLTFSkin>();
ClassDB::register_class<GLTFLight>(); ClassDB::register_class<GLTFCamera>();
ClassDB::register_class<GLTFState>(); ClassDB::register_class<GLTFLight>();
ClassDB::register_class<GLTFDocument>(); ClassDB::register_class<GLTFState>();
ClassDB::register_class<GLTFDocumentExtension>(); ClassDB::register_class<GLTFDocument>();
ClassDB::register_class<PackedSceneGLTF>(); ClassDB::register_class<GLTFDocumentExtension>();
ClassDB::register_class<PackedSceneGLTF>();
}
} }
void unregister_gltf_types(ModuleRegistrationLevel p_level) { void unregister_gltf_types(ModuleRegistrationLevel p_level) {

4
editor_modules/plugin_refresher/register_types.cpp
View File

@ -28,7 +28,9 @@ SOFTWARE.
void register_plugin_refresher_types(ModuleRegistrationLevel p_level) { void register_plugin_refresher_types(ModuleRegistrationLevel p_level) {
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<PluginRefresherEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<PluginRefresherEditorPlugin>();
}
#endif #endif
} }

20
editor_modules/text_editor/register_types.cpp
View File

@ -33,17 +33,25 @@ SOFTWARE.
Ref<TextEditorTextLoader> text_editor_text_resource_loader; Ref<TextEditorTextLoader> text_editor_text_resource_loader;
void register_text_editor_types(ModuleRegistrationLevel p_level) { void register_text_editor_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<TextEditorFile>(); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
text_editor_text_resource_loader.instance();
ResourceLoader::add_resource_format_loader(text_editor_text_resource_loader);
}
text_editor_text_resource_loader.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ResourceLoader::add_resource_format_loader(text_editor_text_resource_loader); ClassDB::register_class<TextEditorFile>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<TextEditorEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<TextEditorEditorPlugin>();
}
#endif #endif
} }
void unregister_text_editor_types(ModuleRegistrationLevel p_level) { void unregister_text_editor_types(ModuleRegistrationLevel p_level) {
ResourceLoader::remove_resource_format_loader(text_editor_text_resource_loader); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
text_editor_text_resource_loader.unref(); ResourceLoader::remove_resource_format_loader(text_editor_text_resource_loader);
text_editor_text_resource_loader.unref();
}
} }

14
editor_modules/tinyexr/register_types.cpp
View File

@ -36,14 +36,18 @@
static ImageLoaderTinyEXR *image_loader_tinyexr = nullptr; static ImageLoaderTinyEXR *image_loader_tinyexr = nullptr;
void register_tinyexr_types(ModuleRegistrationLevel p_level) { void register_tinyexr_types(ModuleRegistrationLevel p_level) {
image_loader_tinyexr = memnew(ImageLoaderTinyEXR); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ImageLoader::add_image_format_loader(image_loader_tinyexr); image_loader_tinyexr = memnew(ImageLoaderTinyEXR);
ImageLoader::add_image_format_loader(image_loader_tinyexr);
Image::save_exr_func = save_exr; Image::save_exr_func = save_exr;
}
} }
void unregister_tinyexr_types(ModuleRegistrationLevel p_level) { void unregister_tinyexr_types(ModuleRegistrationLevel p_level) {
memdelete(image_loader_tinyexr); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
memdelete(image_loader_tinyexr);
Image::save_exr_func = nullptr; Image::save_exr_func = nullptr;
}
} }

21
main/main.cpp
View File

@ -1520,7 +1520,17 @@ Error Main::setup2(Thread::ID p_main_tid_override) {
MAIN_PRINT("Main: Load Modules, Physics, Drivers, Scripts"); MAIN_PRINT("Main: Load Modules, Physics, Drivers, Scripts");
register_platform_apis(); register_platform_apis();
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_START);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_SINGLETON);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_CORE); register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_CORE);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_DRIVER);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_PLATFORM);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_SERVER);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_SCENE);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_EDITOR);
//register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_TEST);
register_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_FINALIZE);
// Theme needs modules to be initialized so that sub-resources can be loaded. // Theme needs modules to be initialized so that sub-resources can be loaded.
initialize_theme(); initialize_theme();
@ -2440,7 +2450,18 @@ void Main::cleanup(bool p_force) {
ImageLoader::cleanup(); ImageLoader::cleanup();
unregister_driver_types(); unregister_driver_types();
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_START);
//unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_TEST);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_EDITOR);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_SCENE);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_SERVER);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_PLATFORM);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_DRIVER);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_CORE); unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_CORE);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_SINGLETON);
unregister_module_types(ModuleRegistrationLevel::MODULE_REGISTRATION_LEVEL_FINALIZE);
unregister_platform_apis(); unregister_platform_apis();
unregister_scene_types(); unregister_scene_types();
unregister_server_types(); unregister_server_types();

10
modules/bmp/register_types.cpp
View File

@ -35,10 +35,14 @@
static ImageLoaderBMP *image_loader_bmp = nullptr; static ImageLoaderBMP *image_loader_bmp = nullptr;
void register_bmp_types(ModuleRegistrationLevel p_level) { void register_bmp_types(ModuleRegistrationLevel p_level) {
image_loader_bmp = memnew(ImageLoaderBMP); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ImageLoader::add_image_format_loader(image_loader_bmp); image_loader_bmp = memnew(ImageLoaderBMP);
ImageLoader::add_image_format_loader(image_loader_bmp);
}
} }
void unregister_bmp_types(ModuleRegistrationLevel p_level) { void unregister_bmp_types(ModuleRegistrationLevel p_level) {
memdelete(image_loader_bmp); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
memdelete(image_loader_bmp);
}
} }

4
modules/broken_seals_module/register_types.cpp
View File

@ -27,7 +27,9 @@ SOFTWARE.
#include "biome_terrain_generator.h" #include "biome_terrain_generator.h"
void register_broken_seals_module_types(ModuleRegistrationLevel p_level) { void register_broken_seals_module_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<BiomeTerrainGenerator>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<BiomeTerrainGenerator>();
}
} }
void unregister_broken_seals_module_types(ModuleRegistrationLevel p_level) { void unregister_broken_seals_module_types(ModuleRegistrationLevel p_level) {

44
modules/cscript/register_types.cpp
View File

@ -137,33 +137,41 @@ static void _editor_init() {
#endif // TOOLS_ENABLED #endif // TOOLS_ENABLED
void register_cscript_types(ModuleRegistrationLevel p_level) { void register_cscript_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<CScript>(); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
script_language_cscript = memnew(CScriptLanguage);
ScriptServer::register_language(script_language_cscript);
script_language_cscript = memnew(CScriptLanguage); resource_loader_cscript.instance();
ScriptServer::register_language(script_language_cscript); ResourceLoader::add_resource_format_loader(resource_loader_cscript);
resource_loader_cscript.instance(); resource_saver_cscript.instance();
ResourceLoader::add_resource_format_loader(resource_loader_cscript); ResourceSaver::add_resource_format_saver(resource_saver_cscript);
}
resource_saver_cscript.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ResourceSaver::add_resource_format_saver(resource_saver_cscript); ClassDB::register_class<CScript>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
ScriptEditor::register_create_syntax_highlighter_function(CScriptSyntaxHighlighter::create); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorNode::add_init_callback(_editor_init); ScriptEditor::register_create_syntax_highlighter_function(CScriptSyntaxHighlighter::create);
EditorNode::add_init_callback(_editor_init);
}
#endif // TOOLS_ENABLED #endif // TOOLS_ENABLED
} }
void unregister_cscript_types(ModuleRegistrationLevel p_level) { void unregister_cscript_types(ModuleRegistrationLevel p_level) {
ScriptServer::unregister_language(script_language_cscript); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ScriptServer::unregister_language(script_language_cscript);
if (script_language_cscript) { if (script_language_cscript) {
memdelete(script_language_cscript); memdelete(script_language_cscript);
}
ResourceLoader::remove_resource_format_loader(resource_loader_cscript);
resource_loader_cscript.unref();
ResourceSaver::remove_resource_format_saver(resource_saver_cscript);
resource_saver_cscript.unref();
} }
ResourceLoader::remove_resource_format_loader(resource_loader_cscript);
resource_loader_cscript.unref();
ResourceSaver::remove_resource_format_saver(resource_saver_cscript);
resource_saver_cscript.unref();
} }

30
modules/database/register_types.cpp
View File

@ -36,21 +36,27 @@ SOFTWARE.
DatabaseManager *_database_manager = nullptr; DatabaseManager *_database_manager = nullptr;
void register_database_types(ModuleRegistrationLevel p_level) { void register_database_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<Database>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<DatabaseConnection>(); _database_manager = memnew(DatabaseManager);
ClassDB::register_class<DatabaseManager>(); ClassDB::register_class<DatabaseManager>();
ClassDB::register_class<DatabaseMultiThreaded>(); Engine::get_singleton()->add_singleton(Engine::Singleton("DatabaseManager", DatabaseManager::get_singleton()));
ClassDB::register_class<DatabaseSingleThreaded>(); }
ClassDB::register_class<QueryBuilder>();
ClassDB::register_class<QueryResult>();
ClassDB::register_class<TableBuilder>();
_database_manager = memnew(DatabaseManager); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
Engine::get_singleton()->add_singleton(Engine::Singleton("DatabaseManager", DatabaseManager::get_singleton())); ClassDB::register_class<Database>();
ClassDB::register_class<DatabaseConnection>();
ClassDB::register_class<DatabaseMultiThreaded>();
ClassDB::register_class<DatabaseSingleThreaded>();
ClassDB::register_class<QueryBuilder>();
ClassDB::register_class<QueryResult>();
ClassDB::register_class<TableBuilder>();
}
} }
void unregister_database_types(ModuleRegistrationLevel p_level) { void unregister_database_types(ModuleRegistrationLevel p_level) {
if (_database_manager) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(_database_manager); if (_database_manager) {
memdelete(_database_manager);
}
} }
} }

4
modules/database_sqlite/register_types.cpp
View File

@ -25,7 +25,9 @@ SOFTWARE.
#include "sqlite3_database.h" #include "sqlite3_database.h"
void register_database_sqlite_types(ModuleRegistrationLevel p_level) { void register_database_sqlite_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<SQLite3Database>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<SQLite3Database>();
}
} }
void unregister_database_sqlite_types(ModuleRegistrationLevel p_level) { void unregister_database_sqlite_types(ModuleRegistrationLevel p_level) {

12
modules/dds/register_types.cpp
View File

@ -35,11 +35,15 @@
static Ref<ResourceFormatDDS> resource_loader_dds; static Ref<ResourceFormatDDS> resource_loader_dds;
void register_dds_types(ModuleRegistrationLevel p_level) { void register_dds_types(ModuleRegistrationLevel p_level) {
resource_loader_dds.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ResourceLoader::add_resource_format_loader(resource_loader_dds); resource_loader_dds.instance();
ResourceLoader::add_resource_format_loader(resource_loader_dds);
}
} }
void unregister_dds_types(ModuleRegistrationLevel p_level) { void unregister_dds_types(ModuleRegistrationLevel p_level) {
ResourceLoader::remove_resource_format_loader(resource_loader_dds); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
resource_loader_dds.unref(); ResourceLoader::remove_resource_format_loader(resource_loader_dds);
resource_loader_dds.unref();
}
} }

20
modules/enet/register_types.cpp
View File

@ -35,17 +35,23 @@
static bool enet_ok = false; static bool enet_ok = false;
void register_enet_types(ModuleRegistrationLevel p_level) { void register_enet_types(ModuleRegistrationLevel p_level) {
if (enet_initialize() != 0) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ERR_PRINT("ENet initialization failure"); if (enet_initialize() != 0) {
} else { ERR_PRINT("ENet initialization failure");
enet_ok = true; } else {
enet_ok = true;
}
} }
ClassDB::register_class<NetworkedMultiplayerENet>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<NetworkedMultiplayerENet>();
}
} }
void unregister_enet_types(ModuleRegistrationLevel p_level) { void unregister_enet_types(ModuleRegistrationLevel p_level) {
if (enet_ok) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
enet_deinitialize(); if (enet_ok) {
enet_deinitialize();
}
} }
} }

204
modules/entity_spell_system/register_types.cpp
View File

@ -146,154 +146,162 @@ static ESS *entity_data_manager = NULL;
static ProfileManager *profile_manager = NULL; static ProfileManager *profile_manager = NULL;
void register_entity_spell_system_types(ModuleRegistrationLevel p_level) { void register_entity_spell_system_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
entity_data_manager = memnew(ESS);
ClassDB::register_class<ESS>();
Engine::get_singleton()->add_singleton(Engine::Singleton("ESS", ESS::get_singleton()));
profile_manager = memnew(ProfileManager);
ClassDB::register_class<ProfileManager>();
Engine::get_singleton()->add_singleton(Engine::Singleton("ProfileManager", ProfileManager::get_singleton()));
}
if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
#ifdef MODULE_PROPS_ENABLED #ifdef MODULE_PROPS_ENABLED
ClassDB::register_class<PropDataEntity>(); ClassDB::register_class<PropDataEntity>();
#endif #endif
ClassDB::register_class<SpellEnums>(); ClassDB::register_class<SpellEnums>();
//data //data
ClassDB::register_class<CraftRecipeHelper>(); ClassDB::register_class<CraftRecipeHelper>();
ClassDB::register_class<CraftRecipe>(); ClassDB::register_class<CraftRecipe>();
ClassDB::register_class<Spell>(); ClassDB::register_class<Spell>();
ClassDB::register_class<AuraGroup>(); ClassDB::register_class<AuraGroup>();
ClassDB::register_class<EntityData>(); ClassDB::register_class<EntityData>();
ClassDB::register_class<EntityClassData>(); ClassDB::register_class<EntityClassData>();
ClassDB::register_class<VendorItemData>(); ClassDB::register_class<VendorItemData>();
ClassDB::register_class<VendorItemDataEntry>(); ClassDB::register_class<VendorItemDataEntry>();
ClassDB::register_class<EntityDataContainer>(); ClassDB::register_class<EntityDataContainer>();
ClassDB::register_class<ItemContainerData>(); ClassDB::register_class<ItemContainerData>();
ClassDB::register_class<ItemContainerDataEntry>(); ClassDB::register_class<ItemContainerDataEntry>();
ClassDB::register_class<ItemEnums>(); ClassDB::register_class<ItemEnums>();
ClassDB::register_class<ItemTemplate>(); ClassDB::register_class<ItemTemplate>();
ClassDB::register_class<ItemInstance>(); ClassDB::register_class<ItemInstance>();
ClassDB::register_class<SpellCooldownManipulationData>(); ClassDB::register_class<SpellCooldownManipulationData>();
ClassDB::register_class<EquipmentData>(); ClassDB::register_class<EquipmentData>();
ClassDB::register_class<EntitySkill>(); ClassDB::register_class<EntitySkill>();
ClassDB::register_class<EntitySkillData>(); ClassDB::register_class<EntitySkillData>();
ClassDB::register_class<ModelVisual>(); ClassDB::register_class<ModelVisual>();
ClassDB::register_class<ModelVisualEntry>(); ClassDB::register_class<ModelVisualEntry>();
ClassDB::register_class<CharacterAtlas>(); ClassDB::register_class<CharacterAtlas>();
ClassDB::register_class<CharacterAtlasEntry>(); ClassDB::register_class<CharacterAtlasEntry>();
ClassDB::register_class<CharacterBones>(); ClassDB::register_class<CharacterBones>();
//entity data //entity data
ClassDB::register_class<EntityEnums>(); ClassDB::register_class<EntityEnums>();
ClassDB::register_class<StatData>(); ClassDB::register_class<StatData>();
ClassDB::register_class<LevelStatData>(); ClassDB::register_class<LevelStatData>();
ClassDB::register_class<SimpleLevelStatData>(); ClassDB::register_class<SimpleLevelStatData>();
ClassDB::register_class<ComplexLevelStatData>(); ClassDB::register_class<ComplexLevelStatData>();
ClassDB::register_class<CharacterSpec>(); ClassDB::register_class<CharacterSpec>();
ClassDB::register_class<Bag>(); ClassDB::register_class<Bag>();
ClassDB::register_class<SpellDamageInfo>(); ClassDB::register_class<SpellDamageInfo>();
ClassDB::register_class<SpellHealInfo>(); ClassDB::register_class<SpellHealInfo>();
ClassDB::register_class<AuraData>(); ClassDB::register_class<AuraData>();
ClassDB::register_class<EntityResourceCostData>(); ClassDB::register_class<EntityResourceCostData>();
ClassDB::register_class<EntityResourceCostDataHealth>(); ClassDB::register_class<EntityResourceCostDataHealth>();
ClassDB::register_class<EntityResourceCostDataResource>(); ClassDB::register_class<EntityResourceCostDataResource>();
ClassDB::register_class<EntityResource>(); ClassDB::register_class<EntityResource>();
ClassDB::register_class<EntityResourceHealth>(); ClassDB::register_class<EntityResourceHealth>();
ClassDB::register_class<EntityResourceSpeed>(); ClassDB::register_class<EntityResourceSpeed>();
//entities //entities
ClassDB::register_class<EntityCreateInfo>(); ClassDB::register_class<EntityCreateInfo>();
ClassDB::register_class<Entity>(); ClassDB::register_class<Entity>();
//spellinfos //spellinfos
ClassDB::register_class<SpellCastInfo>(); ClassDB::register_class<SpellCastInfo>();
//aurainfos //aurainfos
ClassDB::register_class<AuraApplyInfo>(); ClassDB::register_class<AuraApplyInfo>();
//UI //UI
ClassDB::register_class<ESDragAndDrop>(); ClassDB::register_class<ESDragAndDrop>();
//Skeleton //Skeleton
ClassDB::register_class<CharacterSkeleton2D>(); ClassDB::register_class<CharacterSkeleton2D>();
ClassDB::register_class<CharacterSkeleton3D>(); ClassDB::register_class<CharacterSkeleton3D>();
ClassDB::register_class<EntitySpeciesData>(); ClassDB::register_class<EntitySpeciesData>();
ClassDB::register_class<SpeciesModelData>(); ClassDB::register_class<SpeciesModelData>();
ClassDB::register_class<SpeciesInstance>(); ClassDB::register_class<SpeciesInstance>();
ClassDB::register_class<SkeletonModelEntry>(); ClassDB::register_class<SkeletonModelEntry>();
ClassDB::register_class<LootDataBase>(); ClassDB::register_class<LootDataBase>();
ClassDB::register_class<SpellEffectVisual>(); ClassDB::register_class<SpellEffectVisual>();
ClassDB::register_class<SpellEffectVisualSimple>(); ClassDB::register_class<SpellEffectVisualSimple>();
//Projectiles //Projectiles
ClassDB::register_class<SpellFollowProjectile3D>(); ClassDB::register_class<SpellFollowProjectile3D>();
//AI //AI
ClassDB::register_class<EntityAI>(); ClassDB::register_class<EntityAI>();
ClassDB::register_class<AIFormation>(); ClassDB::register_class<AIFormation>();
//Resources //Resources
ClassDB::register_virtual_class<ESSResourceDB>(); ClassDB::register_virtual_class<ESSResourceDB>();
ClassDB::register_class<ESSResourceDBStatic>(); ClassDB::register_class<ESSResourceDBStatic>();
ClassDB::register_class<ESSResourceDBFolders>(); ClassDB::register_class<ESSResourceDBFolders>();
ClassDB::register_class<ESSResourceDBMap>(); ClassDB::register_class<ESSResourceDBMap>();
//ProfileManager //ProfileManager
ClassDB::register_class<InputProfileModifier>(); ClassDB::register_class<InputProfileModifier>();
ClassDB::register_class<InputProfileModifierEntry>(); ClassDB::register_class<InputProfileModifierEntry>();
ClassDB::register_class<InputProfile>(); ClassDB::register_class<InputProfile>();
ClassDB::register_class<ActionBarButtonEntry>(); ClassDB::register_class<ActionBarButtonEntry>();
ClassDB::register_class<ActionBarEntry>(); ClassDB::register_class<ActionBarEntry>();
ClassDB::register_class<ActionBarProfile>(); ClassDB::register_class<ActionBarProfile>();
ClassDB::register_class<ClassProfile>(); ClassDB::register_class<ClassProfile>();
ClassDB::register_class<PlayerProfile>(); ClassDB::register_class<PlayerProfile>();
ClassDB::register_class<ProfileManager>(); ClassDB::register_class<ProfileManager>();
ClassDB::register_class<ESSEntitySpawner>(); ClassDB::register_class<ESSEntitySpawner>();
ClassDB::register_class<ESSMaterialCache>(); ClassDB::register_class<ESSMaterialCache>();
#ifdef MODULE_TEXTURE_PACKER_ENABLED #ifdef MODULE_TEXTURE_PACKER_ENABLED
ClassDB::register_class<ESSMaterialCachePCM>(); ClassDB::register_class<ESSMaterialCachePCM>();
#endif #endif
}
entity_data_manager = memnew(ESS);
ClassDB::register_class<ESS>();
Engine::get_singleton()->add_singleton(Engine::Singleton("ESS", ESS::get_singleton()));
profile_manager = memnew(ProfileManager);
ClassDB::register_class<ProfileManager>();
Engine::get_singleton()->add_singleton(Engine::Singleton("ProfileManager", ProfileManager::get_singleton()));
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
//if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
//EditorPlugins::add_by_type<ESSEditorPlugin>(); //EditorPlugins::add_by_type<ESSEditorPlugin>();
//}
#endif #endif
} }
void unregister_entity_spell_system_types(ModuleRegistrationLevel p_level) { void unregister_entity_spell_system_types(ModuleRegistrationLevel p_level) {
if (entity_data_manager) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(entity_data_manager); if (entity_data_manager) {
} memdelete(entity_data_manager);
}
if (profile_manager) { if (profile_manager) {
memdelete(profile_manager); memdelete(profile_manager);
}
} }
} }

6
modules/fastnoise/register_types.cpp
View File

@ -6,8 +6,10 @@
#include "noise.h" #include "noise.h"
void register_fastnoise_types(ModuleRegistrationLevel p_level) { void register_fastnoise_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<FastNoise>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<FastnoiseNoiseParams>(); ClassDB::register_class<FastNoise>();
ClassDB::register_class<FastnoiseNoiseParams>();
}
} }
void unregister_fastnoise_types(ModuleRegistrationLevel p_level) { void unregister_fastnoise_types(ModuleRegistrationLevel p_level) {

46
modules/gdscript/register_types.cpp
View File

@ -137,34 +137,42 @@ static void _editor_init() {
#endif // TOOLS_ENABLED #endif // TOOLS_ENABLED
void register_gdscript_types(ModuleRegistrationLevel p_level) { void register_gdscript_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<GDScript>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_virtual_class<GDScriptFunctionState>(); script_language_gd = memnew(GDScriptLanguage);
ScriptServer::register_language(script_language_gd);
script_language_gd = memnew(GDScriptLanguage); resource_loader_gd.instance();
ScriptServer::register_language(script_language_gd); ResourceLoader::add_resource_format_loader(resource_loader_gd);
resource_loader_gd.instance(); resource_saver_gd.instance();
ResourceLoader::add_resource_format_loader(resource_loader_gd); ResourceSaver::add_resource_format_saver(resource_saver_gd);
}
resource_saver_gd.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ResourceSaver::add_resource_format_saver(resource_saver_gd); ClassDB::register_class<GDScript>();
ClassDB::register_virtual_class<GDScriptFunctionState>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
ScriptEditor::register_create_syntax_highlighter_function(GDScriptSyntaxHighlighter::create); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorNode::add_init_callback(_editor_init); ScriptEditor::register_create_syntax_highlighter_function(GDScriptSyntaxHighlighter::create);
EditorNode::add_init_callback(_editor_init);
}
#endif // TOOLS_ENABLED #endif // TOOLS_ENABLED
} }
void unregister_gdscript_types(ModuleRegistrationLevel p_level) { void unregister_gdscript_types(ModuleRegistrationLevel p_level) {
ScriptServer::unregister_language(script_language_gd); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ScriptServer::unregister_language(script_language_gd);
if (script_language_gd) { if (script_language_gd) {
memdelete(script_language_gd); memdelete(script_language_gd);
}
ResourceLoader::remove_resource_format_loader(resource_loader_gd);
resource_loader_gd.unref();
ResourceSaver::remove_resource_format_saver(resource_saver_gd);
resource_saver_gd.unref();
} }
ResourceLoader::remove_resource_format_loader(resource_loader_gd);
resource_loader_gd.unref();
ResourceSaver::remove_resource_format_saver(resource_saver_gd);
resource_saver_gd.unref();
} }

15
modules/gridmap/register_types.cpp
View File

@ -35,18 +35,23 @@
#include "mesh_library.h" #include "mesh_library.h"
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "mesh_library_editor_plugin.h"
#include "grid_map_editor_plugin.h" #include "grid_map_editor_plugin.h"
#include "mesh_library_editor_plugin.h"
#endif #endif
#endif #endif
void register_gridmap_types(ModuleRegistrationLevel p_level) { void register_gridmap_types(ModuleRegistrationLevel p_level) {
#ifndef _3D_DISABLED #ifndef _3D_DISABLED
ClassDB::register_class<GridMap>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<MeshLibrary>(); ClassDB::register_class<GridMap>();
ClassDB::register_class<MeshLibrary>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<GridMapEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<MeshLibraryEditorPlugin>(); EditorPlugins::add_by_type<GridMapEditorPlugin>();
EditorPlugins::add_by_type<MeshLibraryEditorPlugin>();
}
#endif #endif
#endif #endif
} }

10
modules/hdr/register_types.cpp
View File

@ -35,10 +35,14 @@
static ImageLoaderHDR *image_loader_hdr = nullptr; static ImageLoaderHDR *image_loader_hdr = nullptr;
void register_hdr_types(ModuleRegistrationLevel p_level) { void register_hdr_types(ModuleRegistrationLevel p_level) {
image_loader_hdr = memnew(ImageLoaderHDR); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ImageLoader::add_image_format_loader(image_loader_hdr); image_loader_hdr = memnew(ImageLoaderHDR);
ImageLoader::add_image_format_loader(image_loader_hdr);
}
} }
void unregister_hdr_types(ModuleRegistrationLevel p_level) { void unregister_hdr_types(ModuleRegistrationLevel p_level) {
memdelete(image_loader_hdr); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
memdelete(image_loader_hdr);
}
} }

5
modules/http_server_simple/register_types.cpp
View File

@ -24,9 +24,10 @@ SOFTWARE.
#include "web_server_simple.h" #include "web_server_simple.h"
void register_http_server_simple_types(ModuleRegistrationLevel p_level) { void register_http_server_simple_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<WebServerSimple>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<WebServerSimple>();
}
} }
void unregister_http_server_simple_types(ModuleRegistrationLevel p_level) { void unregister_http_server_simple_types(ModuleRegistrationLevel p_level) {

10
modules/jpg/register_types.cpp
View File

@ -35,10 +35,14 @@
static ImageLoaderJPG *image_loader_jpg = nullptr; static ImageLoaderJPG *image_loader_jpg = nullptr;
void register_jpg_types(ModuleRegistrationLevel p_level) { void register_jpg_types(ModuleRegistrationLevel p_level) {
image_loader_jpg = memnew(ImageLoaderJPG); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ImageLoader::add_image_format_loader(image_loader_jpg); image_loader_jpg = memnew(ImageLoaderJPG);
ImageLoader::add_image_format_loader(image_loader_jpg);
}
} }
void unregister_jpg_types(ModuleRegistrationLevel p_level) { void unregister_jpg_types(ModuleRegistrationLevel p_level) {
memdelete(image_loader_jpg); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
memdelete(image_loader_jpg);
}
} }

4
modules/lz4/register_types.cpp
View File

@ -4,7 +4,9 @@
#include "lz4_compressor.h" #include "lz4_compressor.h"
void register_lz4_types(ModuleRegistrationLevel p_level) { void register_lz4_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<LZ4Compressor>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<LZ4Compressor>();
}
} }
void unregister_lz4_types(ModuleRegistrationLevel p_level) { void unregister_lz4_types(ModuleRegistrationLevel p_level) {

409
modules/material_maker/register_types.cpp
View File

@ -156,231 +156,238 @@ SOFTWARE.
static _MMAlgos *_mm_algos_singleton = nullptr; static _MMAlgos *_mm_algos_singleton = nullptr;
void register_material_maker_types(ModuleRegistrationLevel p_level) { void register_material_maker_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<_MMAlgos>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
_mm_algos_singleton = memnew(_MMAlgos);
ClassDB::register_class<_MMAlgos>();
Engine::get_singleton()->add_singleton(Engine::Singleton("MMAlgos", _MMAlgos::get_singleton()));
}
ClassDB::register_class<MMNodeUniversalProperty>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<MMMaterial>(); ClassDB::register_class<MMNodeUniversalProperty>();
ClassDB::register_class<MMNode>(); ClassDB::register_class<MMMaterial>();
ClassDB::register_class<MMNode>();
ClassDB::register_class<CurveBase>(); ClassDB::register_class<CurveBase>();
ClassDB::register_class<GradientBase>(); ClassDB::register_class<GradientBase>();
ClassDB::register_class<PolygonBase>(); ClassDB::register_class<PolygonBase>();
ClassDB::register_class<MMGraphNode>(); ClassDB::register_class<MMGraphNode>();
ClassDB::register_class<MatMakerGDEditor>(); ClassDB::register_class<MatMakerGDEditor>();
ClassDB::register_class<MMUniform>(); ClassDB::register_class<MMUniform>();
MMAlgos::register_node_class("Uniform", "MMUniform"); MMAlgos::register_node_class("Uniform", "MMUniform");
ClassDB::register_class<MMGreyscaleUniform>(); ClassDB::register_class<MMGreyscaleUniform>();
MMAlgos::register_node_class("Uniform", "MMGreyscaleUniform"); MMAlgos::register_node_class("Uniform", "MMGreyscaleUniform");
ClassDB::register_class<MMTranslate>(); ClassDB::register_class<MMTranslate>();
MMAlgos::register_node_class("Transform", "MMTranslate"); MMAlgos::register_node_class("Transform", "MMTranslate");
ClassDB::register_class<MMTransform>(); ClassDB::register_class<MMTransform>();
MMAlgos::register_node_class("Transform", "MMTransform"); MMAlgos::register_node_class("Transform", "MMTransform");
ClassDB::register_class<MMTiler>(); ClassDB::register_class<MMTiler>();
MMAlgos::register_node_class("Transform", "MMTiler"); MMAlgos::register_node_class("Transform", "MMTiler");
ClassDB::register_class<MMShear>(); ClassDB::register_class<MMShear>();
MMAlgos::register_node_class("Transform", "MMShear"); MMAlgos::register_node_class("Transform", "MMShear");
ClassDB::register_class<MMScale>(); ClassDB::register_class<MMScale>();
MMAlgos::register_node_class("Transform", "MMScale"); MMAlgos::register_node_class("Transform", "MMScale");
ClassDB::register_class<MMRotate>(); ClassDB::register_class<MMRotate>();
MMAlgos::register_node_class("Transform", "MMRotate"); MMAlgos::register_node_class("Transform", "MMRotate");
ClassDB::register_class<MMRepeat>(); ClassDB::register_class<MMRepeat>();
MMAlgos::register_node_class("Transform", "MMRepeat"); MMAlgos::register_node_class("Transform", "MMRepeat");
ClassDB::register_class<MMMirror>(); ClassDB::register_class<MMMirror>();
MMAlgos::register_node_class("Transform", "MMMirror"); MMAlgos::register_node_class("Transform", "MMMirror");
ClassDB::register_class<MMKaleidoscope>(); ClassDB::register_class<MMKaleidoscope>();
MMAlgos::register_node_class("Transform", "MMKaleidoscope"); MMAlgos::register_node_class("Transform", "MMKaleidoscope");
ClassDB::register_class<MMColorTiler>(); ClassDB::register_class<MMColorTiler>();
MMAlgos::register_node_class("Transform", "MMColorTiler"); MMAlgos::register_node_class("Transform", "MMColorTiler");
ClassDB::register_class<MMCircleMap>(); ClassDB::register_class<MMCircleMap>();
MMAlgos::register_node_class("Transform", "MMCircleMap"); MMAlgos::register_node_class("Transform", "MMCircleMap");
ClassDB::register_class<MMShape>(); ClassDB::register_class<MMShape>();
MMAlgos::register_node_class("Simple", "MMShape"); MMAlgos::register_node_class("Simple", "MMShape");
ClassDB::register_class<MMImage>(); ClassDB::register_class<MMImage>();
MMAlgos::register_node_class("Simple", "MMImage"); MMAlgos::register_node_class("Simple", "MMImage");
ClassDB::register_class<MMCurve>(); ClassDB::register_class<MMCurve>();
MMAlgos::register_node_class("Simple", "MMCurve"); MMAlgos::register_node_class("Simple", "MMCurve");
ClassDB::register_class<MMSdf3dColor>(); ClassDB::register_class<MMSdf3dColor>();
MMAlgos::register_node_class("SDF3D", "MMSdf3dColor"); MMAlgos::register_node_class("SDF3D", "MMSdf3dColor");
ClassDB::register_class<MMSdf3dRender>(); ClassDB::register_class<MMSdf3dRender>();
MMAlgos::register_node_class("SDF3D", "MMSdf3dRender"); MMAlgos::register_node_class("SDF3D", "MMSdf3dRender");
ClassDB::register_class<MMSdf3dTfTranslate>(); ClassDB::register_class<MMSdf3dTfTranslate>();
MMAlgos::register_node_class("SDF3D - TF", "MMSdf3dTfTranslate"); MMAlgos::register_node_class("SDF3D - TF", "MMSdf3dTfTranslate");
ClassDB::register_class<MMSdf3dTfScale>(); ClassDB::register_class<MMSdf3dTfScale>();
MMAlgos::register_node_class("SDF3D - TF", "MMSdf3dTfScale"); MMAlgos::register_node_class("SDF3D - TF", "MMSdf3dTfScale");
ClassDB::register_class<MMSdf3dTfRotate>(); ClassDB::register_class<MMSdf3dTfRotate>();
MMAlgos::register_node_class("SDF3D - TF", "MMSdf3dTfRotate"); MMAlgos::register_node_class("SDF3D - TF", "MMSdf3dTfRotate");
ClassDB::register_class<MMSdf3dShapeTorus>(); ClassDB::register_class<MMSdf3dShapeTorus>();
MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeTorus"); MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeTorus");
ClassDB::register_class<MMSdf3dShapeSphere>(); ClassDB::register_class<MMSdf3dShapeSphere>();
MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeSphere"); MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeSphere");
ClassDB::register_class<MMSdf3dShapeCylinder>(); ClassDB::register_class<MMSdf3dShapeCylinder>();
MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeCylinder"); MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeCylinder");
ClassDB::register_class<MMSdf3dShapeCone>(); ClassDB::register_class<MMSdf3dShapeCone>();
MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeCone"); MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeCone");
ClassDB::register_class<MMSdf3dShapeCapsule>(); ClassDB::register_class<MMSdf3dShapeCapsule>();
MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeCapsule"); MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeCapsule");
ClassDB::register_class<MMSdf3dShapeBox>(); ClassDB::register_class<MMSdf3dShapeBox>();
MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeBox"); MMAlgos::register_node_class("SDF3D - Shape", "MMSdf3dShapeBox");
ClassDB::register_class<MMSdf3dOpSmoothBool>(); ClassDB::register_class<MMSdf3dOpSmoothBool>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpSmoothBool"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpSmoothBool");
ClassDB::register_class<MMSdf3dOpRounded>(); ClassDB::register_class<MMSdf3dOpRounded>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpRounded"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpRounded");
ClassDB::register_class<MMSdf3dOpRevolution>(); ClassDB::register_class<MMSdf3dOpRevolution>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpRevolution"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpRevolution");
ClassDB::register_class<MMSdf3dOpRepeat>(); ClassDB::register_class<MMSdf3dOpRepeat>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpRepeat"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpRepeat");
ClassDB::register_class<MMSdf3dOpMorph>(); ClassDB::register_class<MMSdf3dOpMorph>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpMorph"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpMorph");
ClassDB::register_class<MMSdf3dOpElongation>(); ClassDB::register_class<MMSdf3dOpElongation>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpElongation"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpElongation");
ClassDB::register_class<MMSdf3dOpCircleRepeat>(); ClassDB::register_class<MMSdf3dOpCircleRepeat>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpCircleRepeat"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpCircleRepeat");
ClassDB::register_class<MMSdf3dOpBool>(); ClassDB::register_class<MMSdf3dOpBool>();
MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpBool"); MMAlgos::register_node_class("SDF3D - OP", "MMSdf3dOpBool");
ClassDB::register_class<SSSdShow>(); ClassDB::register_class<SSSdShow>();
MMAlgos::register_node_class("SDF2D", "SSSdShow"); MMAlgos::register_node_class("SDF2D", "SSSdShow");
ClassDB::register_class<MMSdShapeRhombus>(); ClassDB::register_class<MMSdShapeRhombus>();
MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeRhombus"); MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeRhombus");
ClassDB::register_class<MMSdShapePolygon>(); ClassDB::register_class<MMSdShapePolygon>();
MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapePolygon"); MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapePolygon");
ClassDB::register_class<MMSdShapeLine>(); ClassDB::register_class<MMSdShapeLine>();
MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeLine"); MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeLine");
ClassDB::register_class<MMSdShapeCircle>(); ClassDB::register_class<MMSdShapeCircle>();
MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeCircle"); MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeCircle");
ClassDB::register_class<MMSdShapeBox>(); ClassDB::register_class<MMSdShapeBox>();
MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeBox"); MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeBox");
ClassDB::register_class<MMSdShapeArc>(); ClassDB::register_class<MMSdShapeArc>();
MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeArc"); MMAlgos::register_node_class("SDF2D - Shape", "MMSdShapeArc");
ClassDB::register_class<MMSdTfTranslate>(); ClassDB::register_class<MMSdTfTranslate>();
MMAlgos::register_node_class("SDF2D - TF", "MMSdTfTranslate"); MMAlgos::register_node_class("SDF2D - TF", "MMSdTfTranslate");
ClassDB::register_class<MMSdTfScale>(); ClassDB::register_class<MMSdTfScale>();
MMAlgos::register_node_class("SDF2D - TF", "MMSdTfScale"); MMAlgos::register_node_class("SDF2D - TF", "MMSdTfScale");
ClassDB::register_class<MMSdTfRotate>(); ClassDB::register_class<MMSdTfRotate>();
MMAlgos::register_node_class("SDF2D - TF", "MMSdTfRotate"); MMAlgos::register_node_class("SDF2D - TF", "MMSdTfRotate");
ClassDB::register_class<MMSdOpSmoothBool>(); ClassDB::register_class<MMSdOpSmoothBool>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpSmoothBool"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpSmoothBool");
ClassDB::register_class<MMSdOpRoundedShape>(); ClassDB::register_class<MMSdOpRoundedShape>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpRoundedShape"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpRoundedShape");
ClassDB::register_class<MMSdOpRepeat>(); ClassDB::register_class<MMSdOpRepeat>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpRepeat"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpRepeat");
ClassDB::register_class<MMSdOpMorph>(); ClassDB::register_class<MMSdOpMorph>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpMorph"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpMorph");
ClassDB::register_class<MMSdOpCircleRepeat>(); ClassDB::register_class<MMSdOpCircleRepeat>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpCircleRepeat"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpCircleRepeat");
ClassDB::register_class<MMSdOpBool>(); ClassDB::register_class<MMSdOpBool>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpBool"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpBool");
ClassDB::register_class<MMSdOpAnnularShape>(); ClassDB::register_class<MMSdOpAnnularShape>();
MMAlgos::register_node_class("SDF2D - OP", "MMSdOpAnnularShape"); MMAlgos::register_node_class("SDF2D - OP", "MMSdOpAnnularShape");
ClassDB::register_class<MMWeave>(); ClassDB::register_class<MMWeave>();
MMAlgos::register_node_class("Patterns", "MMWeave"); MMAlgos::register_node_class("Patterns", "MMWeave");
ClassDB::register_class<MMTruchet>(); ClassDB::register_class<MMTruchet>();
MMAlgos::register_node_class("Patterns", "MMTruchet"); MMAlgos::register_node_class("Patterns", "MMTruchet");
ClassDB::register_class<MMSineWave>(); ClassDB::register_class<MMSineWave>();
MMAlgos::register_node_class("Patterns", "MMSineWave"); MMAlgos::register_node_class("Patterns", "MMSineWave");
ClassDB::register_class<MMScratches>(); ClassDB::register_class<MMScratches>();
MMAlgos::register_node_class("Patterns", "MMScratches"); MMAlgos::register_node_class("Patterns", "MMScratches");
ClassDB::register_class<MMRunes>(); ClassDB::register_class<MMRunes>();
MMAlgos::register_node_class("Patterns", "MMRunes"); MMAlgos::register_node_class("Patterns", "MMRunes");
ClassDB::register_class<MMPattern>(); ClassDB::register_class<MMPattern>();
MMAlgos::register_node_class("Patterns", "MMPattern"); MMAlgos::register_node_class("Patterns", "MMPattern");
ClassDB::register_class<MMIching>(); ClassDB::register_class<MMIching>();
MMAlgos::register_node_class("Patterns", "MMIching"); MMAlgos::register_node_class("Patterns", "MMIching");
ClassDB::register_class<MMBricks>(); ClassDB::register_class<MMBricks>();
MMAlgos::register_node_class("Patterns", "MMBricks"); MMAlgos::register_node_class("Patterns", "MMBricks");
ClassDB::register_class<MMBeehive>(); ClassDB::register_class<MMBeehive>();
MMAlgos::register_node_class("Patterns", "MMBeehive"); MMAlgos::register_node_class("Patterns", "MMBeehive");
ClassDB::register_class<MMOutputImage>(); ClassDB::register_class<MMOutputImage>();
MMAlgos::register_node_class("Output", "MMOutputImage"); MMAlgos::register_node_class("Output", "MMOutputImage");
ClassDB::register_class<MMVoronoi>(); ClassDB::register_class<MMVoronoi>();
MMAlgos::register_node_class("Noise", "MMVoronoi"); MMAlgos::register_node_class("Noise", "MMVoronoi");
ClassDB::register_class<MMNoise>(); ClassDB::register_class<MMNoise>();
MMAlgos::register_node_class("Noise", "MMNoise"); MMAlgos::register_node_class("Noise", "MMNoise");
ClassDB::register_class<MMFbmNoise>(); ClassDB::register_class<MMFbmNoise>();
MMAlgos::register_node_class("Noise", "MMFbmNoise"); MMAlgos::register_node_class("Noise", "MMFbmNoise");
ClassDB::register_class<MMColorValue>(); ClassDB::register_class<MMColorValue>();
MMAlgos::register_node_class("Noise", "MMColorValue"); MMAlgos::register_node_class("Noise", "MMColorValue");
ClassDB::register_class<MMColorNoise>(); ClassDB::register_class<MMColorNoise>();
MMAlgos::register_node_class("Noise", "MMColorNoise"); MMAlgos::register_node_class("Noise", "MMColorNoise");
ClassDB::register_class<MMAnisotropicNoise>(); ClassDB::register_class<MMAnisotropicNoise>();
MMAlgos::register_node_class("Noise", "MMAnisotropicNoise"); MMAlgos::register_node_class("Noise", "MMAnisotropicNoise");
ClassDB::register_class<MMRadialGradient>(); ClassDB::register_class<MMRadialGradient>();
MMAlgos::register_node_class("Gradient", "MMRadialGradient"); MMAlgos::register_node_class("Gradient", "MMRadialGradient");
ClassDB::register_class<MMGradient>(); ClassDB::register_class<MMGradient>();
MMAlgos::register_node_class("Gradient", "MMGradient"); MMAlgos::register_node_class("Gradient", "MMGradient");
ClassDB::register_class<MMCircularGradient>(); ClassDB::register_class<MMCircularGradient>();
MMAlgos::register_node_class("Gradient", "MMCircularGradient"); MMAlgos::register_node_class("Gradient", "MMCircularGradient");
ClassDB::register_class<MMTonality>(); ClassDB::register_class<MMTonality>();
MMAlgos::register_node_class("Filter", "MMTonality"); MMAlgos::register_node_class("Filter", "MMTonality");
ClassDB::register_class<MMSwapChannels>(); ClassDB::register_class<MMSwapChannels>();
MMAlgos::register_node_class("Filter", "MMSwapChannels"); MMAlgos::register_node_class("Filter", "MMSwapChannels");
ClassDB::register_class<MMQuantize>(); ClassDB::register_class<MMQuantize>();
MMAlgos::register_node_class("Filter", "MMQuantize"); MMAlgos::register_node_class("Filter", "MMQuantize");
ClassDB::register_class<MMMath>(); ClassDB::register_class<MMMath>();
MMAlgos::register_node_class("Filter", "MMMath"); MMAlgos::register_node_class("Filter", "MMMath");
ClassDB::register_class<MMMakeTileable>(); ClassDB::register_class<MMMakeTileable>();
MMAlgos::register_node_class("Filter", "MMMakeTileable"); MMAlgos::register_node_class("Filter", "MMMakeTileable");
ClassDB::register_class<MMInvert>(); ClassDB::register_class<MMInvert>();
MMAlgos::register_node_class("Filter", "MMInvert"); MMAlgos::register_node_class("Filter", "MMInvert");
ClassDB::register_class<MMGreyscale>(); ClassDB::register_class<MMGreyscale>();
MMAlgos::register_node_class("Filter", "MMGreyscale"); MMAlgos::register_node_class("Filter", "MMGreyscale");
ClassDB::register_class<MMFillToUv>(); ClassDB::register_class<MMFillToUv>();
MMAlgos::register_node_class("Filter", "MMFillToUv"); MMAlgos::register_node_class("Filter", "MMFillToUv");
ClassDB::register_class<MMFillToSize>(); ClassDB::register_class<MMFillToSize>();
MMAlgos::register_node_class("Filter", "MMFillToSize"); MMAlgos::register_node_class("Filter", "MMFillToSize");
ClassDB::register_class<MMFillToRandomGrey>(); ClassDB::register_class<MMFillToRandomGrey>();
MMAlgos::register_node_class("Filter", "MMFillToRandomGrey"); MMAlgos::register_node_class("Filter", "MMFillToRandomGrey");
ClassDB::register_class<MMFillToRandomColor>(); ClassDB::register_class<MMFillToRandomColor>();
MMAlgos::register_node_class("Filter", "MMFillToRandomColor"); MMAlgos::register_node_class("Filter", "MMFillToRandomColor");
ClassDB::register_class<MMFillToPosition>(); ClassDB::register_class<MMFillToPosition>();
MMAlgos::register_node_class("Filter", "MMFillToPosition"); MMAlgos::register_node_class("Filter", "MMFillToPosition");
ClassDB::register_class<MMFillToColor>(); ClassDB::register_class<MMFillToColor>();
MMAlgos::register_node_class("Filter", "MMFillToColor"); MMAlgos::register_node_class("Filter", "MMFillToColor");
ClassDB::register_class<MMFillChannel>(); ClassDB::register_class<MMFillChannel>();
MMAlgos::register_node_class("Filter", "MMFillChannel"); MMAlgos::register_node_class("Filter", "MMFillChannel");
ClassDB::register_class<MMEmboss>(); ClassDB::register_class<MMEmboss>();
MMAlgos::register_node_class("Filter", "MMEmboss"); MMAlgos::register_node_class("Filter", "MMEmboss");
ClassDB::register_class<MMDecompose>(); ClassDB::register_class<MMDecompose>();
MMAlgos::register_node_class("Filter", "MMDecompose"); MMAlgos::register_node_class("Filter", "MMDecompose");
ClassDB::register_class<MMCombine>(); ClassDB::register_class<MMCombine>();
MMAlgos::register_node_class("Filter", "MMCombine"); MMAlgos::register_node_class("Filter", "MMCombine");
ClassDB::register_class<MMColorize>(); ClassDB::register_class<MMColorize>();
MMAlgos::register_node_class("Filter", "MMColorize"); MMAlgos::register_node_class("Filter", "MMColorize");
ClassDB::register_class<MMBrightnessContrast>(); ClassDB::register_class<MMBrightnessContrast>();
MMAlgos::register_node_class("Filter", "MMBrightnessContrast"); MMAlgos::register_node_class("Filter", "MMBrightnessContrast");
ClassDB::register_class<MMBlurGaussian>(); ClassDB::register_class<MMBlurGaussian>();
MMAlgos::register_node_class("Filter", "MMBlurGaussian"); MMAlgos::register_node_class("Filter", "MMBlurGaussian");
ClassDB::register_class<MMBlend>(); ClassDB::register_class<MMBlend>();
MMAlgos::register_node_class("Filter", "MMBlend"); MMAlgos::register_node_class("Filter", "MMBlend");
ClassDB::register_class<MMAdjustHsv>(); ClassDB::register_class<MMAdjustHsv>();
MMAlgos::register_node_class("Filter", "MMAdjustHsv"); MMAlgos::register_node_class("Filter", "MMAdjustHsv");
}
_mm_algos_singleton = memnew(_MMAlgos);
Engine::get_singleton()->add_singleton(Engine::Singleton("MMAlgos", _MMAlgos::get_singleton()));
#if TOOLS_ENABLED #if TOOLS_ENABLED
EditorPlugins::add_by_type<MaterialMakerEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<MaterialMakerEditorPlugin>();
}
#endif #endif
} }
void unregister_material_maker_types(ModuleRegistrationLevel p_level) { void unregister_material_maker_types(ModuleRegistrationLevel p_level) {
if (_mm_algos_singleton) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(_mm_algos_singleton); if (_mm_algos_singleton) {
memdelete(_mm_algos_singleton);
}
} }
} }

20
modules/mbedtls/register_types.cpp
View File

@ -36,15 +36,19 @@
#include "stream_peer_mbedtls.h" #include "stream_peer_mbedtls.h"
void register_mbedtls_types(ModuleRegistrationLevel p_level) { void register_mbedtls_types(ModuleRegistrationLevel p_level) {
CryptoMbedTLS::initialize_crypto(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
StreamPeerMbedTLS::initialize_ssl(); CryptoMbedTLS::initialize_crypto();
PacketPeerMbedDTLS::initialize_dtls(); StreamPeerMbedTLS::initialize_ssl();
DTLSServerMbedTLS::initialize(); PacketPeerMbedDTLS::initialize_dtls();
DTLSServerMbedTLS::initialize();
}
} }
void unregister_mbedtls_types(ModuleRegistrationLevel p_level) { void unregister_mbedtls_types(ModuleRegistrationLevel p_level) {
DTLSServerMbedTLS::finalize(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
PacketPeerMbedDTLS::finalize_dtls(); DTLSServerMbedTLS::finalize();
StreamPeerMbedTLS::finalize_ssl(); PacketPeerMbedDTLS::finalize_dtls();
CryptoMbedTLS::finalize_crypto(); StreamPeerMbedTLS::finalize_ssl();
CryptoMbedTLS::finalize_crypto();
}
} }

30
modules/mesh_data_resource/register_types.cpp
View File

@ -53,34 +53,36 @@ SOFTWARE.
#endif #endif
void register_mesh_data_resource_types(ModuleRegistrationLevel p_level) { void register_mesh_data_resource_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<MeshDataResource>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<MeshDataResourceCollection>(); ClassDB::register_class<MeshDataResource>();
ClassDB::register_class<MeshDataResourceCollection>();
ClassDB::register_class<MeshDataInstance>(); ClassDB::register_class<MeshDataInstance>();
ClassDB::register_class<MeshDataInstance2D>(); ClassDB::register_class<MeshDataInstance2D>();
#ifdef MODULE_PROPS_ENABLED #ifdef MODULE_PROPS_ENABLED
ClassDB::register_class<PropDataMeshData>(); ClassDB::register_class<PropDataMeshData>();
Ref<PropDataMeshData> processor = Ref<PropDataMeshData>(memnew(PropDataMeshData)); Ref<PropDataMeshData> processor = Ref<PropDataMeshData>(memnew(PropDataMeshData));
PropUtils::add_processor(processor); PropUtils::add_processor(processor);
#endif #endif
#ifdef MODULE_PROPS_2D_ENABLED #ifdef MODULE_PROPS_2D_ENABLED
ClassDB::register_class<Prop2DDataMeshData>(); ClassDB::register_class<Prop2DDataMeshData>();
Ref<Prop2DDataMeshData> prop_2d_processor = Ref<Prop2DDataMeshData>(memnew(Prop2DDataMeshData)); Ref<Prop2DDataMeshData> prop_2d_processor = Ref<Prop2DDataMeshData>(memnew(Prop2DDataMeshData));
Prop2DUtils::add_processor(prop_2d_processor); Prop2DUtils::add_processor(prop_2d_processor);
#endif #endif
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
#ifdef MODULE_GLTF_ENABLED #ifdef MODULE_GLTF_ENABLED
EditorPlugins::add_by_type<EditorPluginGLTFMdr>(); EditorPlugins::add_by_type<EditorPluginGLTFMdr>();
#endif #endif
#ifdef MODULE_MESH_UTILS_ENABLED #ifdef MODULE_MESH_UTILS_ENABLED
EditorPlugins::add_by_type<MDIEdPlugin>(); EditorPlugins::add_by_type<MDIEdPlugin>();
#endif #endif
}
#endif #endif
} }

20
modules/mesh_utils/register_types.cpp
View File

@ -33,16 +33,22 @@ SOFTWARE.
static MeshUtils *mesh_utils = NULL; static MeshUtils *mesh_utils = NULL;
void register_mesh_utils_types(ModuleRegistrationLevel p_level) { void register_mesh_utils_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<FastQuadraticMeshSimplifier>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<MeshMerger>(); mesh_utils = memnew(MeshUtils);
ClassDB::register_class<MeshUtils>();
Engine::get_singleton()->add_singleton(Engine::Singleton("MeshUtils", MeshUtils::get_singleton()));
}
mesh_utils = memnew(MeshUtils); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<MeshUtils>(); ClassDB::register_class<FastQuadraticMeshSimplifier>();
Engine::get_singleton()->add_singleton(Engine::Singleton("MeshUtils", MeshUtils::get_singleton())); ClassDB::register_class<MeshMerger>();
}
} }
void unregister_mesh_utils_types(ModuleRegistrationLevel p_level) { void unregister_mesh_utils_types(ModuleRegistrationLevel p_level) {
if (mesh_utils) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(mesh_utils); if (mesh_utils) {
memdelete(mesh_utils);
}
} }
} }

15
modules/minimp3/register_types.cpp
View File

@ -38,14 +38,19 @@
#endif #endif
void register_minimp3_types(ModuleRegistrationLevel p_level) { void register_minimp3_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<AudioStreamMP3>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
if (Engine::get_singleton()->is_editor_hint()) { if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
Ref<ResourceImporterMP3> mp3_import; if (Engine::get_singleton()->is_editor_hint()) {
mp3_import.instance(); Ref<ResourceImporterMP3> mp3_import;
ResourceFormatImporter::get_singleton()->add_importer(mp3_import); mp3_import.instance();
ResourceFormatImporter::get_singleton()->add_importer(mp3_import);
}
} }
#endif #endif
ClassDB::register_class<AudioStreamMP3>();
} }
void unregister_minimp3_types(ModuleRegistrationLevel p_level) { void unregister_minimp3_types(ModuleRegistrationLevel p_level) {

20
modules/navigation/register_types.cpp
View File

@ -51,23 +51,29 @@ NavigationServer *new_server() {
} }
void register_navigation_types(ModuleRegistrationLevel p_level) { void register_navigation_types(ModuleRegistrationLevel p_level) {
NavigationServerManager::set_default_server(new_server); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
NavigationServerManager::set_default_server(new_server);
#ifndef _3D_DISABLED #ifndef _3D_DISABLED
_nav_mesh_generator = memnew(NavigationMeshGenerator); _nav_mesh_generator = memnew(NavigationMeshGenerator);
ClassDB::register_class<NavigationMeshGenerator>(); ClassDB::register_class<NavigationMeshGenerator>();
Engine::get_singleton()->add_singleton(Engine::Singleton("NavigationMeshGenerator", NavigationMeshGenerator::get_singleton())); Engine::get_singleton()->add_singleton(Engine::Singleton("NavigationMeshGenerator", NavigationMeshGenerator::get_singleton()));
#endif #endif
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<NavigationMeshEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<NavigationMeshEditorPlugin>();
}
#endif #endif
} }
void unregister_navigation_types(ModuleRegistrationLevel p_level) { void unregister_navigation_types(ModuleRegistrationLevel p_level) {
#ifndef _3D_DISABLED #ifndef _3D_DISABLED
if (_nav_mesh_generator) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(_nav_mesh_generator); if (_nav_mesh_generator) {
memdelete(_nav_mesh_generator);
}
} }
#endif #endif
} }

19
modules/network_synchronizer/register_types.cpp
View File

@ -34,23 +34,24 @@
#include "register_types.h" #include "register_types.h"
#include "core/config/project_settings.h"
#include "data_buffer.h" #include "data_buffer.h"
#include "interpolator.h" #include "interpolator.h"
#include "networked_controller.h" #include "networked_controller.h"
#include "scene_diff.h" #include "scene_diff.h"
#include "scene_synchronizer.h" #include "scene_synchronizer.h"
#include "core/config/project_settings.h"
void register_network_synchronizer_types(ModuleRegistrationLevel p_level) { void register_network_synchronizer_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<DataBuffer>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<SceneDiff>(); ClassDB::register_class<DataBuffer>();
ClassDB::register_class<Interpolator>(); ClassDB::register_class<SceneDiff>();
ClassDB::register_class<NetworkedController>(); ClassDB::register_class<Interpolator>();
ClassDB::register_class<SceneSynchronizer>(); ClassDB::register_class<NetworkedController>();
ClassDB::register_class<SceneSynchronizer>();
GLOBAL_DEF("NetworkSynchronizer/debug_server_speedup", false); GLOBAL_DEF("NetworkSynchronizer/debug_server_speedup", false);
GLOBAL_DEF("NetworkSynchronizer/debug_doll_speedup", false); GLOBAL_DEF("NetworkSynchronizer/debug_doll_speedup", false);
}
} }
void unregister_network_synchronizer_types(ModuleRegistrationLevel p_level) { void unregister_network_synchronizer_types(ModuleRegistrationLevel p_level) {

6
modules/opensimplex/register_types.cpp
View File

@ -33,8 +33,10 @@
#include "open_simplex_noise.h" #include "open_simplex_noise.h"
void register_opensimplex_types(ModuleRegistrationLevel p_level) { void register_opensimplex_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<OpenSimplexNoise>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<NoiseTexture>(); ClassDB::register_class<OpenSimplexNoise>();
ClassDB::register_class<NoiseTexture>();
}
} }
void unregister_opensimplex_types(ModuleRegistrationLevel p_level) { void unregister_opensimplex_types(ModuleRegistrationLevel p_level) {

48
modules/paint/register_types.cpp
View File

@ -53,34 +53,38 @@ SOFTWARE.
#endif #endif
void register_paint_types(ModuleRegistrationLevel p_level) { void register_paint_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<PaintAction>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<PaintAction>();
ClassDB::register_class<BrightenAction>(); ClassDB::register_class<BrightenAction>();
ClassDB::register_class<BrushAction>(); ClassDB::register_class<BrushAction>();
ClassDB::register_class<BucketAction>(); ClassDB::register_class<BucketAction>();
ClassDB::register_class<CutAction>(); ClassDB::register_class<CutAction>();
ClassDB::register_class<DarkenAction>(); ClassDB::register_class<DarkenAction>();
ClassDB::register_class<LineAction>(); ClassDB::register_class<LineAction>();
ClassDB::register_class<MultiLineAction>(); ClassDB::register_class<MultiLineAction>();
ClassDB::register_class<PasteCutAction>(); ClassDB::register_class<PasteCutAction>();
ClassDB::register_class<PencilAction>(); ClassDB::register_class<PencilAction>();
ClassDB::register_class<RainbowAction>(); ClassDB::register_class<RainbowAction>();
ClassDB::register_class<RectAction>(); ClassDB::register_class<RectAction>();
ClassDB::register_class<PaintCanvasBackground>(); ClassDB::register_class<PaintCanvasBackground>();
ClassDB::register_class<PaintVisualGrid>(); ClassDB::register_class<PaintVisualGrid>();
ClassDB::register_class<PaintCustomPropertyInspector>(); ClassDB::register_class<PaintCustomPropertyInspector>();
ClassDB::register_class<PaintToolsPropertyInspector>(); ClassDB::register_class<PaintToolsPropertyInspector>();
ClassDB::register_class<PaintProjectPropertyInspector>(); ClassDB::register_class<PaintProjectPropertyInspector>();
ClassDB::register_class<PaintProjectToolsPropertyInspector>(); ClassDB::register_class<PaintProjectToolsPropertyInspector>();
ClassDB::register_class<PaintNode>(); ClassDB::register_class<PaintNode>();
ClassDB::register_class<PaintCanvas>(); ClassDB::register_class<PaintCanvas>();
ClassDB::register_class<PaintProject>(); ClassDB::register_class<PaintProject>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<PaintEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<PaintEditorPlugin>();
}
#endif #endif
} }

102
modules/props/register_types.cpp
View File

@ -72,78 +72,86 @@ static PropUtils *prop_utils = NULL;
static PropCache *prop_texture_cache = NULL; static PropCache *prop_texture_cache = NULL;
void register_props_types(ModuleRegistrationLevel p_level) { void register_props_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<TiledWall>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<TiledWallData>(); prop_utils = memnew(PropUtils);
ClassDB::register_class<PropUtils>();
Engine::get_singleton()->add_singleton(Engine::Singleton("PropUtils", PropUtils::get_singleton()));
ClassDB::register_class<PropLight>(); prop_texture_cache = memnew(PropCache);
ClassDB::register_class<PropCache>();
Engine::get_singleton()->add_singleton(Engine::Singleton("PropCache", PropCache::get_singleton()));
}
ClassDB::register_class<PropData>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<PropDataEntry>(); ClassDB::register_class<TiledWall>();
ClassDB::register_class<PropDataScene>(); ClassDB::register_class<TiledWallData>();
ClassDB::register_class<PropDataLight>();
ClassDB::register_class<PropDataProp>();
ClassDB::register_class<PropDataTiledWall>();
ClassDB::register_class<PropDataPortal>(); ClassDB::register_class<PropLight>();
ClassDB::register_class<GroundClutter>(); ClassDB::register_class<PropData>();
ClassDB::register_class<GroundClutterFoliage>(); ClassDB::register_class<PropDataEntry>();
ClassDB::register_class<PropDataScene>();
ClassDB::register_class<PropDataLight>();
ClassDB::register_class<PropDataProp>();
ClassDB::register_class<PropDataTiledWall>();
ClassDB::register_class<PropMesher>(); ClassDB::register_class<PropDataPortal>();
ClassDB::register_class<PropMesherJobStep>();
ClassDB::register_class<PropInstance>(); ClassDB::register_class<GroundClutter>();
ClassDB::register_class<PropInstanceMerger>(); ClassDB::register_class<GroundClutterFoliage>();
ClassDB::register_class<PropESSEntity>(); ClassDB::register_class<PropMesher>();
ClassDB::register_class<PropMesherJobStep>();
ClassDB::register_class<PropInstanceJob>(); ClassDB::register_class<PropInstance>();
ClassDB::register_class<PropInstancePropJob>(); ClassDB::register_class<PropInstanceMerger>();
ClassDB::register_class<PropTextureJob>(); ClassDB::register_class<PropESSEntity>();
ClassDB::register_class<PropSceneInstance>(); ClassDB::register_class<PropInstanceJob>();
ClassDB::register_class<PropInstancePropJob>();
ClassDB::register_class<PropMaterialCache>(); ClassDB::register_class<PropTextureJob>();
ClassDB::register_class<PropSceneInstance>();
ClassDB::register_class<PropMaterialCache>();
#ifdef MODULE_TEXTURE_PACKER_ENABLED #ifdef MODULE_TEXTURE_PACKER_ENABLED
ClassDB::register_class<PropMaterialCachePCM>(); ClassDB::register_class<PropMaterialCachePCM>();
#endif #endif
prop_utils = memnew(PropUtils); Ref<PropDataLight> light_processor = Ref<PropDataLight>(memnew(PropDataLight));
ClassDB::register_class<PropUtils>(); PropUtils::add_processor(light_processor);
Engine::get_singleton()->add_singleton(Engine::Singleton("PropUtils", PropUtils::get_singleton()));
prop_texture_cache = memnew(PropCache); Ref<PropDataProp> prop_processor = Ref<PropDataProp>(memnew(PropDataProp));
ClassDB::register_class<PropCache>(); PropUtils::add_processor(prop_processor);
Engine::get_singleton()->add_singleton(Engine::Singleton("PropCache", PropCache::get_singleton()));
Ref<PropDataLight> light_processor = Ref<PropDataLight>(memnew(PropDataLight)); Ref<PropDataScene> scene_processor = Ref<PropDataScene>(memnew(PropDataScene));
PropUtils::add_processor(light_processor); PropUtils::add_processor(scene_processor);
Ref<PropDataProp> prop_processor = Ref<PropDataProp>(memnew(PropDataProp)); Ref<PropDataPortal> portal_processor = Ref<PropDataPortal>(memnew(PropDataPortal));
PropUtils::add_processor(prop_processor); PropUtils::add_processor(portal_processor);
Ref<PropDataScene> scene_processor = Ref<PropDataScene>(memnew(PropDataScene)); Ref<PropDataTiledWall> tiled_wall_processor = Ref<PropDataTiledWall>(memnew(PropDataTiledWall));
PropUtils::add_processor(scene_processor); PropUtils::add_processor(tiled_wall_processor);
}
Ref<PropDataPortal> portal_processor = Ref<PropDataPortal>(memnew(PropDataPortal));
PropUtils::add_processor(portal_processor);
Ref<PropDataTiledWall> tiled_wall_processor = Ref<PropDataTiledWall>(memnew(PropDataTiledWall));
PropUtils::add_processor(tiled_wall_processor);
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<PropEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<PropEditorPlugin>();
}
#endif #endif
} }
void unregister_props_types(ModuleRegistrationLevel p_level) { void unregister_props_types(ModuleRegistrationLevel p_level) {
if (prop_utils) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(prop_utils); if (prop_utils) {
} memdelete(prop_utils);
}
if (prop_texture_cache) { if (prop_texture_cache) {
memdelete(prop_texture_cache); memdelete(prop_texture_cache);
}
} }
} }

106
modules/props_2d/register_types.cpp
View File

@ -72,81 +72,89 @@ static Prop2DUtils *prop_utils = NULL;
static Prop2DCache *prop_texture_cache = NULL; static Prop2DCache *prop_texture_cache = NULL;
void register_props_2d_types(ModuleRegistrationLevel p_level) { void register_props_2d_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<TiledWall2D>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<TiledWall2DData>(); prop_utils = memnew(Prop2DUtils);
ClassDB::register_class<Prop2DUtils>();
Engine::get_singleton()->add_singleton(Engine::Singleton("Prop2DUtils", Prop2DUtils::get_singleton()));
ClassDB::register_class<Prop2DLight>(); prop_texture_cache = memnew(Prop2DCache);
ClassDB::register_class<Prop2DCache>();
Engine::get_singleton()->add_singleton(Engine::Singleton("Prop2DCache", Prop2DCache::get_singleton()));
}
ClassDB::register_class<Prop2DData>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<Prop2DDataEntry>(); ClassDB::register_class<TiledWall2D>();
ClassDB::register_class<Prop2DDataScene>(); ClassDB::register_class<TiledWall2DData>();
ClassDB::register_class<Prop2DDataLight>();
ClassDB::register_class<Prop2DDataProp2D>();
ClassDB::register_class<Prop2DDataTiledWall2D>();
ClassDB::register_class<Prop2DDataSprite>();
ClassDB::register_class<Prop2DDataPortal>(); ClassDB::register_class<Prop2DLight>();
ClassDB::register_class<GroundClutter2D>(); ClassDB::register_class<Prop2DData>();
ClassDB::register_class<GroundClutter2DFoliage>(); ClassDB::register_class<Prop2DDataEntry>();
ClassDB::register_class<Prop2DDataScene>();
ClassDB::register_class<Prop2DDataLight>();
ClassDB::register_class<Prop2DDataProp2D>();
ClassDB::register_class<Prop2DDataTiledWall2D>();
ClassDB::register_class<Prop2DDataSprite>();
ClassDB::register_class<Prop2DMesher>(); ClassDB::register_class<Prop2DDataPortal>();
ClassDB::register_class<Prop2DInstance>(); ClassDB::register_class<GroundClutter2D>();
ClassDB::register_class<Prop2DInstanceMerger>(); ClassDB::register_class<GroundClutter2DFoliage>();
ClassDB::register_class<Prop2DESSEntity>(); ClassDB::register_class<Prop2DMesher>();
ClassDB::register_class<Prop2DInstanceJob>(); ClassDB::register_class<Prop2DInstance>();
ClassDB::register_class<Prop2DInstanceProp2DJob>(); ClassDB::register_class<Prop2DInstanceMerger>();
ClassDB::register_class<Prop2DTextureJob>(); ClassDB::register_class<Prop2DESSEntity>();
ClassDB::register_class<Prop2DSceneInstance>(); ClassDB::register_class<Prop2DInstanceJob>();
ClassDB::register_class<Prop2DInstanceProp2DJob>();
ClassDB::register_class<Prop2DMaterialCache>(); ClassDB::register_class<Prop2DTextureJob>();
ClassDB::register_class<Prop2DSceneInstance>();
ClassDB::register_class<Prop2DMaterialCache>();
#ifdef MODULE_TEXTURE_PACKER_ENABLED #ifdef MODULE_TEXTURE_PACKER_ENABLED
ClassDB::register_class<Prop2DMaterialCachePCM>(); ClassDB::register_class<Prop2DMaterialCachePCM>();
#endif #endif
prop_utils = memnew(Prop2DUtils); Ref<Prop2DDataLight> light_processor = Ref<Prop2DDataLight>(memnew(Prop2DDataLight));
ClassDB::register_class<Prop2DUtils>(); Prop2DUtils::add_processor(light_processor);
Engine::get_singleton()->add_singleton(Engine::Singleton("Prop2DUtils", Prop2DUtils::get_singleton()));
prop_texture_cache = memnew(Prop2DCache); Ref<Prop2DDataProp2D> prop_processor = Ref<Prop2DDataProp2D>(memnew(Prop2DDataProp2D));
ClassDB::register_class<Prop2DCache>(); Prop2DUtils::add_processor(prop_processor);
Engine::get_singleton()->add_singleton(Engine::Singleton("Prop2DCache", Prop2DCache::get_singleton()));
Ref<Prop2DDataLight> light_processor = Ref<Prop2DDataLight>(memnew(Prop2DDataLight)); Ref<Prop2DDataScene> scene_processor = Ref<Prop2DDataScene>(memnew(Prop2DDataScene));
Prop2DUtils::add_processor(light_processor); Prop2DUtils::add_processor(scene_processor);
Ref<Prop2DDataProp2D> prop_processor = Ref<Prop2DDataProp2D>(memnew(Prop2DDataProp2D)); Ref<Prop2DDataPortal> portal_processor = Ref<Prop2DDataPortal>(memnew(Prop2DDataPortal));
Prop2DUtils::add_processor(prop_processor); Prop2DUtils::add_processor(portal_processor);
Ref<Prop2DDataScene> scene_processor = Ref<Prop2DDataScene>(memnew(Prop2DDataScene)); Ref<Prop2DDataTiledWall2D> tiled_wall_processor = Ref<Prop2DDataTiledWall2D>(memnew(Prop2DDataTiledWall2D));
Prop2DUtils::add_processor(scene_processor); Prop2DUtils::add_processor(tiled_wall_processor);
Ref<Prop2DDataPortal> portal_processor = Ref<Prop2DDataPortal>(memnew(Prop2DDataPortal)); Ref<Prop2DDataSprite> sprite_processor = Ref<Prop2DDataSprite>(memnew(Prop2DDataSprite));
Prop2DUtils::add_processor(portal_processor); Prop2DUtils::add_processor(sprite_processor);
}
Ref<Prop2DDataTiledWall2D> tiled_wall_processor = Ref<Prop2DDataTiledWall2D>(memnew(Prop2DDataTiledWall2D));
Prop2DUtils::add_processor(tiled_wall_processor);
Ref<Prop2DDataSprite> sprite_processor = Ref<Prop2DDataSprite>(memnew(Prop2DDataSprite));
Prop2DUtils::add_processor(sprite_processor);
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<Prop2DEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<Prop2DEditorPlugin>();
}
#endif #endif
} }
void unregister_props_2d_types(ModuleRegistrationLevel p_level) { void unregister_props_2d_types(ModuleRegistrationLevel p_level) {
if (prop_utils) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(prop_utils); if (prop_utils) {
} memdelete(prop_utils);
}
if (prop_texture_cache) { if (prop_texture_cache) {
memdelete(prop_texture_cache); memdelete(prop_texture_cache);
}
} }
} }

14
modules/pvr/register_types.cpp
View File

@ -36,13 +36,17 @@
static Ref<ResourceFormatPVR> resource_loader_pvr; static Ref<ResourceFormatPVR> resource_loader_pvr;
void register_pvr_types(ModuleRegistrationLevel p_level) { void register_pvr_types(ModuleRegistrationLevel p_level) {
resource_loader_pvr.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ResourceLoader::add_resource_format_loader(resource_loader_pvr); resource_loader_pvr.instance();
ResourceLoader::add_resource_format_loader(resource_loader_pvr);
_register_pvrtc_compress_func(); _register_pvrtc_compress_func();
}
} }
void unregister_pvr_types(ModuleRegistrationLevel p_level) { void unregister_pvr_types(ModuleRegistrationLevel p_level) {
ResourceLoader::remove_resource_format_loader(resource_loader_pvr); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
resource_loader_pvr.unref(); ResourceLoader::remove_resource_format_loader(resource_loader_pvr);
resource_loader_pvr.unref();
}
} }

6
modules/regex/register_types.cpp
View File

@ -33,8 +33,10 @@
#include "regex.h" #include "regex.h"
void register_regex_types(ModuleRegistrationLevel p_level) { void register_regex_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<RegExMatch>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<RegEx>(); ClassDB::register_class<RegExMatch>();
ClassDB::register_class<RegEx>();
}
} }
void unregister_regex_types(ModuleRegistrationLevel p_level) { void unregister_regex_types(ModuleRegistrationLevel p_level) {

32
modules/skeleton_2d/register_types.cpp
View File

@ -19,24 +19,28 @@
#endif #endif
void register_skeleton_2d_types(ModuleRegistrationLevel p_level) { void register_skeleton_2d_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<Skeleton2D>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<Bone2D>(); ClassDB::register_class<Skeleton2D>();
ClassDB::register_class<PhysicalBone2D>(); ClassDB::register_class<Bone2D>();
ClassDB::register_class<PhysicalBone2D>();
ClassDB::register_class<SkeletonModificationStack2D>(); ClassDB::register_class<SkeletonModificationStack2D>();
ClassDB::register_class<SkeletonModification2D>(); ClassDB::register_class<SkeletonModification2D>();
ClassDB::register_class<SkeletonModification2DLookAt>(); ClassDB::register_class<SkeletonModification2DLookAt>();
ClassDB::register_class<SkeletonModification2DCCDIK>(); ClassDB::register_class<SkeletonModification2DCCDIK>();
ClassDB::register_class<SkeletonModification2DFABRIK>(); ClassDB::register_class<SkeletonModification2DFABRIK>();
ClassDB::register_class<SkeletonModification2DJiggle>(); ClassDB::register_class<SkeletonModification2DJiggle>();
ClassDB::register_class<SkeletonModification2DTwoBoneIK>(); ClassDB::register_class<SkeletonModification2DTwoBoneIK>();
ClassDB::register_class<SkeletonModification2DStackHolder>(); ClassDB::register_class<SkeletonModification2DStackHolder>();
ClassDB::register_class<PhysicalBone2D>(); ClassDB::register_class<PhysicalBone2D>();
ClassDB::register_class<SkeletonModification2DPhysicalBones>(); ClassDB::register_class<SkeletonModification2DPhysicalBones>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<Skeleton2DEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<Skeleton2DEditorPlugin>();
}
#endif #endif
} }

40
modules/skeleton_3d/register_types.cpp
View File

@ -19,35 +19,39 @@
#include "resources/skeleton_modification_stack_3d.h" #include "resources/skeleton_modification_stack_3d.h"
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "editor/physical_bone_plugin.h"
#include "editor/skeleton_editor_plugin.h" #include "editor/skeleton_editor_plugin.h"
#include "editor/skeleton_ik_editor_plugin.h" #include "editor/skeleton_ik_editor_plugin.h"
#include "editor/physical_bone_plugin.h"
#endif #endif
void register_skeleton_3d_types(ModuleRegistrationLevel p_level) { void register_skeleton_3d_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<Skeleton>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<Skin>(); ClassDB::register_class<Skeleton>();
ClassDB::register_class<SkinReference>(); ClassDB::register_class<Skin>();
ClassDB::register_class<SkinReference>();
ClassDB::register_class<BoneAttachment>(); ClassDB::register_class<BoneAttachment>();
ClassDB::register_class<SkeletonIK>(); ClassDB::register_class<SkeletonIK>();
ClassDB::register_class<PhysicalBone>(); ClassDB::register_class<PhysicalBone>();
ClassDB::register_class<SkeletonModificationStack3D>(); ClassDB::register_class<SkeletonModificationStack3D>();
ClassDB::register_class<SkeletonModification3D>(); ClassDB::register_class<SkeletonModification3D>();
ClassDB::register_class<SkeletonModification3DLookAt>(); ClassDB::register_class<SkeletonModification3DLookAt>();
ClassDB::register_class<SkeletonModification3DCCDIK>(); ClassDB::register_class<SkeletonModification3DCCDIK>();
ClassDB::register_class<SkeletonModification3DFABRIK>(); ClassDB::register_class<SkeletonModification3DFABRIK>();
ClassDB::register_class<SkeletonModification3DJiggle>(); ClassDB::register_class<SkeletonModification3DJiggle>();
ClassDB::register_class<SkeletonModification3DTwoBoneIK>(); ClassDB::register_class<SkeletonModification3DTwoBoneIK>();
ClassDB::register_class<SkeletonModification3DStackHolder>(); ClassDB::register_class<SkeletonModification3DStackHolder>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<SkeletonEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<SkeletonIKEditorPlugin>(); EditorPlugins::add_by_type<SkeletonEditorPlugin>();
EditorPlugins::add_by_type<PhysicalBonePlugin>(); EditorPlugins::add_by_type<SkeletonIKEditorPlugin>();
EditorPlugins::add_by_type<PhysicalBonePlugin>();
}
#endif #endif
} }

6
modules/squish/register_types.cpp
View File

@ -32,8 +32,10 @@
#include "image_compress_squish.h" #include "image_compress_squish.h"
void register_squish_types(ModuleRegistrationLevel p_level) { void register_squish_types(ModuleRegistrationLevel p_level) {
Image::set_compress_bc_func(image_compress_squish); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
Image::_image_decompress_bc = image_decompress_squish; Image::set_compress_bc_func(image_compress_squish);
Image::_image_decompress_bc = image_decompress_squish;
}
} }
void unregister_squish_types(ModuleRegistrationLevel p_level) {} void unregister_squish_types(ModuleRegistrationLevel p_level) {}

15
modules/stb_vorbis/register_types.cpp
View File

@ -38,14 +38,19 @@
#endif #endif
void register_stb_vorbis_types(ModuleRegistrationLevel p_level) { void register_stb_vorbis_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<AudioStreamOGGVorbis>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
if (Engine::get_singleton()->is_editor_hint()) { if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
Ref<ResourceImporterOGGVorbis> ogg_import; if (Engine::get_singleton()->is_editor_hint()) {
ogg_import.instance(); Ref<ResourceImporterOGGVorbis> ogg_import;
ResourceFormatImporter::get_singleton()->add_importer(ogg_import); ogg_import.instance();
ResourceFormatImporter::get_singleton()->add_importer(ogg_import);
}
} }
#endif #endif
ClassDB::register_class<AudioStreamOGGVorbis>();
} }
void unregister_stb_vorbis_types(ModuleRegistrationLevel p_level) { void unregister_stb_vorbis_types(ModuleRegistrationLevel p_level) {

72
modules/steering_ai/register_types.cpp
View File

@ -62,45 +62,51 @@ SOFTWARE.
static GSAIUtils *gs_ai_utils = NULL; static GSAIUtils *gs_ai_utils = NULL;
void register_steering_ai_types(ModuleRegistrationLevel p_level) { void register_steering_ai_types(ModuleRegistrationLevel p_level) {
gs_ai_utils = memnew(GSAIUtils); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<GSAIUtils>(); gs_ai_utils = memnew(GSAIUtils);
Engine::get_singleton()->add_singleton(Engine::Singleton("GSAIUtils", GSAIUtils::get_singleton())); ClassDB::register_class<GSAIUtils>();
Engine::get_singleton()->add_singleton(Engine::Singleton("GSAIUtils", GSAIUtils::get_singleton()));
}
ClassDB::register_class<GSAITargetAcceleration>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<GSAISteeringBehavior>(); ClassDB::register_class<GSAITargetAcceleration>();
ClassDB::register_class<GSAISteeringAgent>(); ClassDB::register_class<GSAISteeringBehavior>();
ClassDB::register_class<GSAIPath>(); ClassDB::register_class<GSAISteeringAgent>();
ClassDB::register_class<GSAIGroupBehavior>(); ClassDB::register_class<GSAIPath>();
ClassDB::register_class<GSAIAgentLocation>(); ClassDB::register_class<GSAIGroupBehavior>();
ClassDB::register_class<GSAIProximity>(); ClassDB::register_class<GSAIAgentLocation>();
ClassDB::register_class<GSAIProximity>();
ClassDB::register_class<GSAIRadiusProximity>(); ClassDB::register_class<GSAIRadiusProximity>();
ClassDB::register_class<GSAIInfiniteProximity>(); ClassDB::register_class<GSAIInfiniteProximity>();
ClassDB::register_class<GSAIArrive>(); ClassDB::register_class<GSAIArrive>();
ClassDB::register_class<GSAIAvoidCollisions>(); ClassDB::register_class<GSAIAvoidCollisions>();
ClassDB::register_class<GSAIBlend>(); ClassDB::register_class<GSAIBlend>();
ClassDB::register_class<GSAICohesion>(); ClassDB::register_class<GSAICohesion>();
ClassDB::register_class<GSAIEvade>(); ClassDB::register_class<GSAIEvade>();
ClassDB::register_class<GSAIFace>(); ClassDB::register_class<GSAIFace>();
ClassDB::register_class<GSAIFlee>(); ClassDB::register_class<GSAIFlee>();
ClassDB::register_class<GSAIFollowPath>(); ClassDB::register_class<GSAIFollowPath>();
ClassDB::register_class<GSAILookWhereYouGo>(); ClassDB::register_class<GSAILookWhereYouGo>();
ClassDB::register_class<GSAIMatchOrientation>(); ClassDB::register_class<GSAIMatchOrientation>();
ClassDB::register_class<GSAIPriority>(); ClassDB::register_class<GSAIPriority>();
ClassDB::register_class<GSAIPursue>(); ClassDB::register_class<GSAIPursue>();
ClassDB::register_class<GSAISeek>(); ClassDB::register_class<GSAISeek>();
ClassDB::register_class<GSAISeparation>(); ClassDB::register_class<GSAISeparation>();
ClassDB::register_class<GSAIKinematicBody2DAgent>(); ClassDB::register_class<GSAIKinematicBody2DAgent>();
ClassDB::register_class<GSAIKinematicBody3DAgent>(); ClassDB::register_class<GSAIKinematicBody3DAgent>();
ClassDB::register_class<GSAIRigidBody2DAgent>(); ClassDB::register_class<GSAIRigidBody2DAgent>();
ClassDB::register_class<GSAIRigidBody3DAgent>(); ClassDB::register_class<GSAIRigidBody3DAgent>();
ClassDB::register_class<GSAISpecializedAgent>(); ClassDB::register_class<GSAISpecializedAgent>();
}
} }
void unregister_steering_ai_types(ModuleRegistrationLevel p_level) { void unregister_steering_ai_types(ModuleRegistrationLevel p_level) {
if (gs_ai_utils) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(gs_ai_utils); if (gs_ai_utils) {
memdelete(gs_ai_utils);
}
} }
} }

10
modules/svg/register_types.cpp
View File

@ -35,10 +35,14 @@
static ImageLoaderSVG *image_loader_svg = nullptr; static ImageLoaderSVG *image_loader_svg = nullptr;
void register_svg_types(ModuleRegistrationLevel p_level) { void register_svg_types(ModuleRegistrationLevel p_level) {
image_loader_svg = memnew(ImageLoaderSVG); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ImageLoader::add_image_format_loader(image_loader_svg); image_loader_svg = memnew(ImageLoaderSVG);
ImageLoader::add_image_format_loader(image_loader_svg);
}
} }
void unregister_svg_types(ModuleRegistrationLevel p_level) { void unregister_svg_types(ModuleRegistrationLevel p_level) {
memdelete(image_loader_svg); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
memdelete(image_loader_svg);
}
} }

68
modules/terraman/register_types.cpp
View File

@ -71,53 +71,57 @@ SOFTWARE.
#include "world/jobs/terrain_terrain_job.h" #include "world/jobs/terrain_terrain_job.h"
void register_terraman_types(ModuleRegistrationLevel p_level) { void register_terraman_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<TerrainMesher>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<TerrainMesherDefault>(); ClassDB::register_class<TerrainMesher>();
ClassDB::register_class<TerrainMesherDefault>();
ClassDB::register_class<TerrainSurface>(); ClassDB::register_class<TerrainSurface>();
ClassDB::register_class<TerrainSurfaceSimple>(); ClassDB::register_class<TerrainSurfaceSimple>();
ClassDB::register_class<TerrainLibrary>(); ClassDB::register_class<TerrainLibrary>();
ClassDB::register_class<TerrainLibrarySimple>(); ClassDB::register_class<TerrainLibrarySimple>();
ClassDB::register_class<TerrainMaterialCache>(); ClassDB::register_class<TerrainMaterialCache>();
#ifdef MODULE_TEXTURE_PACKER_ENABLED #ifdef MODULE_TEXTURE_PACKER_ENABLED
ClassDB::register_class<TerrainSurfaceMerger>(); ClassDB::register_class<TerrainSurfaceMerger>();
ClassDB::register_class<TerrainLibraryMerger>(); ClassDB::register_class<TerrainLibraryMerger>();
ClassDB::register_class<TerrainLibraryMergerPCM>(); ClassDB::register_class<TerrainLibraryMergerPCM>();
ClassDB::register_class<TerrainMaterialCachePCM>(); ClassDB::register_class<TerrainMaterialCachePCM>();
#endif #endif
ClassDB::register_class<TerrainLight>(); ClassDB::register_class<TerrainLight>();
ClassDB::register_class<TerrainLightNode>(); ClassDB::register_class<TerrainLightNode>();
ClassDB::register_class<TerrainWorld>(); ClassDB::register_class<TerrainWorld>();
ClassDB::register_class<TerrainChunk>(); ClassDB::register_class<TerrainChunk>();
ClassDB::register_class<TerrainStructure>(); ClassDB::register_class<TerrainStructure>();
ClassDB::register_class<BlockTerrainStructure>(); ClassDB::register_class<BlockTerrainStructure>();
ClassDB::register_class<TerrainEnvironmentData>(); ClassDB::register_class<TerrainEnvironmentData>();
ClassDB::register_class<TerrainChunkDefault>(); ClassDB::register_class<TerrainChunkDefault>();
ClassDB::register_class<TerrainWorldDefault>(); ClassDB::register_class<TerrainWorldDefault>();
ClassDB::register_class<TerrainMesherBlocky>(); ClassDB::register_class<TerrainMesherBlocky>();
ClassDB::register_class<TerrainWorldBlocky>(); ClassDB::register_class<TerrainWorldBlocky>();
ClassDB::register_class<TerrainChunkBlocky>(); ClassDB::register_class<TerrainChunkBlocky>();
ClassDB::register_class<TerrainLevelGenerator>(); ClassDB::register_class<TerrainLevelGenerator>();
ClassDB::register_class<TerrainLevelGeneratorFlat>(); ClassDB::register_class<TerrainLevelGeneratorFlat>();
ClassDB::register_class<TerrainWorldArea>(); ClassDB::register_class<TerrainWorldArea>();
ClassDB::register_class<TerrainJob>(); ClassDB::register_class<TerrainJob>();
ClassDB::register_class<TerrainTerrainJob>(); ClassDB::register_class<TerrainTerrainJob>();
ClassDB::register_class<TerrainMesherJobStep>(); ClassDB::register_class<TerrainMesherJobStep>();
ClassDB::register_class<TerrainLightJob>(); ClassDB::register_class<TerrainLightJob>();
ClassDB::register_class<TerrainPropJob>(); ClassDB::register_class<TerrainPropJob>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<TerrainWorldEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<TerrainWorldEditorPlugin>();
}
#endif #endif
} }

72
modules/terraman_2d/register_types.cpp
View File

@ -73,56 +73,60 @@ SOFTWARE.
#include "world/jobs/terrain_2d_terrain_job.h" #include "world/jobs/terrain_2d_terrain_job.h"
void register_terraman_2d_types(ModuleRegistrationLevel p_level) { void register_terraman_2d_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<Terrain2DMesher>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<Terrain2DMesherDefault>(); ClassDB::register_class<Terrain2DMesher>();
ClassDB::register_class<Terrain2DMesherDefault>();
ClassDB::register_class<Terrain2DSurface>(); ClassDB::register_class<Terrain2DSurface>();
ClassDB::register_class<Terrain2DSurfaceSimple>(); ClassDB::register_class<Terrain2DSurfaceSimple>();
ClassDB::register_class<Terrain2DLibrary>(); ClassDB::register_class<Terrain2DLibrary>();
ClassDB::register_class<Terrain2DLibrarySimple>(); ClassDB::register_class<Terrain2DLibrarySimple>();
ClassDB::register_class<Terrain2DMaterialCache>(); ClassDB::register_class<Terrain2DMaterialCache>();
#ifdef MODULE_TEXTURE_PACKER_ENABLED #ifdef MODULE_TEXTURE_PACKER_ENABLED
ClassDB::register_class<Terrain2DSurfaceMerger>(); ClassDB::register_class<Terrain2DSurfaceMerger>();
ClassDB::register_class<Terrain2DLibraryMerger>(); ClassDB::register_class<Terrain2DLibraryMerger>();
ClassDB::register_class<Terrain2DLibraryMergerPCM>(); ClassDB::register_class<Terrain2DLibraryMergerPCM>();
ClassDB::register_class<Terrain2DMaterialCachePCM>(); ClassDB::register_class<Terrain2DMaterialCachePCM>();
#endif #endif
ClassDB::register_class<Terrain2DLight>(); ClassDB::register_class<Terrain2DLight>();
ClassDB::register_class<Terrain2DLightNode>(); ClassDB::register_class<Terrain2DLightNode>();
ClassDB::register_class<Terrain2DWorld>(); ClassDB::register_class<Terrain2DWorld>();
ClassDB::register_class<Terrain2DChunk>(); ClassDB::register_class<Terrain2DChunk>();
ClassDB::register_class<Terrain2DStructure>(); ClassDB::register_class<Terrain2DStructure>();
ClassDB::register_class<BlockTerrain2DStructure>(); ClassDB::register_class<BlockTerrain2DStructure>();
ClassDB::register_class<Terrain2DEnvironmentData>(); ClassDB::register_class<Terrain2DEnvironmentData>();
ClassDB::register_class<Terrain2DChunkDefault>(); ClassDB::register_class<Terrain2DChunkDefault>();
ClassDB::register_class<Terrain2DWorldDefault>(); ClassDB::register_class<Terrain2DWorldDefault>();
ClassDB::register_class<Terrain2DMesherSimple>(); ClassDB::register_class<Terrain2DMesherSimple>();
ClassDB::register_class<Terrain2DWorldSimple>(); ClassDB::register_class<Terrain2DWorldSimple>();
ClassDB::register_class<Terrain2DChunkSimple>(); ClassDB::register_class<Terrain2DChunkSimple>();
ClassDB::register_class<Terrain2DMesherIsometric>(); ClassDB::register_class<Terrain2DMesherIsometric>();
ClassDB::register_class<Terrain2DWorldIsometric>(); ClassDB::register_class<Terrain2DWorldIsometric>();
ClassDB::register_class<Terrain2DChunkIsometric>(); ClassDB::register_class<Terrain2DChunkIsometric>();
ClassDB::register_class<Terrain2DLevelGenerator>(); ClassDB::register_class<Terrain2DLevelGenerator>();
ClassDB::register_class<Terrain2DLevelGeneratorFlat>(); ClassDB::register_class<Terrain2DLevelGeneratorFlat>();
ClassDB::register_class<Terrain2DWorldArea>(); ClassDB::register_class<Terrain2DWorldArea>();
ClassDB::register_class<Terrain2DJob>(); ClassDB::register_class<Terrain2DJob>();
ClassDB::register_class<Terrain2DTerrain2DJob>(); ClassDB::register_class<Terrain2DTerrain2DJob>();
ClassDB::register_class<Terrain2DLightJob>(); ClassDB::register_class<Terrain2DLightJob>();
ClassDB::register_class<Terrain2DProp2DJob>(); ClassDB::register_class<Terrain2DProp2DJob>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<Terrain2DWorldEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<Terrain2DWorldEditorPlugin>();
}
#endif #endif
} }

14
modules/texture_packer/register_types.cpp
View File

@ -36,15 +36,19 @@ SOFTWARE.
#endif #endif
void register_texture_packer_types(ModuleRegistrationLevel p_level) { void register_texture_packer_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<TexturePacker>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<TextureMerger>(); ClassDB::register_class<TexturePacker>();
ClassDB::register_class<TextureMerger>();
ClassDB::register_class<PackerImageResource>(); ClassDB::register_class<PackerImageResource>();
ClassDB::register_class<TextureLayerMerger>(); ClassDB::register_class<TextureLayerMerger>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<EditorPluginPackerImageResource>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<EditorPluginPackerImageResource>();
}
#endif #endif
} }

10
modules/tga/register_types.cpp
View File

@ -35,10 +35,14 @@
static ImageLoaderTGA *image_loader_tga = nullptr; static ImageLoaderTGA *image_loader_tga = nullptr;
void register_tga_types(ModuleRegistrationLevel p_level) { void register_tga_types(ModuleRegistrationLevel p_level) {
image_loader_tga = memnew(ImageLoaderTGA); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ImageLoader::add_image_format_loader(image_loader_tga); image_loader_tga = memnew(ImageLoaderTGA);
ImageLoader::add_image_format_loader(image_loader_tga);
}
} }
void unregister_tga_types(ModuleRegistrationLevel p_level) { void unregister_tga_types(ModuleRegistrationLevel p_level) {
memdelete(image_loader_tga); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
memdelete(image_loader_tga);
}
} }

16
modules/theora/register_types.cpp
View File

@ -35,13 +35,19 @@
static Ref<ResourceFormatLoaderTheora> resource_loader_theora; static Ref<ResourceFormatLoaderTheora> resource_loader_theora;
void register_theora_types(ModuleRegistrationLevel p_level) { void register_theora_types(ModuleRegistrationLevel p_level) {
resource_loader_theora.instance(); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
ResourceLoader::add_resource_format_loader(resource_loader_theora, true); resource_loader_theora.instance();
ResourceLoader::add_resource_format_loader(resource_loader_theora, true);
}
ClassDB::register_class<VideoStreamTheora>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<VideoStreamTheora>();
}
} }
void unregister_theora_types(ModuleRegistrationLevel p_level) { void unregister_theora_types(ModuleRegistrationLevel p_level) {
ResourceLoader::remove_resource_format_loader(resource_loader_theora); if (p_level == MODULE_REGISTRATION_LEVEL_CORE) {
resource_loader_theora.unref(); ResourceLoader::remove_resource_format_loader(resource_loader_theora);
resource_loader_theora.unref();
}
} }

16
modules/tile_map/register_types.cpp
View File

@ -31,13 +31,17 @@ SOFTWARE.
#endif #endif
void register_tile_map_types(ModuleRegistrationLevel p_level) { void register_tile_map_types(ModuleRegistrationLevel p_level) {
#ifdef TOOLS_ENABLED if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
EditorPlugins::add_by_type<TileMapEditorPlugin>(); ClassDB::register_class<TileMap>();
EditorPlugins::add_by_type<TileSetEditorPlugin>(); ClassDB::register_class<TileSet>();
#endif }
ClassDB::register_class<TileMap>(); #ifdef TOOLS_ENABLED
ClassDB::register_class<TileSet>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<TileMapEditorPlugin>();
EditorPlugins::add_by_type<TileSetEditorPlugin>();
}
#endif
} }
void unregister_tile_map_types(ModuleRegistrationLevel p_level) { void unregister_tile_map_types(ModuleRegistrationLevel p_level) {

10
modules/ui_extensions/register_types.cpp
View File

@ -23,14 +23,16 @@ SOFTWARE.
#include "register_types.h" #include "register_types.h"
#include "bs_input_event_key.h" #include "bs_input_event_key.h"
#include "input_map_editor.h"
#include "core/input/shortcut.h" #include "core/input/shortcut.h"
#include "input_map_editor.h"
#include "touch_button.h" #include "touch_button.h"
void register_ui_extensions_types(ModuleRegistrationLevel p_level) { void register_ui_extensions_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<TouchButton>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<BSInputEventKey>(); ClassDB::register_class<TouchButton>();
ClassDB::register_class<InputMapEditor>(); ClassDB::register_class<BSInputEventKey>();
ClassDB::register_class<InputMapEditor>();
}
} }
void unregister_ui_extensions_types(ModuleRegistrationLevel p_level) { void unregister_ui_extensions_types(ModuleRegistrationLevel p_level) {

6
modules/upnp/register_types.cpp
View File

@ -36,8 +36,10 @@
#include "upnp_device.h" #include "upnp_device.h"
void register_upnp_types(ModuleRegistrationLevel p_level) { void register_upnp_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<UPNP>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<UPNPDevice>(); ClassDB::register_class<UPNP>();
ClassDB::register_class<UPNPDevice>();
}
} }
void unregister_upnp_types(ModuleRegistrationLevel p_level) { void unregister_upnp_types(ModuleRegistrationLevel p_level) {

47
modules/users/register_types.cpp
View File

@ -55,38 +55,43 @@ SOFTWARE.
UserDB *_user_db = nullptr; UserDB *_user_db = nullptr;
void register_users_types(ModuleRegistrationLevel p_level) { void register_users_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<User>(); if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
ClassDB::register_class<UserModule>(); _user_db = memnew(UserDB);
ClassDB::register_class<UserDB>();
Engine::get_singleton()->add_singleton(Engine::Singleton("UserDB", UserDB::get_singleton()));
}
ClassDB::register_class<UserManager>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<UserManagerStatic>(); ClassDB::register_class<User>();
ClassDB::register_class<UserManagerFile>(); ClassDB::register_class<UserModule>();
ClassDB::register_class<UserDB>(); ClassDB::register_class<UserManager>();
ClassDB::register_class<UserManagerStatic>();
_user_db = memnew(UserDB); ClassDB::register_class<UserManagerFile>();
Engine::get_singleton()->add_singleton(Engine::Singleton("UserDB", UserDB::get_singleton()));
#ifdef MODULE_WEB_ENABLED #ifdef MODULE_WEB_ENABLED
ClassDB::register_class<UserSessionSetupWebServerMiddleware>(); ClassDB::register_class<UserSessionSetupWebServerMiddleware>();
ClassDB::register_class<UserWebPage>(); ClassDB::register_class<UserWebPage>();
ClassDB::register_class<UserDeleteWebPage>(); ClassDB::register_class<UserDeleteWebPage>();
ClassDB::register_class<UserLoginWebPage>(); ClassDB::register_class<UserLoginWebPage>();
ClassDB::register_class<UserLogoutWebPage>(); ClassDB::register_class<UserLogoutWebPage>();
ClassDB::register_class<UserPasswordResetWebPage>(); ClassDB::register_class<UserPasswordResetWebPage>();
ClassDB::register_class<UserRegisterWebPage>(); ClassDB::register_class<UserRegisterWebPage>();
ClassDB::register_class<UserSettingsWebPage>(); ClassDB::register_class<UserSettingsWebPage>();
ClassDB::register_class<UserStatsWebPage>(); ClassDB::register_class<UserStatsWebPage>();
#endif #endif
#ifdef MODULE_DATABASE_ENABLED #ifdef MODULE_DATABASE_ENABLED
ClassDB::register_class<UserManagerDB>(); ClassDB::register_class<UserManagerDB>();
#endif #endif
}
} }
void unregister_users_types(ModuleRegistrationLevel p_level) { void unregister_users_types(ModuleRegistrationLevel p_level) {
if (_user_db) { if (p_level == MODULE_REGISTRATION_LEVEL_SINGLETON) {
memdelete(_user_db); if (_user_db) {
memdelete(_user_db);
}
} }
} }

8
modules/vhacd/register_types.cpp
View File

@ -79,9 +79,13 @@ static Vector<PoolVector<Vector3>> convex_decompose(const real_t *p_vertices, in
} }
void register_vhacd_types(ModuleRegistrationLevel p_level) { void register_vhacd_types(ModuleRegistrationLevel p_level) {
Mesh::convex_decomposition_function = convex_decompose; if (p_level == MODULE_REGISTRATION_LEVEL_DRIVER) {
Mesh::convex_decomposition_function = convex_decompose;
}
} }
void unregister_vhacd_types(ModuleRegistrationLevel p_level) { void unregister_vhacd_types(ModuleRegistrationLevel p_level) {
Mesh::convex_decomposition_function = nullptr; if (p_level == MODULE_REGISTRATION_LEVEL_DRIVER) {
Mesh::convex_decomposition_function = nullptr;
}
} }

86
modules/voxelman/register_types.cpp
View File

@ -84,66 +84,70 @@ SOFTWARE.
#include "world/jobs/voxel_terrain_job.h" #include "world/jobs/voxel_terrain_job.h"
void register_voxelman_types(ModuleRegistrationLevel p_level) { void register_voxelman_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<VoxelMesher>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<VoxelMesherDefault>(); ClassDB::register_class<VoxelMesher>();
ClassDB::register_class<VoxelMesherDefault>();
ClassDB::register_class<VoxelMesherMarchingCubes>(); ClassDB::register_class<VoxelMesherMarchingCubes>();
ClassDB::register_class<MarchingCubesCellData>(); ClassDB::register_class<MarchingCubesCellData>();
ClassDB::register_class<VoxelSurface>(); ClassDB::register_class<VoxelSurface>();
ClassDB::register_class<VoxelSurfaceSimple>(); ClassDB::register_class<VoxelSurfaceSimple>();
ClassDB::register_class<VoxelLibrary>(); ClassDB::register_class<VoxelLibrary>();
ClassDB::register_class<VoxelLibrarySimple>(); ClassDB::register_class<VoxelLibrarySimple>();
ClassDB::register_class<VoxelMaterialCache>(); ClassDB::register_class<VoxelMaterialCache>();
#ifdef MODULE_TEXTURE_PACKER_ENABLED #ifdef MODULE_TEXTURE_PACKER_ENABLED
ClassDB::register_class<VoxelSurfaceMerger>(); ClassDB::register_class<VoxelSurfaceMerger>();
ClassDB::register_class<VoxelLibraryMerger>(); ClassDB::register_class<VoxelLibraryMerger>();
ClassDB::register_class<VoxelLibraryMergerPCM>(); ClassDB::register_class<VoxelLibraryMergerPCM>();
ClassDB::register_class<VoxelMaterialCachePCM>(); ClassDB::register_class<VoxelMaterialCachePCM>();
#endif #endif
ClassDB::register_class<VoxelLight>(); ClassDB::register_class<VoxelLight>();
ClassDB::register_class<VoxelLightNode>(); ClassDB::register_class<VoxelLightNode>();
ClassDB::register_class<VoxelWorld>(); ClassDB::register_class<VoxelWorld>();
ClassDB::register_class<VoxelChunk>(); ClassDB::register_class<VoxelChunk>();
ClassDB::register_class<VoxelStructure>(); ClassDB::register_class<VoxelStructure>();
ClassDB::register_class<BlockVoxelStructure>(); ClassDB::register_class<BlockVoxelStructure>();
ClassDB::register_class<EnvironmentData>(); ClassDB::register_class<EnvironmentData>();
ClassDB::register_class<VoxelChunkDefault>(); ClassDB::register_class<VoxelChunkDefault>();
ClassDB::register_class<VoxelWorldDefault>(); ClassDB::register_class<VoxelWorldDefault>();
ClassDB::register_class<VoxelMesherCubic>(); ClassDB::register_class<VoxelMesherCubic>();
ClassDB::register_class<VoxelCubePoints>(); ClassDB::register_class<VoxelCubePoints>();
ClassDB::register_class<VoxelMesherBlocky>(); ClassDB::register_class<VoxelMesherBlocky>();
ClassDB::register_class<VoxelWorldBlocky>(); ClassDB::register_class<VoxelWorldBlocky>();
ClassDB::register_class<VoxelChunkBlocky>(); ClassDB::register_class<VoxelChunkBlocky>();
ClassDB::register_class<VoxelMesherLiquidBlocky>(); ClassDB::register_class<VoxelMesherLiquidBlocky>();
ClassDB::register_class<VoxelWorldMarchingCubes>(); ClassDB::register_class<VoxelWorldMarchingCubes>();
ClassDB::register_class<VoxelChunkMarchingCubes>(); ClassDB::register_class<VoxelChunkMarchingCubes>();
ClassDB::register_class<VoxelWorldCubic>(); ClassDB::register_class<VoxelWorldCubic>();
ClassDB::register_class<VoxelChunkCubic>(); ClassDB::register_class<VoxelChunkCubic>();
ClassDB::register_class<VoxelLevelGenerator>(); ClassDB::register_class<VoxelLevelGenerator>();
ClassDB::register_class<VoxelLevelGeneratorFlat>(); ClassDB::register_class<VoxelLevelGeneratorFlat>();
ClassDB::register_class<WorldArea>(); ClassDB::register_class<WorldArea>();
ClassDB::register_class<VoxelJob>(); ClassDB::register_class<VoxelJob>();
ClassDB::register_class<VoxelTerrainJob>(); ClassDB::register_class<VoxelTerrainJob>();
ClassDB::register_class<VoxelMesherJobStep>(); ClassDB::register_class<VoxelMesherJobStep>();
ClassDB::register_class<VoxelLightJob>(); ClassDB::register_class<VoxelLightJob>();
ClassDB::register_class<VoxelPropJob>(); ClassDB::register_class<VoxelPropJob>();
}
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
EditorPlugins::add_by_type<VoxelWorldEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<VoxelWorldEditorPlugin>();
}
#endif #endif
} }

108
modules/web/register_types.cpp
View File

@ -73,76 +73,80 @@ SOFTWARE.
#endif #endif
void register_web_types(ModuleRegistrationLevel p_level) { void register_web_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<_HTMLBuilder>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<_HTMLTag>(); ClassDB::register_class<_HTMLBuilder>();
ClassDB::register_class<_HTMLTag>();
ClassDB::register_class<HTMLPaginator>(); ClassDB::register_class<HTMLPaginator>();
ClassDB::register_class<FormFieldEntry>(); ClassDB::register_class<FormFieldEntry>();
ClassDB::register_class<FormExistsFieldEntry>(); ClassDB::register_class<FormExistsFieldEntry>();
ClassDB::register_class<FormIntFieldEntry>(); ClassDB::register_class<FormIntFieldEntry>();
ClassDB::register_class<FormFloatFieldEntry>(); ClassDB::register_class<FormFloatFieldEntry>();
ClassDB::register_class<FormAlphaFieldEntry>(); ClassDB::register_class<FormAlphaFieldEntry>();
ClassDB::register_class<FormAlphaNumericFieldEntry>(); ClassDB::register_class<FormAlphaNumericFieldEntry>();
ClassDB::register_class<FormNeedsLowercaseCharacterFieldEntry>(); ClassDB::register_class<FormNeedsLowercaseCharacterFieldEntry>();
ClassDB::register_class<FormNeedsUppercaseCharacterFieldEntry>(); ClassDB::register_class<FormNeedsUppercaseCharacterFieldEntry>();
ClassDB::register_class<FormNeedsOtherCharacterFieldEntry>(); ClassDB::register_class<FormNeedsOtherCharacterFieldEntry>();
ClassDB::register_class<FormMinimumLengthFieldEntry>(); ClassDB::register_class<FormMinimumLengthFieldEntry>();
ClassDB::register_class<FormMaximumLengthFieldEntry>(); ClassDB::register_class<FormMaximumLengthFieldEntry>();
ClassDB::register_class<FormEmailFieldEntry>(); ClassDB::register_class<FormEmailFieldEntry>();
ClassDB::register_class<FormNeedToMatchOtherFieldEntry>(); ClassDB::register_class<FormNeedToMatchOtherFieldEntry>();
ClassDB::register_class<FormField>(); ClassDB::register_class<FormField>();
ClassDB::register_class<FormValidator>(); ClassDB::register_class<FormValidator>();
ClassDB::register_class<HTMLParserAttribute>(); ClassDB::register_class<HTMLParserAttribute>();
ClassDB::register_class<HTMLParserTag>(); ClassDB::register_class<HTMLParserTag>();
ClassDB::register_class<HTMLParser>(); ClassDB::register_class<HTMLParser>();
ClassDB::register_class<BBCodeParserAttribute>(); ClassDB::register_class<BBCodeParserAttribute>();
ClassDB::register_class<BBCodeParserTag>(); ClassDB::register_class<BBCodeParserTag>();
ClassDB::register_class<BBCodeParser>(); ClassDB::register_class<BBCodeParser>();
ClassDB::register_class<MarkdownRenderer>(); ClassDB::register_class<MarkdownRenderer>();
ClassDB::register_class<FileCache>(); ClassDB::register_class<FileCache>();
ClassDB::register_class<HTTPServerEnums>(); ClassDB::register_class<HTTPServerEnums>();
ClassDB::register_class<CSRFTokenWebServerMiddleware>(); ClassDB::register_class<CSRFTokenWebServerMiddleware>();
ClassDB::register_class<HTTPSession>(); ClassDB::register_class<HTTPSession>();
ClassDB::register_class<HTTPSessionManager>(); ClassDB::register_class<HTTPSessionManager>();
ClassDB::register_class<SessionSetupWebServerMiddleware>(); ClassDB::register_class<SessionSetupWebServerMiddleware>();
ClassDB::register_class<WebNode>(); ClassDB::register_class<WebNode>();
ClassDB::register_class<WebPermission>(); ClassDB::register_class<WebPermission>();
ClassDB::register_class<WebRoot>(); ClassDB::register_class<WebRoot>();
ClassDB::register_class<WebServer>(); ClassDB::register_class<WebServer>();
ClassDB::register_class<WebServerCookie>(); ClassDB::register_class<WebServerCookie>();
ClassDB::register_class<WebServerMiddleware>(); ClassDB::register_class<WebServerMiddleware>();
ClassDB::register_class<WebServerRequest>(); ClassDB::register_class<WebServerRequest>();
ClassDB::register_class<WebServerRequestScriptable>(); ClassDB::register_class<WebServerRequestScriptable>();
ClassDB::register_class<StaticWebPage>(); ClassDB::register_class<StaticWebPage>();
ClassDB::register_class<StaticWebPageFile>(); ClassDB::register_class<StaticWebPageFile>();
ClassDB::register_class<StaticWebPageFolderFiles>(); ClassDB::register_class<StaticWebPageFolderFiles>();
ClassDB::register_class<FolderServeWebPage>(); ClassDB::register_class<FolderServeWebPage>();
ClassDB::register_class<BrowsableFolderServeWebPage>(); ClassDB::register_class<BrowsableFolderServeWebPage>();
ClassDB::register_class<ListWebPage>(); ClassDB::register_class<ListWebPage>();
ClassDB::register_class<PagedArticleWebPage>(); ClassDB::register_class<PagedArticleWebPage>();
ClassDB::register_class<PagedArticlesWebPage>(); ClassDB::register_class<PagedArticlesWebPage>();
//ClassDB::register_class<PagedArticlesWebPageMDIndex>(); //ClassDB::register_class<PagedArticlesWebPageMDIndex>();
ClassDB::register_class<RedirectWebPage>(); ClassDB::register_class<RedirectWebPage>();
ClassDB::register_class<AliasWebPage>(); ClassDB::register_class<AliasWebPage>();
#ifdef MODULE_DATABASE_ENABLED #ifdef MODULE_DATABASE_ENABLED
ClassDB::register_class<HTTPSessionManagerDB>(); ClassDB::register_class<HTTPSessionManagerDB>();
#endif #endif
}
#if TOOLS_ENABLED #if TOOLS_ENABLED
EditorPlugins::add_by_type<WebNodeEditorPlugin>(); if (p_level == MODULE_REGISTRATION_LEVEL_EDITOR) {
EditorPlugins::add_by_type<WebNodeEditorPlugin>();
}
#endif #endif
} }

46
modules/websocket/register_types.cpp
View File

@ -29,8 +29,8 @@
/*************************************************************************/ /*************************************************************************/
#include "register_types.h" #include "register_types.h"
#include "core/error/error_macros.h"
#include "core/config/project_settings.h" #include "core/config/project_settings.h"
#include "core/error/error_macros.h"
#ifdef JAVASCRIPT_ENABLED #ifdef JAVASCRIPT_ENABLED
#include "emscripten.h" #include "emscripten.h"
#include "emws_client.h" #include "emws_client.h"
@ -42,36 +42,40 @@
#endif #endif
void register_websocket_types(ModuleRegistrationLevel p_level) { void register_websocket_types(ModuleRegistrationLevel p_level) {
if (p_level == MODULE_REGISTRATION_LEVEL_DRIVER) {
#define _SET_HINT(NAME, _VAL_, _MAX_) \ #define _SET_HINT(NAME, _VAL_, _MAX_) \
GLOBAL_DEF(NAME, _VAL_); \ GLOBAL_DEF(NAME, _VAL_); \
ProjectSettings::get_singleton()->set_custom_property_info(NAME, PropertyInfo(Variant::INT, NAME, PROPERTY_HINT_RANGE, "2," #_MAX_ ",1,or_greater")); ProjectSettings::get_singleton()->set_custom_property_info(NAME, PropertyInfo(Variant::INT, NAME, PROPERTY_HINT_RANGE, "2," #_MAX_ ",1,or_greater"));
// Client buffers project settings // Client buffers project settings
_SET_HINT(WSC_IN_BUF, 64, 4096); _SET_HINT(WSC_IN_BUF, 64, 4096);
_SET_HINT(WSC_IN_PKT, 1024, 16384); _SET_HINT(WSC_IN_PKT, 1024, 16384);
_SET_HINT(WSC_OUT_BUF, 64, 4096); _SET_HINT(WSC_OUT_BUF, 64, 4096);
_SET_HINT(WSC_OUT_PKT, 1024, 16384); _SET_HINT(WSC_OUT_PKT, 1024, 16384);
// Server buffers project settings // Server buffers project settings
_SET_HINT(WSS_IN_BUF, 64, 4096); _SET_HINT(WSS_IN_BUF, 64, 4096);
_SET_HINT(WSS_IN_PKT, 1024, 16384); _SET_HINT(WSS_IN_PKT, 1024, 16384);
_SET_HINT(WSS_OUT_BUF, 64, 4096); _SET_HINT(WSS_OUT_BUF, 64, 4096);
_SET_HINT(WSS_OUT_PKT, 1024, 16384); _SET_HINT(WSS_OUT_PKT, 1024, 16384);
#ifdef JAVASCRIPT_ENABLED #ifdef JAVASCRIPT_ENABLED
EMWSPeer::make_default(); EMWSPeer::make_default();
EMWSClient::make_default(); EMWSClient::make_default();
EMWSServer::make_default(); EMWSServer::make_default();
#else #else
WSLPeer::make_default(); WSLPeer::make_default();
WSLClient::make_default(); WSLClient::make_default();
WSLServer::make_default(); WSLServer::make_default();
#endif #endif
}
ClassDB::register_virtual_class<WebSocketMultiplayerPeer>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_custom_instance_class<WebSocketServer>(); ClassDB::register_virtual_class<WebSocketMultiplayerPeer>();
ClassDB::register_custom_instance_class<WebSocketClient>(); ClassDB::register_custom_instance_class<WebSocketServer>();
ClassDB::register_custom_instance_class<WebSocketPeer>(); ClassDB::register_custom_instance_class<WebSocketClient>();
ClassDB::register_custom_instance_class<WebSocketPeer>();
}
} }
void unregister_websocket_types(ModuleRegistrationLevel p_level) {} void unregister_websocket_types(ModuleRegistrationLevel p_level) {}

12
modules/wfc/register_types.cpp
View File

@ -1,16 +1,18 @@
#include "register_types.h" #include "register_types.h"
#include "image_indexer.h"
#include "overlapping_wave_form_collapse.h" #include "overlapping_wave_form_collapse.h"
#include "tiling_wave_form_collapse.h" #include "tiling_wave_form_collapse.h"
#include "wave_form_collapse.h" #include "wave_form_collapse.h"
#include "image_indexer.h"
void register_wfc_types(ModuleRegistrationLevel p_level) { void register_wfc_types(ModuleRegistrationLevel p_level) {
ClassDB::register_class<WaveFormCollapse>(); if (p_level == MODULE_REGISTRATION_LEVEL_SCENE) {
ClassDB::register_class<OverlappingWaveFormCollapse>(); ClassDB::register_class<WaveFormCollapse>();
ClassDB::register_class<TilingWaveFormCollapse>(); ClassDB::register_class<OverlappingWaveFormCollapse>();
ClassDB::register_class<ImageIndexer>(); ClassDB::register_class<TilingWaveFormCollapse>();
ClassDB::register_class<ImageIndexer>();
}
} }
void unregister_wfc_types(ModuleRegistrationLevel p_level) { void unregister_wfc_types(ModuleRegistrationLevel p_level) {