重新封装二进制文件读取

Editor/src/Editor/EditorLayer.cpp

@@ -320,7 +320,7 @@ namespace Hazel
 
 		    	static float fpsRefreshTime = 0.0f;
 		    	static float displayedFPS = 0;
-		    	float currentTime = ImGui::GetTime();
+		    	float currentTime = static_cast<float>(ImGui::GetTime());
 
 		    	// 每秒更新一次要显示的FPS
 		    	if (currentTime - fpsRefreshTime >= 1.0f)

Hazel/src/Hazel/Core/Buffer.h

@@ -0,0 +1,103 @@
+//
+// Created by sfd on 25-10-26.
+//
+
+#ifndef BUFFER_H
+#define BUFFER_H
+#include <cstdint>
+
+namespace Hazel
+{
+    struct Buffer
+    {
+        uint8_t* Data = nullptr;
+        uint64_t Size = 0;
+
+        Buffer() = default;
+
+        Buffer(const uint64_t size)
+        {
+            Allocate(size);
+        }
+
+        Buffer(const Buffer&) = default;
+
+        static Buffer Copy(const Buffer other)
+        {
+            const Buffer result(other.Size);
+            memcpy(result.Data, other.Data, other.Size);
+            return result;
+        }
+
+        void Allocate(uint64_t size)
+        {
+            Release();
+
+            Data = new uint8_t[size];
+            Size = size;
+        }
+
+        void Release()
+        {
+            if (Data != nullptr)
+                delete[] Data;
+            Data = nullptr;
+            Size = 0;
+        }
+
+        template<typename T>
+        T* As()
+        {
+            return reinterpret_cast<T*>(Data);
+        }
+
+        explicit operator bool() const
+        {
+            return static_cast<bool>(Data);
+        }
+    };
+
+    struct ScopedBuffer
+    {
+        ScopedBuffer(Buffer buffer)
+            : m_Buffer(buffer)
+        {
+        }
+
+        ScopedBuffer(uint64_t size)
+            : m_Buffer(size)
+        {
+        }
+
+        ~ScopedBuffer()
+        {
+            m_Buffer.Release();
+        }
+
+        uint8_t* Data() const
+        {
+            return m_Buffer.Data;
+        }
+
+        uint64_t Size() const
+        {
+            return m_Buffer.Size;
+        }
+
+        template<typename T>
+        T* As()
+        {
+            return m_Buffer.As<T>();
+        }
+
+        explicit operator bool() const
+        {
+            return static_cast<bool>(m_Buffer);
+        }
+
+    private:
+        Buffer m_Buffer;
+    };
+}
+
+#endif //BUFFER_H

Hazel/src/Hazel/Core/FileSystem.cpp

@@ -0,0 +1,39 @@
+//
+// Created by sfd on 25-10-26.
+//
+
+#include "FileSystem.h"
+
+#include <fstream>
+
+#include "Log.h"
+
+namespace Hazel
+{
+    Buffer FileSystem::ReadFileBinary(const std::filesystem::path& filePath)
+    {
+        std::ifstream file(filePath, std::ios::binary | std::ios::ate);
+
+        if (!file)
+        {
+            HZ_CORE_WARN("could not open file '{0}'", filePath.string());
+            return {};
+        }
+
+        std::streampos end = file.tellg();
+        file.seekg(0, std::ios::beg);
+        uint64_t size = end - file.tellg();
+
+        if (size == 0)
+        {
+            HZ_CORE_WARN("file is empty");
+            return {};
+        }
+
+        Buffer buffer(size);
+        file.read(buffer.As<char>(), size);
+        file.close();
+        return buffer;
+    }
+
+}

Hazel/src/Hazel/Core/FileSystem.h

@@ -0,0 +1,22 @@
+//
+// Created by sfd on 25-10-26.
+//
+
+#ifndef FILESYSTEM_H
+#define FILESYSTEM_H
+#include <filesystem>
+
+#include "Buffer.h"
+#include "Core.h"
+
+
+namespace Hazel
+{
+    class HAZEL_API FileSystem
+    {
+    public:
+        static Buffer ReadFileBinary(const std::filesystem::path& filePath);
+    };
+}
+
+#endif //FILESYSTEM_H

