feat: Improved hot reloading

Improved hot reloading of scripts by notifying the editor of property changes.
Improved "Global Class" loading by having the generator keep a list of global classes.
Added a "hot reload" button specifically to assist in pushing global classes into the editor.

Author: fuzzybinary

src/assets/godot_dart.gdextension

@@ -5,7 +5,8 @@ compatibility_minimum = 4.2
 
 [icons]
 
-DartScript = "res://logo_dart.svg"
+DartScript = "res://godot_dart/logo_dart.svg"
+DartHotReload = "res://godot_dart/hot_reload.svg"
 
 [libraries]
 

src/assets/logo_dart.svg renamed to src/assets/godot_dart/logo_dart.svg

@@ -8,10 +8,10 @@ environment:
 
 dependencies:
   ffi: ^2.0.1
-  godot_dart: ^0.3.0    
+  godot_dart: ^0.4.0    
   collection: ^1.17.2
 
 dev_dependencies:
   lints: ^2.0.0
   build_runner: ^2.3.3
-  godot_dart_build: ^0.2.0 
+  godot_dart_build: ^0.3.0 

src/assets/src/pubspec.yaml

@@ -19,8 +19,8 @@ add_library(godot_dart SHARED
     dart_instance_binding.cpp
     dart_instance_binding.h
     dart_helpers.h
-    dart_script_instance.cpp
-    dart_script_instance.h
+    "script/dart_script_instance.cpp"
+    "script/dart_script_instance.h"
     gde_c_interface.cpp
     gde_c_interface.h
     gde_dart_converters.cpp
@@ -46,13 +46,14 @@ add_library(godot_dart SHARED
     script/dart_script.cpp
     script/dart_resource_format.h
     script/dart_resource_format.cpp
-)
+ )
 
 target_include_directories(godot_dart PUBLIC
     "${GODOT_CPP_DIR}/include"
     "${GODOT_CPP_DIR}/gen/include"
     "${GODOT_CPP_DIR}/gdextension"
     "${DART_DIR}/include"
+    "${PROJECT_SOURCE_DIR}"
 )
 
 set(DART_DLL_NAMES    

src/cpp/CMakeLists.txt

@@ -10,18 +10,17 @@
 #include <dart_tools_api.h>
 
 #include <gdextension_interface.h>
-#include <godot_cpp/variant/string.hpp>
-#include <godot_cpp/variant/string_name.hpp>
 #include <godot_cpp/classes/editor_file_system.hpp>
 #include <godot_cpp/classes/editor_interface.hpp>
-
+#include <godot_cpp/variant/string.hpp>
+#include <godot_cpp/variant/string_name.hpp>
 
 #include "dart_helpers.h"
 #include "dart_instance_binding.h"
-#include "dart_script_instance.h"
 #include "gde_dart_converters.h"
 #include "gde_wrapper.h"
 #include "ref_counted_wrapper.h"
+#include "script/dart_script_instance.h"
 #include "script/dart_script_language.h"
 
 // Forward declarations for Dart callbacks and helpers
@@ -143,8 +142,8 @@ bool GodotDartBindings::initialize(const char *script_path, const char *package_
       Dart_Handle print = Dart_Invoke(godot_dart_library, Dart_NewStringFromCString("_getPrintClosure"), 0, NULL);
       Dart_Handle result = Dart_SetField(internal_lib, Dart_NewStringFromCString("_printClosure"), print);
       if (Dart_IsError(result)) {
-        GD_PRINT_WARNING("GodotDart: Error setting print closure");
-        GD_PRINT_WARNING(Dart_GetError(result));
+        GD_PRINT_ERROR("GodotDart: Error setting print closure");
+        GD_PRINT_ERROR(Dart_GetError(result));
       }
     }
 
@@ -175,21 +174,6 @@ bool GodotDartBindings::initialize(const char *script_path, const char *package_
   return true;
 }
 
-void GodotDartBindings::add_pending_reload(const godot::String &path) {
-  _pending_reloads.insert(path);
-  reload_code();
-}
-
-void GodotDartBindings::perform_pending_reloads() {
-  for (const auto &str : _pending_reloads) {
-    auto editor_interface = godot::EditorInterface::get_singleton();
-    if (editor_interface) {
-      editor_interface->get_resource_filesystem()->update_file(str);
-    }
-  }
-  _pending_reloads.clear();
-}
-
 void GodotDartBindings::reload_code() {
   if (_is_reloading) {
     return;
@@ -283,10 +267,11 @@ void GodotDartBindings::perform_frame_maintanance() {
     // If we're reloading, check to see if we're done.
     if (_is_reloading) {
       Dart_Handle root_library = Dart_HandleFromPersistent(_godot_dart_library);
-      DART_CHECK(dart_is_reloading, Dart_GetField(root_library, Dart_NewStringFromCString("_isReloading")), "Failed to get _isReloading");
+      DART_CHECK(dart_is_reloading, Dart_GetField(root_library, Dart_NewStringFromCString("_isReloading")),
+                 "Failed to get _isReloading");
       Dart_BooleanValue(dart_is_reloading, &_is_reloading);
       if (!_is_reloading) {
-        perform_pending_reloads();
+        DartScriptLanguage::instance()->did_finish_hot_reload();
       }
     }
 
@@ -318,28 +303,6 @@ void GodotDartBindings::perform_pending_ref_changes() {
   _pending_ref_changes.clear();
 }
 
-void *GodotDartBindings::create_script_instance(Dart_Handle type, const DartScript *script, void *godot_object,
-                                                bool is_placeholder, bool is_refcounted) {
-  GDExtensionScriptInstancePtr godot_script_instance = nullptr;
-
-  execute_on_dart_thread([&] {
-    DartBlockScope scope;
-
-    Dart_Handle dart_pointer = new_dart_void_pointer(godot_object);
-    Dart_Handle args[1] = {dart_pointer};
-    DART_CHECK_RET(dart_object, Dart_New(type, Dart_NewStringFromCString("withNonNullOwner"), 1, args), nullptr,
-                   "Error creating bindings");
-
-    DartScriptInstance *script_instance = new DartScriptInstance(dart_object, const_cast<DartScript *>(script),
-                                                                 godot_object, is_placeholder, is_refcounted);
-    godot_script_instance =
-        gde_script_instance_create2(DartScriptInstance::get_script_instance_info(),
-                                    reinterpret_cast<GDExtensionScriptInstanceDataPtr>(script_instance));
-  });
-
-  return godot_script_instance;
-}
-
 void GodotDartBindings::bind_method(const TypeInfo &bind_type, const char *method_name, const TypeInfo &ret_type_info,
                                     Dart_Handle args_list, MethodFlags method_flags) {
   MethodInfo *info = new MethodInfo();
@@ -700,8 +663,7 @@ void dart_print(Dart_NativeArguments args) {
   Dart_Handle arg = Dart_GetNativeArgument(args, 1);
   DART_CHECK(result, Dart_StringToCString(arg, &cstring), "Error getting printable string.");
 
-  // TODO - Find a nice way to log
-  GD_PRINT_WARNING(cstring);
+  __print_verbose(cstring);
 }
 
 void bind_class(Dart_NativeArguments args) {

src/cpp/dart_bindings.cpp

@@ -9,19 +9,20 @@
 
 #include <dart_api.h>
 #include <gdextension_interface.h>
+#include <godot_cpp/classes/ref.hpp>
 #include <godot_cpp/variant/string.hpp>
+#include <godot_cpp/classes/wrapped.hpp>
 
 #include "dart_instance_binding.h"
 #include "gde_dart_converters.h"
+#include "script/dart_script.h"
 
 enum class MethodFlags : int32_t {
   None,
   PropertyGetter,
   PropertySetter,
 };
 
-class DartScript;
-
 class GodotDartBindings {
 public:
   static GodotDartBindings *instance() {
@@ -38,8 +39,7 @@ class GodotDartBindings {
     return _fully_initialized;
   }
   void shutdown();
-
-  void add_pending_reload(const godot::String& path);
+  
   void reload_code();
 
   void bind_method(const TypeInfo &bind_type, const char *method_name, const TypeInfo &ret_type_info,
@@ -53,17 +53,14 @@ class GodotDartBindings {
   void remove_pending_ref_change(DartGodotInstanceBinding *bindings);
   void perform_pending_ref_changes();
 
-  void *create_script_instance(Dart_Handle type, const DartScript *script, void *godot_object, bool is_placeholder,
-                               bool is_refcounted);
-
   static GDExtensionObjectPtr class_create_instance(void *p_userdata);
   static void class_free_instance(void *p_userdata, GDExtensionClassInstancePtr p_instance);
   static void *get_virtual_call_data(void *p_userdata, GDExtensionConstStringNamePtr p_name);
   static void call_virtual_func(void *p_instance, GDExtensionConstStringNamePtr p_name, void *p_userdata,
                                 const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret);
 
 private:
-  void perform_pending_reloads();
+  void did_finish_hot_reload();
 
   static void bind_call(void *method_userdata, GDExtensionClassInstancePtr instance,
                         const GDExtensionConstVariantPtr *args, GDExtensionInt argument_count,
@@ -74,14 +71,14 @@ class GodotDartBindings {
   static GodotDartBindings *_instance;
 
 public:
-  bool _fully_initialized;  
+  bool _fully_initialized;
   bool _is_stopping;
   bool _is_reloading;
   int32_t _pending_messages;
   std::mutex _work_lock;
   Dart_Isolate _isolate;
   std::thread::id _isolate_current_thread;
-  std::set<godot::String> _pending_reloads;
+  std::set<godot::Ref<DartScript>> _pending_reloads;
   std::set<DartGodotInstanceBinding *> _pending_ref_changes;
 
   Dart_PersistentHandle _godot_dart_library;

src/cpp/dart_bindings.h

@@ -3,13 +3,31 @@
 #include <dart_api.h>
 
 #include "gde_c_interface.h"
+#include <godot_cpp/classes/os.hpp>
+#include <godot_cpp/variant/utility_functions.hpp>
+
+inline bool is_print_verbose_enabled() {
+  auto os_singleton = godot::OS::get_singleton();
+  if (os_singleton && os_singleton->is_stdout_verbose()) return true;
+  return false;
+}
+
+inline void __print_verbose(const char *msg) {
+  if (is_print_verbose_enabled()) {
+    godot::String godot_msg(msg);
+    godot::UtilityFunctions::print(msg);
+  }
+}
 
 #define GD_PRINT_ERROR(msg)                                                                                            \
   { gde_print_error(msg, __func__, __FILE__, __LINE__, true); }
 
 #define GD_PRINT_WARNING(msg)                                                                                          \
   { gde_print_warning(msg, __func__, __FILE__, __LINE__, true); }
 
+#define GD_PRINT_VERBOSE(msg)                                                                                          \
+  { __print_verbose(msg); }
+
 #define DART_CHECK_RET(var, expr, ret, message)                                                                        \
   Dart_Handle var = (expr);                                                                                            \
   if (Dart_IsError(var)) {                                                                                             \

src/cpp/dart_helpers.h

@@ -2,12 +2,15 @@
 
 #include <sstream>
 
+#include <godot_cpp/classes/button.hpp>
 #include <godot_cpp/classes/confirmation_dialog.hpp>
 #include <godot_cpp/classes/dir_access.hpp>
+#include <godot_cpp/classes/editor_interface.hpp>
 #include <godot_cpp/classes/file_access.hpp>
 #include <godot_cpp/classes/os.hpp>
 #include <godot_cpp/classes/popup.hpp>
 #include <godot_cpp/classes/thread.hpp>
+#include <godot_cpp/classes/theme.hpp>
 #include <godot_cpp/core/class_db.hpp>
 
 #include "../dart_helpers.h"
@@ -18,7 +21,7 @@
 
 using namespace godot;
 
-GodotDartEditorPlugin::GodotDartEditorPlugin() {
+GodotDartEditorPlugin::GodotDartEditorPlugin() : _reload_button(nullptr) {
   _progress_dialog = memnew(DartProgressDialog);
   add_child(_progress_dialog);
 }
@@ -27,16 +30,16 @@ GodotDartEditorPlugin::~GodotDartEditorPlugin() {
 }
 
 void GodotDartEditorPlugin::_bind_methods() {
-
   ClassDB::bind_method(godot::D_METHOD("confirm_create_project"), &GodotDartEditorPlugin::confirm_create_project);
   ClassDB::bind_method(godot::D_METHOD("confirm_pub_get"), &GodotDartEditorPlugin::confirm_pub_get);
   ClassDB::bind_method(godot::D_METHOD("run_work"), &GodotDartEditorPlugin::run_work);
+  ClassDB::bind_method(godot::D_METHOD("dart_hot_reload"), &GodotDartEditorPlugin::hot_reload);
 }
 
 void GodotDartEditorPlugin::_enter_tree() {
   GodotDartRuntimePlugin *runtime_plugin = GodotDartRuntimePlugin::get_instance();
   if (!runtime_plugin) {
-    GD_PRINT_ERROR("godot_dart was loaded bug didn't initialize!")
+    GD_PRINT_ERROR("godot_dart was loaded but didn't initialize!")
     return;
   }
 
@@ -45,9 +48,27 @@ void GodotDartEditorPlugin::_enter_tree() {
   } else if (!runtime_plugin->has_package_config()) {
     show_pub_get_dialog();
   }
+
+  _reload_button = memnew(Button);
+  _reload_button->set_flat(false);
+  auto icon =
+      EditorInterface::get_singleton()->get_editor_theme()->get_icon(StringName("Reload"), StringName("EditorIcons"));
+  _reload_button->set_button_icon(icon);
+  _reload_button->set_focus_mode(Control::FOCUS_NONE);
+  _reload_button->set_theme_type_variation(StringName("RunBarButton"));
+  _reload_button->set_tooltip_text(String("Perform a Dart Hot Reload"));
+
+  
+  _reload_button->connect(StringName("pressed"), Callable(this, StringName("dart_hot_reload")));
+  add_control_to_container(EditorPlugin::CONTAINER_TOOLBAR, _reload_button);
+  auto parent = _reload_button->get_parent();
+  int num_buttons = parent->get_child_count();
+  // Move over next to run buttons
+  _reload_button->get_parent()->move_child(_reload_button, num_buttons - 2);
 }
 
 void GodotDartEditorPlugin::_exit_tree() {
+
 }
 
 void GodotDartEditorPlugin::show_create_project_dialog() {
@@ -213,6 +234,10 @@ bool GodotDartEditorPlugin::run_pub_get() {
   return true;
 }
 
+void GodotDartEditorPlugin::hot_reload() {
+  GodotDartBindings::instance()->reload_code();
+}
+
 bool GodotDartEditorPlugin::run_build_runner() {
   GodotDartRuntimePlugin *rtplugin = GodotDartRuntimePlugin::get_instance();
 

src/cpp/editor/godot_dart_editor_plugin.cpp

@@ -39,14 +39,13 @@ class GodotDartEditorPlugin : public godot::EditorPlugin {
   void show_pub_get_dialog();
   void confirm_pub_get();
 
-  // Reload dialog
-  void show_reload_dialog();
-  void confirm_reload();
+  void hot_reload();  
 
   void run_work();
 
   std::vector<WorkStep> _work_steps;
 
   DartProgressDialog *_progress_dialog;
   godot::Ref<godot::Thread> _plugin_work_thread;
+  godot::Button* _reload_button;
 };

src/cpp/editor/godot_dart_editor_plugin.h

@@ -10,8 +10,8 @@
 #include "godot_dart_runtime_plugin.h"
 
 #include "dart_instance_binding.h"
-#include "dart_script_instance.h"
 #include "ref_counted_wrapper.h"
+#include "script/dart_script_instance.h"
 
 #include "editor/godot_dart_editor_plugin.h"
 #include "editor/dart_progress_dialog.h"

src/cpp/godot_dart.cpp

@@ -10,11 +10,11 @@
 #include <godot_cpp/classes/object.hpp>
 
 #include "dart_helpers.h"
-#include "dart_script_instance.h"
 #include "gde_wrapper.h"
 #include "godot_string_wrappers.h"
 #include "ref_counted_wrapper.h"
 
+#include "script/dart_script_instance.h"
 #include "script/dart_script_language.h"
 #include "script/dart_resource_format.h"