atdunbg/Hazel
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

简单添加ScriptComponent序列化功能

Browse Source
This commit is contained in:
Atdunbg
2025-07-18 14:19:10 +08:00
parent e0bfdd9c4e
commit 1bdb1d240e
10 changed files with 326 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Editor/SandboxProject/Source/Camera.cs
View File

@ -8,7 +8,7 @@ namespace Sandbox {
// private TransformComponent m_Transform;
// private RigidBody2DComponent m_Rigidbody;
public float MoveSpeed;
/*
void OnCreate()
{
@ -23,7 +23,7 @@ namespace Sandbox {
{
// Console.WriteLine($"Player.OnUpdate: {ts}");
float speed = 1.0f;
float speed = MoveSpeed;
Vector3 velocity = Vector3.Zero;
if(Input.IsKeyDown(KeyCode.UP))

15
Editor/SandboxProject/Source/Player.cs
View File

@ -8,7 +8,8 @@ namespace Sandbox {
private TransformComponent m_Transform;
private RigidBody2DComponent m_Rigidbody;
public float Speed = 1.0f;
public float Force;
public float Time;
void OnCreate()
{
@ -20,9 +21,9 @@ namespace Sandbox {
void OnUpdate(float ts)
{
// Console.WriteLine($"Player.OnUpdate: {ts}");
Time += ts;
float speed = Speed;
float speed = Force;
Vector3 velocity = Vector3.Zero;
if(Input.IsKeyDown(KeyCode.W))
@ -36,14 +37,6 @@ namespace Sandbox {
velocity.X = 1.0f;
m_Rigidbody.ApplyLinearImpulseToCenter(velocity.XY * speed, true);
/*
velocity *= speed;
Vector3 translation = m_Transform.Translation;
translation += velocity * ts;
m_Transform.Translation = translation;
*/
}
}

85
Editor/src/Editor/Panels/SceneHierachyPanel.cpp
View File