Hazel/src/Hazel/Scene/SceneSerializer.cpp

@@ -148,6 +148,18 @@ namespace YAML
 
 namespace Hazel
 {
+#define WRITE_FIELD_TYPE(FieldType, Type)                                               \
+                        case ScriptFieldType::FieldType:                                \
+                            out << scriptField.GetValue<Type>();break
+
+
+#define READ_FIELD_TYPE(FieldType, Type)                                                \
+                        case ScriptFieldType::FieldType:                                \
+                        {                                                               \
+                            Type valueData = scriptField["Data"].as<Type>();            \
+                            fieldInstance.SetValue(valueData);                          \
+                            break;                                                      \
+                        }
 
 
 
@@ -252,9 +264,7 @@ namespace Hazel
                     out << YAML::Key << "Data" << YAML::Value;
 
                     ScriptFieldInstance& scriptField = entityFields.at(name);
-#define WRITE_FIELD_TYPE(FieldType, Type) case ScriptFieldType::FieldType:\
+
-                                         out << scriptField.GetValue<Type>();\
-                                         break
 
                     switch (field.Type)
                     {
@@ -279,7 +289,6 @@ namespace Hazel
                     }
 
                     out << YAML::EndMap;
-#undef WRITE_FIELD_TYPE
                 }
                 out << YAML::EndSeq;
 
@@ -483,6 +492,8 @@ namespace Hazel
                     if (scriptFields)
                     {
                         Ref<ScriptClass> entityClass = ScriptEngine::GetEntityClass(sc.ClassName);
+                        if (entityClass)
+                        {
                             const auto& fields = entityClass->GetFields();
                             auto& entityFields = ScriptEngine::GetScriptFieldMap(deserializedEntity);
 
@@ -496,14 +507,6 @@ namespace Hazel
                                 fieldInstance.Field = fields.at(name);
 
 
-#define READ_FIELD_TYPE(FieldType, Type)                                                \
-                        case ScriptFieldType::FieldType:                                \
-                        {                                                               \
-                            Type valueData = scriptField["Data"].as<Type>();           \
-                            fieldInstance.SetValue(valueData);                          \
-                            break;                                                      \
-                        }
-
 
                                 switch (type)
                                 {
@@ -526,8 +529,7 @@ namespace Hazel
 
                                     READ_FIELD_TYPE(Entity,     UUID);
                                 }
-
+                            }
-#undef READ_FIELD_TYPE
                         }
                     }
                 }

Hazel/src/Hazel/Scripting/ScriptEngine.cpp

@@ -10,9 +10,13 @@
 #include "FileWatch.h"
 #include "ScriptGlue.h"
 #include "Hazel/Core/Application.h"
+#include "Hazel/Core/Buffer.h"
+#include "Hazel/Core/FileSystem.h"
 #include "mono/jit/jit.h"
 #include "mono/metadata/assembly.h"
 #include "mono/metadata/attrdefs.h"
