Renames

Author: CedNaru

src/api/language/gdj_language.cpp

@@ -1,11 +1,11 @@
 #include "gdj_language.h"
 
-#include "gd_kotlin.h"
+#include "api/script/jvm_script_manager.h"
+#include "api/script/language/gdj_script.h"
+#include "godot_jvm.h"
 #include "jvm/wrapper/memory/memory_manager.h"
 #include "lifecycle/paths.h"
 #include "names.h"
-#include "api/script/jvm_script_manager.h"
-#include "api/script/language/gdj_script.h"
 
 constexpr const char* GDJ_TEMPLATE = "// GENERATED BY THE GODOT EDITOR. DON'T FORGET TO CREATE A CORRESPONDING SOURCE "
                                      "FILE! OTHERWISE THIS FILE WILL BE DELETED UPON NEXT BUILD.\n"
@@ -27,23 +27,23 @@ GdjLanguage* GdjLanguage::get_instance() {
 }
 
 void GdjLanguage::init() {
-    GDKotlin::get_instance().initialize_up_to(GDKotlin::State::JVM_SCRIPTS_INITIALIZED);
+    GodotJvm::get_instance().initialize_up_to(GodotJvm::State::JVM_SCRIPTS_INITIALIZED);
 
 #ifdef DEBUG_ENABLED
-    GDKotlin::get_instance().validate_state();
+    GodotJvm::get_instance().validate_state();
 #endif
 }
 
 void GdjLanguage::frame() {
-    if (unlikely(GDKotlin::get_instance().state < GDKotlin::State::CORE_LIBRARY_INITIALIZED)) { return; }
-    if (unlikely(GDKotlin::get_instance().user_configuration.disable_gc)) { return; }
+    if (unlikely(GodotJvm::get_instance().state < GodotJvm::State::CORE_LIBRARY_INITIALIZED)) { return; }
+    if (unlikely(GodotJvm::get_instance().user_configuration.disable_gc)) { return; }
 
     jni::Env env {jni::Jvm::current_env()};
     MemoryManager::get_instance().sync_memory(env);
 }
 
 void GdjLanguage::finish() {
-    GDKotlin::get_instance().finalize_down_to(GDKotlin::State::NOT_STARTED);
+    GodotJvm::get_instance().finalize_down_to(GodotJvm::State::NOT_STARTED);
 }
 
 void GdjLanguage::thread_enter() {

src/api/resource_format/java_archive_resource_format_loader.cpp

@@ -1,7 +1,7 @@
 
 #include "java_archive_resource_format_loader.h"
 
-#include "gd_kotlin.h"
+#include "godot_jvm.h"
 #include "hash.h"
 #include "java_archive.h"
 #include "lifecycle/paths.h"
@@ -35,8 +35,7 @@ Ref<Resource> JavaArchiveFormatLoader::load(
     ref.instantiate();
 
 #ifdef TOOLS_ENABLED
-    if(p_path.ends_with(USER_CODE_FILE)){
-        GDKotlin::get_instance().reload_user_code();
+    if(p_path.ends_with(USER_CODE_FILE)){ GodotJvm::get_instance().reload_user_code();
     }
 #endif
 

src/core/kotlin_binding.cpp renamed to src/core/jvm_binding.cpp

@@ -1,9 +1,7 @@
-#include "kotlin_binding.h"
-
 #include "jvm/wrapper/memory/type_manager.h"
+#include "jvm_binding.h"
 
-
-void KotlinBinding::init(Object* p_object) {
+void JvmBinding::init(Object* p_object) {
     StringName class_name {p_object->get_class_name()};
     do {
         if (!TypeManager::get_instance().java_engine_type_constructor_for_type_exists(class_name)) {
@@ -15,11 +13,11 @@ void KotlinBinding::init(Object* p_object) {
     constructor_id = TypeManager::get_instance().get_java_engine_type_constructor_index_for_type(class_name);
 }
 
-int KotlinBinding::get_constructor_id() const{
+int JvmBinding::get_constructor_id() const{
     return constructor_id;
 }
 
-bool KotlinBinding::test_and_set_incremented() {
+bool JvmBinding::test_and_set_incremented() {
     // Set to true and return the previous value.
     return is_incremented.test_and_set(std::memory_order_acq_rel);
 }

src/core/kotlin_binding.h renamed to src/core/jvm_binding.h

@@ -1,20 +1,20 @@
-#ifndef GODOT_JVM_KOTLIN_BINDING_H
-#define GODOT_JVM_KOTLIN_BINDING_H
+#ifndef GODOT_JVM_JVM_BINDING_H
+#define GODOT_JVM_JVM_BINDING_H
 
 #include "jvm_wrapper/registration/kt_object.h"
 #include <atomic>
 
-class KotlinBinding {
+class JvmBinding {
     int constructor_id = -1;
     // Using std directly because Godot SafeFlag doesn't provide the right methods (despite wrapping the same std atomic).
     std::atomic_flag is_incremented = ATOMIC_FLAG_INIT;
 public:
-    KotlinBinding() = default;
-    ~KotlinBinding() = default;
+    JvmBinding() = default;
+    ~JvmBinding() = default;
 
     void init(Object* obj);
     int get_constructor_id() const;
     bool test_and_set_incremented();
 };
 
-#endif// GODOT_JVM_KOTLIN_BINDING_H
+#endif // GODOT_JVM_JVM_BINDING_H

src/core/kotlin_binding_manager.cpp renamed to src/core/jvm_binding_manager.cpp

@@ -1,60 +1,59 @@
-#include "kotlin_binding_manager.h"
-
-#include "gd_kotlin.h"
+#include "godot_jvm.h"
 #include "jvm/wrapper/memory/memory_manager.h"
+#include "jvm_binding_manager.h"
 
-GDExtensionInstanceBindingCallbacks KotlinBindingManager::_instance_binding_callbacks = {
+GDExtensionInstanceBindingCallbacks JvmBindingManager::_instance_binding_callbacks = {
   &_instance_binding_create_callback,
   &_instance_binding_free_callback,
   nullptr
 };
 
-void* KotlinBindingManager::_instance_binding_create_callback(void* p_token, void* p_instance) {
-    KotlinBinding* binding = memnew(KotlinBinding);
+void* JvmBindingManager::_instance_binding_create_callback(void* p_token, void* p_instance) {
+    JvmBinding* binding = memnew(JvmBinding);
     binding->init(reinterpret_cast<godot::Object*>(p_instance));
 
     return binding;
 }
 
-void KotlinBindingManager::_instance_binding_free_callback(void* p_token, void* p_instance, void* p_binding) {
+void JvmBindingManager::_instance_binding_free_callback(void* p_token, void* p_instance, void* p_binding) {
     // Called in the destructor of the Object.
     //  It's the very last action done in the destructor so assume variables local to the Object have been cleaned (including script and extension).
     // There are 2 cases, either an Object has been freed, and we have to release its reference OR it's a RefCounted and the JVM instance is already dead.
 
-    godot::memdelete(reinterpret_cast<KotlinBinding*>(p_binding));
+    godot::memdelete(reinterpret_cast<JvmBinding*>(p_binding));
 
     godot::Object* object = reinterpret_cast<godot::Object*>(p_instance);
     if (!object->is_ref_counted()) { MemoryManager::get_instance().queue_dead_object(object); }
 }
 
-KotlinBinding* KotlinBindingManager::set_instance_binding(godot::Object* p_object) {
+JvmBinding* JvmBindingManager::set_instance_binding(godot::Object* p_object) {
     // Godot being weird. Call this function only if the JVM is the creator of the object, otherwise it will crash in case the object has any other bindings.
     // If not the creator (When you want to bind an existing object to JVM), use get_instance_binding instead.
 
-    KotlinBinding* binding = memnew(KotlinBinding);
+    JvmBinding* binding = memnew(JvmBinding);
     binding->init(p_object);
 
     if (p_object->is_ref_counted()) {
         reinterpret_cast<godot::RefCounted*>(p_object)->init_ref();
         binding->test_and_set_incremented();
     }
-    p_object->set_instance_binding(&GDKotlin::get_instance(), binding, &_instance_binding_callbacks);
+    p_object->set_instance_binding(&GodotJvm::get_instance(), binding, &_instance_binding_callbacks);
 
     return binding;
 }
 
-KotlinBinding* KotlinBindingManager::get_instance_binding(godot::Object* p_object) {
+JvmBinding* JvmBindingManager::get_instance_binding(godot::Object* p_object) {
     // Godot being weird but this is how you create a binding if it doesn't exist already, otherwise just retrieve it.
     //  Use this function to bind an existing object to the JVM, the callbacks provided will handle the creation of the binding.
-    KotlinBinding* binding =
-      reinterpret_cast<KotlinBinding*>(p_object->get_instance_binding(&GDKotlin::get_instance(), &_instance_binding_callbacks));
+    JvmBinding* binding =
+      reinterpret_cast<JvmBinding*>(p_object->get_instance_binding(&GodotJvm::get_instance(), &_instance_binding_callbacks));
 
     if (p_object->is_ref_counted() && !binding->test_and_set_incremented()) {
         reinterpret_cast<godot::RefCounted*>(p_object)->reference();
     }
     return binding;
 }
 
-void KotlinBindingManager::free_binding(godot::Object* p_ref) {
-    p_ref->free_instance_binding(&GDKotlin::get_instance());
+void JvmBindingManager::free_binding(godot::Object* p_ref) {
+    p_ref->free_instance_binding(&GodotJvm::get_instance());
 }

src/core/kotlin_binding_manager.h renamed to src/core/jvm_binding_manager.h

@@ -1,16 +1,17 @@
-#ifndef GODOT_JVM_KOTLIN_BINDING_MANAGER_H
-#define GODOT_JVM_KOTLIN_BINDING_MANAGER_H
+#ifndef GODOT_JVM_JVM_BINDING_MANAGER_H
+#define GODOT_JVM_JVM_BINDING_MANAGER_H
+
+#include "jvm_binding.h"
 
 #include <gdextension_interface.h>
-#include <classes/object.hpp>
-#include "kotlin_binding.h"
 
+#include <classes/object.hpp>
 #include <cstdint>
 
-class KotlinBindingManager {
-    KotlinBindingManager() = default;
+class JvmBindingManager {
+    JvmBindingManager() = default;
 
-    ~KotlinBindingManager() = default;
+    ~JvmBindingManager() = default;
 
     // Callbacks required by Godot for instance bindings.
     static GDExtensionInstanceBindingCallbacks _instance_binding_callbacks;
@@ -20,17 +21,17 @@ class KotlinBindingManager {
     static void _instance_binding_free_callback(void* p_token, void* p_instance, void* p_binding);
 
 public:
-    KotlinBindingManager(KotlinBindingManager const& other) = delete;
+    JvmBindingManager(JvmBindingManager const& other) = delete;
 
-    KotlinBindingManager& operator=(const KotlinBindingManager&) = delete;
+    JvmBindingManager& operator=(const JvmBindingManager&) = delete;
 
     // For instance bindings, they are to bind native Godot objects to their JVM wrappers, not for the scripts.
-    static KotlinBinding* set_instance_binding(godot::Object* p_object);
+    static JvmBinding* set_instance_binding(godot::Object* p_object);
 
     // Doesn't set the KtObject as it doesn't exist yet, bind_object has be used later.
-    static KotlinBinding* get_instance_binding(godot::Object* p_object);
+    static JvmBinding* get_instance_binding(godot::Object* p_object);
 
     static void free_binding(godot::Object* p_ref);
 };
 
-#endif// GODOT_JVM_KOTLIN_BINDING_MANAGER_H
+#endif // GODOT_JVM_JVM_BINDING_MANAGER_H

src/editor/export/kotlin_editor_export_plugin.cpp

@@ -2,11 +2,11 @@
 
 #include "kotlin_editor_export_plugin.h"
 
-#include "gd_kotlin.h"
 #include "api/language/names.h"
+#include "api/script/jvm_script_manager.h"
+#include "godot_jvm.h"
 #include "lifecycle/jvm_user_configuration.h"
 #include "lifecycle/paths.h"
-#include "api/script/jvm_script_manager.h"
 
 #include <core/config/project_settings.hpp>
 
@@ -124,7 +124,7 @@ void KotlinEditorExportPlugin::_export_begin(const HashSet<String>& p_features,
 
         // add Godot Kotlin/JVM configuration file based on export targets
         if (export_all) {
-            _generate_export_configuration_file(GDKotlin::get_instance().get_configuration().vm_type);
+            _generate_export_configuration_file(GodotJvm::get_instance().get_configuration().vm_type);
         } else if (export_jvm) {
             _generate_export_configuration_file(jni::JvmType::JVM);
         } else if (export_graal) {
@@ -163,7 +163,7 @@ void KotlinEditorExportPlugin::_export_begin(const HashSet<String>& p_features,
 }
 
 void KotlinEditorExportPlugin::_generate_export_configuration_file(jni::JvmType vm_type) {
-    JvmUserConfiguration configuration = GDKotlin::get_instance().get_configuration(); // Copy
+    JvmUserConfiguration configuration = GodotJvm::get_instance().get_configuration(); // Copy
     configuration.vm_type = vm_type; // We only need to change the vm type
 
     const char32_t* json_string {JvmUserConfiguration::export_configuration_to_json(configuration).get_data()};

src/editor/godot_kotlin_jvm_editor.cpp

@@ -1,14 +1,14 @@
 #include "godot_kotlin_jvm_editor.h"
 
 #include "editor/build/build_manager.h"
+#include "godot_jvm.h"
 #include "lifecycle/paths.h"
 #include "project/project_generator.h"
 #include "strings.h"
 
 #include <core/config/project_settings.hpp>
 #include <editor/editor_interface.hpp>
 #include <editor/filesystem_dock.hpp>
-#include "gd_kotlin.h"
 
 void GodotKotlinJvmEditor::on_menu_option_pressed(int option_id) {
     switch (option_id) {
@@ -38,13 +38,13 @@ void GodotKotlinJvmEditor::on_build_finished() {
 }
 
 void GodotKotlinJvmEditor::on_filesystem_change() {
-    if (GDKotlin::get_instance().state == GDKotlin::State::JVM_SCRIPTS_INITIALIZED) { return; }
+    if (GodotJvm::get_instance().state == GodotJvm::State::JVM_SCRIPTS_INITIALIZED) { return; }
 
     // We check for changes in the file system in case the main.jar has been added (not reloaded, just was not present when the editor started)
-    if (GDKotlin::get_instance().state == GDKotlin::State::JVM_STARTED) {
+    if (GodotJvm::get_instance().state == GodotJvm::State::JVM_STARTED) {
         String bootstrap {String(RES_DIRECTORY).path_join(BOOTSTRAP_FILE)};
         if (FileAccess::exists(bootstrap)) {
-            GDKotlin::get_instance().initialize_up_to(GDKotlin::State::JVM_SCRIPTS_INITIALIZED);
+            GodotJvm::get_instance().initialize_up_to(GodotJvm::State::JVM_SCRIPTS_INITIALIZED);
         }
     }
 }