@ -48,6 +48,7 @@ namespace Hazel
if (ImGui::MenuItem("Create Empty Entity"))
{
m_SelectionContext = m_Context->CreateEntity("Empty Entity");
m_LastSelectionContext = m_SelectionContext;
}
else if (ImGui::MenuItem("Create Camera"))
{
@ -61,9 +62,9 @@ namespace Hazel
}
ImGui::Begin("Properties");
if (m_SelectionContext)
if (m_LastSelectionContext)
{
DrawComponents(m_SelectionContext);
DrawComponents(m_LastSelectionContext);
}
ImGui::End();
}
@ -80,6 +81,7 @@ namespace Hazel
if (ImGui::IsItemClicked())
{
m_SelectionContext = entity;
m_LastSelectionContext = m_SelectionContext;
}
if (ImGui::BeginPopupContextItem())
@ -100,6 +102,7 @@ namespace Hazel
if (m_SelectionContext == entity)
{
m_SelectionContext = {};
m_LastSelectionContext = m_SelectionContext;
}
}
}
@ -358,40 +361,93 @@ namespace Hazel
}
});
DrawComponent<ScriptComponent>("Script", entity, [entity](auto& component) mutable
DrawComponent<ScriptComponent>("Script", entity, [entity, &scene = m_Context](auto& component) mutable
{
const bool scriptClassExists = ScriptEngine::ClassExists(component.ClassName);
bool scriptClassExists = ScriptEngine::ClassExists(component.ClassName);
bool setStyleFlag = false;
static char buffer[64] = {};
strcpy(buffer, component.ClassName.c_str());
if (!scriptClassExists)
{
ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.9f, 0.2f, 0.3f, 1.0f));
setStyleFlag = true;
}
if (ImGui::InputText("Script", buffer, sizeof(buffer)))
if (ImGui::InputText("Class", buffer, sizeof(buffer)))
{
component.ClassName = buffer;
scriptClassExists = ScriptEngine::ClassExists(component.ClassName);
}
// Fields
Ref<ScriptInstance> scriptInstance = ScriptEngine::GetEntityScriptInstance(entity.GetUUID());
if (scriptInstance)
const bool sceneRunning = scene->IsRunning();
if (sceneRunning)
{
const auto& fields = scriptInstance->GetScriptClass()->GetFields();
for (const auto&[name, field] : fields)
if (scriptInstance)
{
if (field.Type == ScriptFieldType::Float)
const auto& fields = scriptInstance->GetScriptClass()->GetFields();
for (const auto& [name, field] : fields)
{
float data = scriptInstance->GetFieldValue<float>(name);
if (ImGui::DragFloat(name.c_str(), &data))
if (field.Type == ScriptFieldType::Float)
{
scriptInstance->SetFieldValue(name, data);
float data = scriptInstance->GetFieldValue<float>(name);
if (ImGui::DragFloat(name.c_str(), &data))
{
scriptInstance->SetFieldValue(name, data);
}
}
}
}
}
else
{
if (scriptClassExists)
{
Ref<ScriptClass> entityClass = ScriptEngine::GetEntityClass(component.ClassName);
const auto& fields = entityClass->GetFields();
auto& entityFields = ScriptEngine::GetScriptFieldMap(entity);
if (!scriptClassExists)
for (const auto& [name, field] : fields)
{
// field has been set in Editor
if (entityFields.contains(name))
{
ScriptFieldInstance& scriptField = entityFields.at(name);
// display control to set
if (field.Type == ScriptFieldType::Float)
{
float data = scriptField.GetValue<float>();
if (ImGui::DragFloat(name.c_str(), &data))
scriptField.SetValue(data);
}
}
else
{
// display control to set
if (field.Type == ScriptFieldType::Float)
{
float data = 0.0f;
if (ImGui::DragFloat(name.c_str(), &data))
{
ScriptFieldInstance& fieldInstance = entityFields[name];
fieldInstance.Field = field;
fieldInstance.SetValue(data);
}
}
}
}
}
}
if (setStyleFlag)
ImGui::PopStyleColor();
});
@ -478,5 +534,6 @@ namespace Hazel
void SceneHierachyPanel::SetSelectedEntity(const Entity entity)
{
m_SelectionContext = entity;
m_LastSelectionContext = m_SelectionContext;
}
}

1
Editor/src/Editor/Panels/SceneHierachyPanel.h
View File

@ -33,6 +33,7 @@ namespace Hazel
Ref<Scene> m_Context;
Entity m_SelectionContext;
Entity m_LastSelectionContext;
};
}

4
Hazel/src/Hazel/Scene/Scene.cpp
View File