+#include "mono/metadata/mono-debug.h"
+#include "mono/metadata/threads.h"
 
 namespace Hazel
 {
@@ -44,6 +48,7 @@ namespace Hazel
     namespace Utils
     {   
 
+        /*
         char* ReadBytes(const std::filesystem::path& filePath, uint32_t* outSize)
         {
             std::ifstream stream(filePath, std::ios::binary | std::ios::ate);
@@ -71,16 +76,15 @@ namespace Hazel
             *outSize = (uint32_t)size;
             return buffer;
         }
+        */
 
-        MonoAssembly* LoadMonoAssembly(const std::filesystem::path& assemblyPath)
+        MonoAssembly* LoadMonoAssembly(const std::filesystem::path& assemblyPath, bool loadPDB = false)
         {
             HZ_CORE_DEBUG("Load Assemble: {0}", assemblyPath.string().c_str());
-            uint32_t fileSize = 0;
+            ScopedBuffer fileData = FileSystem::ReadFileBinary(assemblyPath);
-
-            char* fileData = ReadBytes(assemblyPath, &fileSize);
 
             MonoImageOpenStatus status;
-            MonoImage*          image = mono_image_open_from_data_full(fileData, fileSize, 1, &status, 0);
+            MonoImage*          image = mono_image_open_from_data_full(fileData.As<char>(), fileData.Size(), 1, &status, 0);
             if (status != MONO_IMAGE_OK)
             {
                 const char* errorMessage = mono_image_strerror(status);
@@ -88,12 +92,25 @@ namespace Hazel
                 return nullptr;
             }
 
+            if (loadPDB)
+            {
+                HZ_CORE_INFO("loading pdb file...");
+                std::filesystem::path pdbPath(assemblyPath);
+                pdbPath.replace_extension(".pdb");
+
+                if (std::filesystem::exists(pdbPath))
+                {
+                    ScopedBuffer pdbFileData = FileSystem::ReadFileBinary(pdbPath);
+                    mono_debug_open_image_from_memory(image, pdbFileData.As<mono_byte>(), fileData.Size());
+                    HZ_CORE_INFO("loaded pdb file: {0}", pdbPath.string());
+                    HZ_CORE_INFO("  size: {0}", pdbFileData.Size());
+                }
+            }
+
             std::string   string   = assemblyPath.string();
             MonoAssembly* assembly = mono_assembly_load_from_full(image, string.c_str(), &status, 0);
             mono_image_close(image);
 
-            delete[] fileData;
-
             return assembly;
         }
 
@@ -152,6 +169,9 @@ namespace Hazel
         Scope<filewatch::FileWatch<std::string>> AppAssemblyFileWatcher;
         bool AssemblyReloading = false;
 
+        // Mono C# debug
+        bool EnableDebugging = true;
+
         // runtime
         Scene* SceneContext = nullptr;
     };
@@ -177,8 +197,20 @@ namespace Hazel
         InitMono();
         ScriptGlue::RegisterFunctions();
 
-        LoadAssemble("Resources/Scripts/Hazel-ScriptCore.dll");
+        bool status = LoadAssemble("Resources/Scripts/Hazel-ScriptCore.dll");
-        LoadAppAssemble("Resources/Scripts/Sandbox.dll");
+        if (!status)
+        {
+            HZ_CORE_ERROR("[ScriptEngine] Could not load Hazel-ScriptCore assembly.");
+            return;
+        }
+
+        status = LoadAppAssemble("Resources/Scripts/Sandbox.dll");
+        if (!status)
+        {
+            HZ_CORE_ERROR("[ScriptEngine] Could not load app assembly.");
+            return;
+        }
+
         LoadAssemblyClass();
         Utils::PrintAssemblyTypes(s_Data->CoreAssembly);
         ScriptGlue::RegisterComponents();
@@ -226,32 +258,36 @@ namespace Hazel
         delete s_Data;
     }
 
-    void ScriptEngine::LoadAssemble(const std::filesystem::path& assemblePath)
+    bool ScriptEngine::LoadAssemble(const std::filesystem::path& assemblePath)
     {
         // Create an Domain App
         char monoDomainName[] = "HazelScriptRuntime";
         s_Data->AppDomain     = mono_domain_create_appdomain(monoDomainName, nullptr);
         mono_domain_set(s_Data->AppDomain, true);
 
-        // TODO: move this later
         s_Data->CoreAssemblyFilePath = assemblePath;
-        s_Data->CoreAssembly      = Utils::LoadMonoAssembly(assemblePath);
+        s_Data->CoreAssembly      = Utils::LoadMonoAssembly(assemblePath, s_Data->EnableDebugging);
-        s_Data->CoreAssemblyImage = mono_assembly_get_image(s_Data->CoreAssembly);
+        if (s_Data->CoreAssembly == nullptr)
+            return false;
 
-        // Utils::PrintAssemblyTypes(s_Data->CoreAssembly);
+        s_Data->CoreAssemblyImage = mono_assembly_get_image(s_Data->CoreAssembly);
+        return true;
     }
 
-    void ScriptEngine::LoadAppAssemble(const std::filesystem::path& assemblePath)
+    bool ScriptEngine::LoadAppAssemble(const std::filesystem::path& assemblePath)
     {
         // TODO: move this later
         s_Data->AppAssemblyFilePath = assemblePath;
-        s_Data->AppAssembly      = Utils::LoadMonoAssembly(assemblePath);
+        s_Data->AppAssembly      = Utils::LoadMonoAssembly(assemblePath, s_Data->EnableDebugging);
+        if (s_Data->AppAssembly == nullptr)
+            return false;
+
         s_Data->AppAssemblyImage = mono_assembly_get_image(s_Data->AppAssembly);
 
         s_Data->AppAssemblyFileWatcher = CreateScope<filewatch::FileWatch<std::string>>(assemblePath.string(), OnAssemblyFileSystemEvent);
-        auto& b = s_Data;
         s_Data->AssemblyReloading = false;
-        // Utils::PrintAssemblyTypes(s_Data->CoreAssembly);
+
+        return true;
     }
 
     void ScriptEngine::ReloadAssemble()
@@ -379,8 +415,7 @@ namespace Hazel
         UUID entityUUID = entity.GetUUID();
         if (!s_Data->EntityInstances.contains(entityUUID))
         {
-            HZ_CORE_FATAL("script cannot get");
+            HZ_CORE_ERROR("Could not find ScriptInstance for entity {}",  (uint64_t)entityUUID);
-            assert(1);
         }
 
         const Ref<ScriptInstance> instance = s_Data->EntityInstances[entityUUID];
@@ -408,6 +443,18 @@ namespace Hazel
         mono_set_dirs("Resources", "Resources");
         mono_set_assemblies_path("Resources/mono");
 
+        if (s_Data->EnableDebugging)
+        {
+            const char* argv[2]
+            {
+                "--debugger-agent=transport=dt_socket,address=127.0.0.1:2550,server=y,suspend=n,loglevel=3,logfile=MonoDebugger.log",
+                "--soft-breakpoints"
+            };
+
+            mono_jit_parse_options(2, (char**)argv);
+            mono_debug_init(MONO_DEBUG_FORMAT_MONO);
+        }
+
         MonoDomain* rootDomain = mono_jit_init("HazelJITRuntime");
 
         const char* monoPath = mono_assembly_getrootdir();
@@ -419,6 +466,11 @@ namespace Hazel
         }
         // Storage the root Domain ptr
         s_Data->RootDomain = rootDomain;
+
+        if (s_Data->EnableDebugging)
+            mono_debug_domain_create(s_Data->RootDomain);
+
+        mono_thread_set_main(mono_thread_current());
     }
 
     void ScriptEngine::MonoShutdown()
@@ -468,7 +520,8 @@ namespace Hazel
 
     MonoObject* ScriptClass::InvokeMethod(MonoObject* instance, MonoMethod* method, void** param)
     {
-        return mono_runtime_invoke(method, instance, param, nullptr);
+        MonoObject* expection = nullptr;
+        return mono_runtime_invoke(method, instance, param, &expection);
     }
 
 

Hazel/src/Hazel/Scripting/ScriptEngine.h

@@ -145,8 +145,8 @@ namespace Hazel
         static void Init();
         static void Shutdown();
 
-        static void LoadAssemble(const std::filesystem::path& assemblePath);
+        static bool LoadAssemble(const std::filesystem::path& assemblePath);
-        static void LoadAppAssemble(const std::filesystem::path& assemblePath);
+        static bool LoadAppAssemble(const std::filesystem::path& assemblePath);
 
         static void ReloadAssemble();