@ -242,6 +242,7 @@ namespace Hazel
void Scene::OnRuntimeStart()
{
m_IsRunning = true;
OnPhysics2DStart();
// scripts
@ -274,6 +275,7 @@ namespace Hazel
void Scene::OnRuntimeStop()
{
m_IsRunning = false;
OnPhysics2DStop();
// script
@ -293,7 +295,7 @@ namespace Hazel
}
//
m_Registry.view<NativeScriptComponent>().each([=](auto entity, auto& nsc)
m_Registry.view<NativeScriptComponent>().each([=, this](auto entity, auto& nsc)
{
// TODO: move to Scene::OnScenePlay
if (!nsc.Instance)

4
Hazel/src/Hazel/Scene/Scene.h
View File

@ -47,6 +47,8 @@ namespace Hazel
Entity GetPrimaryCameraEntity();
Entity GetEntityByUUID(UUID uuid);
bool IsRunning() const {return m_IsRunning; }
template<typename... Components>
auto GetAllEntitiesWith()
{
@ -69,6 +71,8 @@ namespace Hazel
b2WorldId* m_PhysicsWorld = nullptr;
bool m_IsRunning = false;
std::unordered_map<UUID, entt::entity> m_EnttMap;
friend class Entity;

129
Hazel/src/Hazel/Scene/SceneSerializer.cpp
View File

@ -8,10 +8,29 @@
#include "Components.h"
#include "Entity.h"
#include "Hazel/Scripting/ScriptEngine.h"
#include "yaml-cpp/yaml.h"
namespace YAML
{
template<>
struct convert<Hazel::UUID>
{
static Node encode(const Hazel::UUID& out)
{
Node node;
node.push_back((uint64_t)out);
return node;
}
static bool decode(const Node& node, Hazel::UUID& uuid)
{
uuid = node.as<uint64_t>();
return true;
}
};
template<>
struct convert<glm::vec2>
{
@ -208,6 +227,64 @@ namespace Hazel
out << YAML::BeginMap; // ScriptComponent
out << YAML::Key << "ClassName" << YAML::Value << scriptComponent.ClassName;
// fields
Ref<ScriptClass> entityClass = ScriptEngine::GetEntityClass(scriptComponent.ClassName);
const auto& fields = entityClass->GetFields();
if (fields.size() > 0)
{
auto& entityFields = ScriptEngine::GetScriptFieldMap(entity);
out << YAML::Key << "ScriptFields" << YAML::Value;
out << YAML::BeginSeq;
for (const auto& [name, field] : fields)
{
if (!entityFields.contains(name))
continue;
// - Name: FieldName
// Type: Int
// Data: 5
out << YAML::BeginMap; // Script Field
out << YAML::Key << "Name" << YAML::Value << name;
out << YAML::Key << "Type" << YAML::Value << Utils::ScriptFieldTypeToString(field.Type);
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)
{
WRITE_FIELD_TYPE(Float, float);
WRITE_FIELD_TYPE(Double, double);
WRITE_FIELD_TYPE(Boolean, bool);
WRITE_FIELD_TYPE(Char, char);
WRITE_FIELD_TYPE(Byte, int8_t);
WRITE_FIELD_TYPE(Short, int16_t);
WRITE_FIELD_TYPE(Int, int32_t);
WRITE_FIELD_TYPE(Long, int64_t);
WRITE_FIELD_TYPE(UByte, uint8_t);
WRITE_FIELD_TYPE(UShort, uint16_t);
WRITE_FIELD_TYPE(UInt, uint32_t);
WRITE_FIELD_TYPE(ULong, uint64_t);
WRITE_FIELD_TYPE(Vector2, glm::vec2);
WRITE_FIELD_TYPE(Vector3, glm::vec3);
WRITE_FIELD_TYPE(Vector4, glm::vec4);
WRITE_FIELD_TYPE(Entity, UUID);
}
out << YAML::EndMap;
#undef WRITE_FIELD_TYPE
}
out << YAML::EndSeq;
}
out << YAML::EndMap; // ScriptComponent
}
@ -401,6 +478,58 @@ namespace Hazel
{
auto& sc = deserializedEntity.AddComponent<ScriptComponent>();
sc.ClassName = scriptComponent["ClassName"].as<std::string>();
auto scriptFields = scriptComponent["ScriptFields"];
if (scriptFields)
{
Ref<ScriptClass> entityClass = ScriptEngine::GetEntityClass(sc.ClassName);
const auto& fields = entityClass->GetFields();
auto& entityFields = ScriptEngine::GetScriptFieldMap(deserializedEntity);
for (auto scriptField: scriptFields)
{
std::string name = scriptField["Name"].as<std::string>();
std::string typeName = scriptField["Type"].as<std::string>();
ScriptFieldType type = Utils::ScriptFieldTypeFromString(typeName);
ScriptFieldInstance& fieldInstance = entityFields[name];
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)
{
READ_FIELD_TYPE(Float, float);
READ_FIELD_TYPE(Double, double);
READ_FIELD_TYPE(Boolean, bool);
READ_FIELD_TYPE(Char, char);
READ_FIELD_TYPE(Byte, int8_t);
READ_FIELD_TYPE(Short, int16_t);
READ_FIELD_TYPE(Int, int32_t);
READ_FIELD_TYPE(Long, int64_t);
READ_FIELD_TYPE(UByte, uint8_t);
READ_FIELD_TYPE(UShort, uint16_t);
READ_FIELD_TYPE(UInt, uint32_t);
READ_FIELD_TYPE(ULong, uint64_t);
READ_FIELD_TYPE(Vector2, glm::vec2);
READ_FIELD_TYPE(Vector3, glm::vec3);
READ_FIELD_TYPE(Vector4, glm::vec4);
READ_FIELD_TYPE(Entity, UUID);
}
#undef READ_FIELD_TYPE
}
}
}
auto spriteRendererComponent = entity["SpriteRendererComponent"];

54
Hazel/src/Hazel/Scripting/ScriptEngine.cpp
View File

@ -122,34 +122,6 @@ namespace Hazel
}
return s_ScriptFieldTypeMap.at(typeName);
}
const char* ScriptFieldTypeToString(ScriptFieldType type)
{
switch (type)
{
case ScriptFieldType::Float: return "Float";
case ScriptFieldType::Double: return "Double";
case ScriptFieldType::Boolean: return "Boolean";
case ScriptFieldType::Byte: return "Byte";
case ScriptFieldType::Char: return "Char";
case ScriptFieldType::Short: return "Short";
case ScriptFieldType::Int: return "Int";
case ScriptFieldType::Long: return "Long";
case ScriptFieldType::UByte: return "UByte";
case ScriptFieldType::UShort: return "UShort";
case ScriptFieldType::UInt: return "UInt";
case ScriptFieldType::ULong: return "ULong";
case ScriptFieldType::Entity: return "Entity";
case ScriptFieldType::Vector2: return "Vector2";
case ScriptFieldType::Vector3: return "Vector3";
case ScriptFieldType::Vector4: return "Vector4";
}
return "<Invalid>";
}
}
struct ScriptEngineData
@ -168,6 +140,8 @@ namespace Hazel
std::unordered_map<std::string, Ref<ScriptClass>> EntityClasses;
std::unordered_map<UUID, Ref<ScriptInstance>> EntityInstances;
std::unordered_map<UUID, ScriptFieldMap> EntityScriptFields;
// runtime
Scene* SceneContext = nullptr;
};
@ -306,6 +280,18 @@ namespace Hazel
return s_Data->EntityClasses;
}
Ref<ScriptClass> ScriptEngine::GetEntityClass(const std::string& name)
{
if (!s_Data->EntityClasses.contains(name))
return nullptr;
return s_Data->EntityClasses.at(name);
}
ScriptFieldMap& ScriptEngine::GetScriptFieldMap(Entity entity)
{
return s_Data->EntityScriptFields[entity.GetUUID()];
}
void ScriptEngine::OnRuntimeStart(Scene* scene)
{
s_Data->SceneContext = scene;
@ -328,8 +314,18 @@ namespace Hazel
const auto& sc = entity.GetComponent<ScriptComponent>();
if (ClassExists(sc.ClassName))
{
UUID entityID = entity.GetUUID();
Ref<ScriptInstance> instance = CreateRef<ScriptInstance>(s_Data->EntityClasses[sc.ClassName], entity);
s_Data->EntityInstances[entity.GetUUID()] = instance;
s_Data->EntityInstances[entityID] = instance;
// copy Field value
if (s_Data->EntityScriptFields.contains(entityID))
{
const ScriptFieldMap& fieldMap = s_Data->EntityScriptFields.at(entityID);
for (const auto& [name, fieldInstance] : fieldMap)
instance->SetFieldValueInternal(name, fieldInstance.m_Buffer);
}
instance->InvokeOnCreate();
}

86
Hazel/src/Hazel/Scripting/ScriptEngine.h
View File

@ -41,6 +41,36 @@ namespace Hazel
MonoClassField* ClassField;
};
struct ScriptFieldInstance
{
ScriptField Field;
template <typename T>
T GetValue()
{
return *(T*)m_Buffer;
}
template <typename T>
void SetValue(T data)
{
if constexpr (sizeof(T) <= 8)
memcpy(m_Buffer, &data, sizeof(T));
else
{
HZ_CLIENT_ERROR("Type to large: sizeof(data): {} bytes", sizeof(T));
}
}
private:
uint8_t m_Buffer[8] = {};
friend class ScriptEngine;
friend class ScriptInstance;
};
using ScriptFieldMap = std::unordered_map<std::string, ScriptFieldInstance>;
class ScriptClass
{
public:
@ -103,6 +133,9 @@ namespace Hazel
MonoMethod* m_OnUpdateMethod = nullptr;
inline static char s_FieldValueBuffer[8];
friend class ScriptEngine;
friend struct ScriptFieldInstance;
};
class ScriptEngine
@ -126,6 +159,8 @@ namespace Hazel
static Ref<ScriptInstance> GetEntityScriptInstance(UUID entityID);
static std::unordered_map<std::string, Ref<ScriptClass>> GetEntityClasses();
static Ref<ScriptClass> GetEntityClass(const std::string& name);
static ScriptFieldMap& GetScriptFieldMap(Entity entity);
static MonoImage* GetCoreAssemblyImage();
@ -139,6 +174,57 @@ namespace Hazel
friend class ScriptClass;
friend class ScriptGlue;
};
namespace Utils
{
inline const char* ScriptFieldTypeToString(const ScriptFieldType fieldType)
{
switch (fieldType)
{
case ScriptFieldType::Char: return "Char";
case ScriptFieldType::Float: return "Float";
case ScriptFieldType::Double: return "Double";
case ScriptFieldType::Vector2: return "Vector2";
case ScriptFieldType::Vector3: return "Vector3";
case ScriptFieldType::Vector4: return "Vector4";
case ScriptFieldType::Byte: return "Byte";
case ScriptFieldType::Short: return "Short";
case ScriptFieldType::Int: return "Int";
case ScriptFieldType::Long: return "Long";
case ScriptFieldType::Boolean: return "Boolean";
case ScriptFieldType::UByte: return "UByte";
case ScriptFieldType::UShort: return "UShort";
case ScriptFieldType::UInt: return "UInt";
case ScriptFieldType::ULong: return "ULong";
case ScriptFieldType::Entity: return "Entity";
}
HZ_CORE_ERROR("Unknown scriptFieldType");
return "None";
}
inline ScriptFieldType ScriptFieldTypeFromString(const std::string& fieldType)
{
if(fieldType == "Char") return ScriptFieldType::Char;
if(fieldType == "Float") return ScriptFieldType::Float;
if(fieldType == "Double") return ScriptFieldType::Double;
if(fieldType == "Vector2") return ScriptFieldType::Vector2;
if(fieldType == "Vector3") return ScriptFieldType::Vector3;
if(fieldType == "Vector4") return ScriptFieldType::Vector4;
if(fieldType == "Byte") return ScriptFieldType::Byte;
if(fieldType == "Short") return ScriptFieldType::Short;
if(fieldType == "Int") return ScriptFieldType::Int;
if(fieldType == "Long") return ScriptFieldType::Long;
if(fieldType == "Boolean") return ScriptFieldType::Boolean;
if(fieldType == "UByte") return ScriptFieldType::UByte;
if(fieldType == "UShort") return ScriptFieldType::UShort;
if(fieldType == "UInt") return ScriptFieldType::UInt;
if(fieldType == "ULong") return ScriptFieldType::ULong;
if(fieldType == "Entity") return ScriptFieldType::Entity;
HZ_CORE_ERROR("Unknown scriptFieldType");
return ScriptFieldType::None;
}
}
}

2
Hazel/src/Hazel/Scripting/ScriptGlue.cpp
View File

@ -18,7 +18,7 @@ namespace Hazel
static std::unordered_map<MonoType*, std::function<bool(Entity)>> s_EntityHasComponentFuncs;
#define HZ_ADD_INTERNAL_CALL(Name) mono_add_internal_call("Hazel.InternalCalls::" #Name, Name)
#define HZ_ADD_INTERNAL_CALL(Name) mono_add_internal_call("Hazel.InternalCalls::" #Name, reinterpret_cast<const void*>(Name))
static void NativeLog(MonoString* text, int param)
{