Level Editor, DvScene Editor, Debug Rendering and GOCPlayerBlackboard additions

.gitmodules

@@ -34,3 +34,6 @@
 [submodule "vendor/uwebsockets/uWebSockets"]
 	path = vendor/uwebsockets/uWebSockets
 	url = https://github.com/uNetworking/uWebSockets.git
+[submodule "vendor/recastnavigation/recastnavigation"]
+	path = vendor/recastnavigation/recastnavigation
+	url = https://github.com/recastnavigation/recastnavigation

CMakeLists.txt

@@ -84,7 +84,7 @@ foreach(DEVTOOLS_TARGET_SDK miller rangers wars)
     add_subdirectory(${SDK_PATH} ${DEVTOOLS_TARGET_SDK}-sdk EXCLUDE_FROM_ALL)
 
     add_library(${DEVTOOLS_TARGET} SHARED)
-    target_link_libraries(${DEVTOOLS_TARGET} PRIVATE ${DEVTOOLS_TARGET_SDK}-sdk filewatch detours imgui imgui-backend-win32 imgui-backend-dx11 imgui-node-editor imgui-memory-editor imguizmo implot imtimeline imbrowser yyjson reflectcpp OGDF rip-hl uwebsockets DiEventLib)
+    target_link_libraries(${DEVTOOLS_TARGET} PRIVATE ${DEVTOOLS_TARGET_SDK}-sdk filewatch detours imgui imgui-backend-win32 imgui-backend-dx11 imgui-node-editor imgui-memory-editor imguizmo implot imtimeline imbrowser yyjson reflectcpp OGDF rip-hl uwebsockets DiEventLib Recast Detour)
     target_compile_features(${DEVTOOLS_TARGET} PRIVATE cxx_std_20)
     target_compile_options(${DEVTOOLS_TARGET} PRIVATE /permissive- /W4 /wd4100 /wd4458 /wd4324)
     target_compile_definitions(${DEVTOOLS_TARGET}

src/CMakeLists.txt

@@ -18,6 +18,7 @@ target_sources(${DEVTOOLS_TARGET}
         debug-rendering/renderables/Bones.cpp
         debug-rendering/renderables/PhysicalAnimation.cpp
         debug-rendering/renderables/Light.cpp
+        debug-rendering/renderables/NavMesh.cpp
         debug-rendering/visuals/AabbTree.cpp
         debug-rendering/visuals/Geometry.cpp
         debug-rendering/visuals/KdTree.cpp
@@ -92,6 +93,7 @@ target_sources(${DEVTOOLS_TARGET}
         debug-rendering/renderables/Bones.h
         debug-rendering/renderables/PhysicalAnimation.h
         debug-rendering/renderables/Light.h
+        debug-rendering/renderables/NavMesh.h
         debug-rendering/visuals/AabbTree.h
         debug-rendering/visuals/Geometry.h
         debug-rendering/visuals/KdTree.h
@@ -284,6 +286,11 @@ if(${DEVTOOLS_TARGET_SDK} STREQUAL "rangers")
         GOCPlayerCollider
         GOCPointLight
         GOCVibration
+        GOCHsm2
+        GOCBossActionSelect
+        GOCBossMoveableRange
+        GOCHealth
+        GOCHitStop
     )
     set(DEVTOOLS_FEATURE_RESOURCE_INSPECTORS
         ResObjectWorldEditor
@@ -370,6 +377,7 @@ if(${DEVTOOLS_TARGET_SDK} STREQUAL "miller")
         GOCSound
         GOCParticleLocator
         GOCPlayerKinematicParams
+        GOCPlayerBlackboard
     )
     set(DEVTOOLS_FEATURE_RESOURCE_INSPECTORS
         ResObjectWorldEditor

src/debug-rendering/DebugRenderingSystem.h

@@ -10,6 +10,7 @@
 #endif
 #ifdef DEVTOOLS_TARGET_SDK_rangers
 #include "renderables/Light.h"
+#include "renderables/NavMesh.h"
 #endif
 
 namespace devtools::debug_rendering {
@@ -25,6 +26,7 @@ namespace devtools::debug_rendering {
 #endif
 #ifdef DEVTOOLS_TARGET_SDK_rangers
 		renderables::Light lightRenderable{};
+		renderables::NavMesh navMeshRenderable{};
 #endif
 
 		static hh::fnd::Reference<DebugRenderingSystem> instance;

src/debug-rendering/renderables/Colliders.cpp

@@ -36,6 +36,55 @@ namespace devtools::debug_rendering::renderables {
 					if (colliderFilters[gameObject->layer][cGoc->filterCategory])
 						ctx.DrawCylinder(cGoc->GetWorldTransform(), cGoc->radius, cGoc->halfHeight, { 0, 255, 255, 255 });
 				}
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+				// WIP - sometimes meshes don't render fully or at all. or they render at the wrong position
+				else if (meshEnabled 
+					&& goc->pStaticClass == hh::physics::GOCMeshCollider::GetClass()) 
+				{
+					auto* cGoc = static_cast<hh::physics::GOCMeshCollider*>(goc);
+					auto meshResource = cGoc->meshResource;
+
+					auto* allocator = hh::fnd::MemoryRouter::GetModuleAllocator();
+					csl::ut::MoveArray<hh::physics::ResPhysicsMesh::MeshInfo*> meshInfos{ allocator };
+
+					if (meshResource->GetMeshInfo(meshInfos, allocator)) {
+						for (auto* meshInfo : meshInfos) {
+							size_t vertexCount = meshInfo->vertices.size();
+							size_t indexCount = meshInfo->faces.size();
+
+							hh::gfnd::DrawVertex* vertices = new (allocator) hh::gfnd::DrawVertex[vertexCount];
+							for (int i = 0; i < vertexCount; i++) {
+								auto& pos = meshInfo->vertices[i];
+								vertices[i].x = pos.x();
+								vertices[i].y = pos.y();
+								vertices[i].z = pos.z();
+								vertices[i].color = 0xFFFFFF00;
+							}
+
+							unsigned short* indices = new (allocator) unsigned short[indexCount * 3 * 2];
+							for (int i = 0; i < indexCount; i++) {
+								auto& f = meshInfo->faces[i];
+								auto curIndex = i * 6;
+								indices[curIndex] = f.a;
+								indices[curIndex + 1] = f.b;
+								indices[curIndex + 2] = f.b;
+								indices[curIndex + 3] = f.c;
+								indices[curIndex + 4] = f.c;
+								indices[curIndex + 5] = f.a;
+							}
+
+							ctx.DrawPrimitive(hh::gfnd::PrimitiveType::LINE_LIST, vertices, indices, indexCount * 3 * 2);
+
+							allocator->Free(vertices);
+							allocator->Free(indices);
+
+							meshInfo->vertices.~MoveArray();
+							meshInfo->faces.~MoveArray();
+							allocator->Free(meshInfo);
+						}
+					}
+				}
+#endif
 			}
 		}
 	}

src/debug-rendering/renderables/Colliders.h

@@ -8,6 +8,9 @@ namespace devtools::debug_rendering::renderables {
 		bool enabled{};
 		bool colliderFilters[32][32];
 		//ColliderFilterList colliderFilterList;
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+		bool meshEnabled{};
+#endif
 
 		virtual void RenderIngameDebugVisuals(hh::gfnd::DrawContext& ctx) override;
 	};

src/debug-rendering/renderables/NavMesh.cpp

@@ -0,0 +1,72 @@
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+#include "NavMesh.h"
+#include <DetourNavMesh.h>
+
+namespace devtools::debug_rendering::renderables {
+	void NavMesh::RenderIngameDebugVisuals(hh::gfnd::DrawContext& ctx)
+	{
+		if (!enabled)
+			return;
+
+		auto* gameManager = hh::game::GameManager::GetInstance();
+		if (!gameManager)
+			return;
+
+		if (auto* navmeshMgr = gameManager->GetService<hh::navmesh::NavMeshManager>()) {
+			auto impl = navmeshMgr->implementation;
+			for (auto& tile : impl->tiles) {
+				auto* resTile = tile.resTile;
+				char* binaryData = (char*)resTile->unpackedBinaryData;
+
+				unsigned char* vandData = (unsigned char*)&binaryData[0x18];
+				int vandSize = static_cast<int>(resTile->size - 0x18);
+
+				dtMeshHeader* header = reinterpret_cast<dtMeshHeader*>(vandData);
+				if (header->magic != DT_NAVMESH_MAGIC || header->version != DT_NAVMESH_VERSION)
+					continue;
+
+                float* verts = (float*)(vandData + sizeof(dtMeshHeader));
+                dtPoly* polys = (dtPoly*)((unsigned char*)verts + sizeof(float) * header->vertCount * 3);
+                dtLink* links = (dtLink*)((unsigned char*)polys + sizeof(dtPoly) * header->polyCount);
+                dtPolyDetail* details = (dtPolyDetail*)((unsigned char*)links + (sizeof(dtLink) + 4) * header->maxLinkCount);
+                float* detailVerts = (float*)((unsigned char*)details + sizeof(dtPolyDetail) * header->detailMeshCount);
+                unsigned char* detailTris = (unsigned char*)(detailVerts + header->detailVertCount * 3);
+
+                auto* allocator = hh::fnd::MemoryRouter::GetModuleAllocator();
+                csl::ut::MoveArray<hh::gfnd::DrawVertex> objVerts{ allocator };
+                csl::ut::MoveArray<unsigned short> objIndices{ allocator };
+
+                for (int i = 0; i < header->polyCount; ++i) {
+                    const dtPoly& poly = polys[i];
+                    const dtPolyDetail& detail = details[i];
+
+                    for (int j = 0; j < detail.triCount; ++j) {
+                        const unsigned char* tri = &detailTris[(detail.triBase + j) * 4];
+
+                        for (int k = 0; k < 3; ++k) {
+                            int index = tri[k];
+                            const float* v = nullptr;
+
+                            if (index < poly.vertCount)
+                                v = &verts[poly.verts[index] * 3];
+                            else
+                                v = &detailVerts[(detail.vertBase + (index - poly.vertCount)) * 3];
+
+                            size_t base = objVerts.size();
+                            objVerts.push_back(hh::gfnd::DrawVertex{
+                                .x = v[0],
+                                .y = v[1],
+                                .z = v[2],
+                                .color = 0x6400FF00
+                                });
+                            objIndices.push_back(base - 1);
+                        }
+                    }
+                }
+
+                ctx.DrawPrimitive(hh::gfnd::PrimitiveType::LINE_STRIP, objVerts.begin(), objIndices.begin(), objIndices.size());
+			}
+		}
+	}
+}
+#endif

src/debug-rendering/renderables/NavMesh.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <debug-rendering/DebugRenderable.h>
+
+namespace devtools::debug_rendering::renderables {
+	class NavMesh : public OptionalDebugRenderable {
+	public:
+		bool enabled{};
+
+		virtual void RenderIngameDebugVisuals(hh::gfnd::DrawContext& ctx) override;
+	};
+}

src/ui/Action.h

@@ -55,6 +55,7 @@ enum class ActionId {
 	SURFRIDE_EDITOR_FOCUSED_SCENE_CHANGED,
 	SURFRIDE_EDITOR_ADD_CAST_TO_LAYER,
 	SURFRIDE_EDITOR_ADD_CAST_TO_CAST,
+	SURFRIDE_EDITOR_ADD_LAYER_TO_SCENE,
 	SURFRIDE_EDITOR_ADD_SCENE,
 	SURFRIDE_EDITOR_REMOVE_CAST,
 	SURFRIDE_EDITOR_REMOVE_LAYER,

src/ui/SettingsManager.cpp

@@ -29,13 +29,19 @@ bool SettingsManager::Settings::operator==(const SettingsManager::Settings& othe
 		&& enableViewports == other.enableViewports
 		&& debugRenderingRenderGOCVisualDebugDraw == other.debugRenderingRenderGOCVisualDebugDraw
 		&& debugRenderingRenderColliders == other.debugRenderingRenderColliders
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+		&& debugRenderingRenderMeshColliders == other.debugRenderingRenderMeshColliders
+#endif
 		&& debugRenderingRenderOcclusionCapsules == other.debugRenderingRenderOcclusionCapsules
 		&& debugRenderingRenderBones == other.debugRenderingRenderBones
 		&& debugRenderingRenderPaths == other.debugRenderingRenderPaths
 		&& debugRenderingRenderPathNormals == other.debugRenderingRenderPathNormals
 		&& debugRenderingRenderPathTangents == other.debugRenderingRenderPathTangents
 		&& debugRenderingRenderPhysicalAnimation == other.debugRenderingRenderPhysicalAnimation
 		&& debugRenderingRenderLight == other.debugRenderingRenderLight
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+		&& debugRenderingRenderNavMesh == other.debugRenderingRenderNavMesh
+#endif
 		&& debugRenderingGOCVisualDebugDrawOpacity == other.debugRenderingGOCVisualDebugDrawOpacity
 		&& debugRenderingLevelEditorDebugBoxScale == other.debugRenderingLevelEditorDebugBoxScale
 		&& debugRenderingLevelEditorDebugBoxRenderLimit == other.debugRenderingLevelEditorDebugBoxRenderLimit
@@ -225,6 +231,11 @@ void SettingsManager::Render() {
 							constexpr uint8_t maxAlpha{ 255 };
 							ImGui::Checkbox("Render GOCVisualDebugDraw visuals", &tempSettings.debugRenderingRenderGOCVisualDebugDraw);
 							ImGui::Checkbox("Render colliders", &tempSettings.debugRenderingRenderColliders);
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+							ImGui::Indent();
+							ImGui::Checkbox("Render mesh colliders", &tempSettings.debugRenderingRenderMeshColliders);
+							ImGui::Unindent();
+#endif
 							ImGui::Checkbox("Render occlusion capsules", &tempSettings.debugRenderingRenderOcclusionCapsules);
 							ImGui::Checkbox("Render bones", &tempSettings.debugRenderingRenderBones);
 							ImGui::Checkbox("Render paths", &tempSettings.debugRenderingRenderPaths);
@@ -234,6 +245,9 @@ void SettingsManager::Render() {
 							ImGui::Unindent();
 							ImGui::Checkbox("Render physical animation", &tempSettings.debugRenderingRenderPhysicalAnimation);
 							ImGui::Checkbox("Render lights", &tempSettings.debugRenderingRenderLight);
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+							ImGui::Checkbox("Render navmesh", &tempSettings.debugRenderingRenderNavMesh);
+#endif
 							ImGui::SliderScalar("GOCVisualDebugDraw opacity (requires stage restart)", ImGuiDataType_U8, &tempSettings.debugRenderingGOCVisualDebugDrawOpacity, &minAlpha, &maxAlpha);
 							ImGui::Checkbox("Render primary tags", &tempSettings.debugRenderingLevelEditorDebugBoxRenderPrimaryTags);
 							ImGui::SetItemTooltip("Whether the primary text tag should be rendered (usually object name).");
@@ -394,6 +408,9 @@ void SettingsManager::ApplySettings() {
 	devtools::debug_rendering::DebugRenderingSystem::instance->gocVisualDebugDrawsRenderable.enabled = settings.debugRenderingRenderGOCVisualDebugDraw;
 	devtools::debug_rendering::DebugRenderingSystem::instance->gocVisualDebugDrawsRenderable.opacity = settings.debugRenderingGOCVisualDebugDrawOpacity;
 	devtools::debug_rendering::DebugRenderingSystem::instance->collidersRenderable.enabled = settings.debugRenderingRenderColliders;
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+	devtools::debug_rendering::DebugRenderingSystem::instance->collidersRenderable.meshEnabled = settings.debugRenderingRenderMeshColliders;
+#endif
 	devtools::debug_rendering::DebugRenderingSystem::instance->occlusionCapsulesRenderable.enabled = settings.debugRenderingRenderOcclusionCapsules;
 	devtools::debug_rendering::DebugRenderingSystem::instance->bonesRenderable.enabled = settings.debugRenderingRenderBones;
 	devtools::debug_rendering::DebugRenderingSystem::instance->pathsRenderable.enabled = settings.debugRenderingRenderPaths;
@@ -404,6 +421,7 @@ void SettingsManager::ApplySettings() {
 #endif
 #ifdef DEVTOOLS_TARGET_SDK_rangers
 	devtools::debug_rendering::DebugRenderingSystem::instance->lightRenderable.enabled = settings.debugRenderingRenderLight;
+	devtools::debug_rendering::DebugRenderingSystem::instance->navMeshRenderable.enabled = settings.debugRenderingRenderNavMesh;
 #endif
 	ObjectLocationVisual3DBehaviorBase::ApplySettings(
 		settings.debugRenderingLevelEditorDebugBoxScale,
@@ -478,13 +496,19 @@ void SettingsManager::ReadLineFn(ImGuiContext* ctx, ImGuiSettingsHandler* handle
 	if (sscanf_s(line, "EnableViewports=%u", &u) == 1) { settings.enableViewports = static_cast<bool>(u); return; }
 	if (sscanf_s(line, "DebugRenderingRenderGOCVisualDebugDraw=%u", &u) == 1) { settings.debugRenderingRenderGOCVisualDebugDraw = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderColliders=%u", &u) == 1) { settings.debugRenderingRenderColliders = u; return; }
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+	if (sscanf_s(line, "DebugRenderingRenderMeshColliders=%u", &u) == 1) { settings.debugRenderingRenderMeshColliders = u; return; }
+#endif
 	if (sscanf_s(line, "DebugRenderingRenderOcclusionCapsules=%u", &u) == 1) { settings.debugRenderingRenderOcclusionCapsules = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderBones=%u", &u) == 1) { settings.debugRenderingRenderBones = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderPaths=%u", &u) == 1) { settings.debugRenderingRenderPaths = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderPathNormals=%u", &u) == 1) { settings.debugRenderingRenderPathNormals = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderPathTangents=%u", &u) == 1) { settings.debugRenderingRenderPathTangents = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderPhysicalAnimation=%u", &u) == 1) { settings.debugRenderingRenderPhysicalAnimation = u; return; }
 	if (sscanf_s(line, "DebugRenderingRenderLight=%u", &u) == 1) { settings.debugRenderingRenderLight = u; return; }
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+	if (sscanf_s(line, "DebugRenderingRenderNavMesh=%u", &u) == 1) { settings.debugRenderingRenderNavMesh = u; return; }
+#endif
 	if (sscanf_s(line, "DebugRenderingGOCVisualDebugDrawOpacity=%u", &u) == 1) { settings.debugRenderingGOCVisualDebugDrawOpacity = static_cast<uint8_t>(u); return; }
 	if (sscanf_s(line, "DebugRenderingLevelEditorDebugBoxScale=%f", &f) == 1) { settings.debugRenderingLevelEditorDebugBoxScale = f; return; }
 	if (sscanf_s(line, "DebugRenderingLevelEditorDebugBoxRenderLimit=%u", &u) == 1) { settings.debugRenderingLevelEditorDebugBoxRenderLimit = u; return; }
@@ -548,13 +572,19 @@ void SettingsManager::WriteAllFn(ImGuiContext* ctx, ImGuiSettingsHandler* handle
 	out_buf->appendf("EnableViewports=%u\n", settings.enableViewports);
 	out_buf->appendf("DebugRenderingRenderGOCVisualDebugDraw=%u\n", settings.debugRenderingRenderGOCVisualDebugDraw);
 	out_buf->appendf("DebugRenderingRenderColliders=%u\n", settings.debugRenderingRenderColliders);
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+	out_buf->appendf("DebugRenderingRenderMeshColliders=%u\n", settings.debugRenderingRenderMeshColliders);
+#endif
 	out_buf->appendf("DebugRenderingRenderOcclusionCapsules=%u\n", settings.debugRenderingRenderOcclusionCapsules);
 	out_buf->appendf("DebugRenderingRenderBones=%u\n", settings.debugRenderingRenderBones);
 	out_buf->appendf("DebugRenderingRenderPaths=%u\n", settings.debugRenderingRenderPaths);
 	out_buf->appendf("DebugRenderingRenderPathNormals=%u\n", settings.debugRenderingRenderPathNormals);
 	out_buf->appendf("DebugRenderingRenderPathTangents=%u\n", settings.debugRenderingRenderPathTangents);
 	out_buf->appendf("DebugRenderingRenderPhysicalAnimation=%u\n", settings.debugRenderingRenderPhysicalAnimation);
 	out_buf->appendf("DebugRenderingRenderLight=%u\n", settings.debugRenderingRenderLight);
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+	out_buf->appendf("DebugRenderingRenderNavMesh=%u\n", settings.debugRenderingRenderNavMesh);
+#endif
 	out_buf->appendf("DebugRenderingGOCVisualDebugDrawOpacity=%u\n", settings.debugRenderingGOCVisualDebugDrawOpacity);
 	out_buf->appendf("DebugRenderingLevelEditorDebugBoxScale=%f\n", settings.debugRenderingLevelEditorDebugBoxScale);
 	out_buf->appendf("DebugRenderingLevelEditorDebugBoxRenderLimit=%u\n", settings.debugRenderingLevelEditorDebugBoxRenderLimit);

src/ui/SettingsManager.h

@@ -175,13 +175,17 @@ class SettingsManager
 #endif
         bool debugRenderingRenderGOCVisualDebugDraw{ true };
         bool debugRenderingRenderColliders{ true };
+        bool debugRenderingRenderMeshColliders{ true };
         bool debugRenderingRenderOcclusionCapsules{ true };
         bool debugRenderingRenderBones{ true };
         bool debugRenderingRenderPaths{ true };
         bool debugRenderingRenderPathNormals{ true };
         bool debugRenderingRenderPathTangents{ true };
         bool debugRenderingRenderPhysicalAnimation{ true };
         bool debugRenderingRenderLight{ true };
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+        bool debugRenderingRenderNavMesh{ true };
+#endif
         uint8_t debugRenderingGOCVisualDebugDrawOpacity{ 80 };
         float debugRenderingLevelEditorDebugBoxScale{ 0.3f };
         unsigned int debugRenderingLevelEditorDebugBoxRenderLimit{ 500 };

src/ui/common/editors/Camera.cpp

@@ -8,7 +8,11 @@ bool Editor(const char* label, CameraParameter::Orientation::Target& target) {
     ImGui::PushID(label);
 
 	edited |= Editor("Up Vector", target.upVector);
-	edited |= Editor("Unk8b", target.unk8b);
+#ifdef DEVTOOLS_TARGET_SDK_rangers
+	edited |= Editor("Z Rot", target.zRot);
+#else
+    edited |= Editor("Unk8b", target.unk8b);
+#endif
 
     ImGui::PopID();
     return edited;

src/ui/common/editors/ObjectData.cpp

@@ -30,14 +30,17 @@ bool Editor(const char* label, hh::game::ObjectTransformData& obj)
 	return edited;
 }
 
-bool Editor(const char* label, hh::game::ObjectData& obj)
+bool Editor(const char* label, hh::game::ObjectData& obj, hh::game::ResObjectWorld* objectWorld)
 {
 	bool edited{};
 	auto* objSystem = GameObjectSystem::GetInstance();
 
 	Viewer("Id", obj.id);
 #ifdef DEVTOOLS_TARGET_SDK_wars
-	Viewer("Name", obj.name);
+	if (objectWorld)
+		edited |= InputText("Name", obj.name, objectWorld);
+	else
+		Viewer("Name", obj.name);
 #else
 	edited |= Editor("Name", obj.name);
 #endif

src/ui/common/editors/ObjectData.h

@@ -1,4 +1,4 @@
 #pragma once
 
 bool Editor(const char* label, hh::game::ObjectTransformData& obj);
-bool Editor(const char* label, hh::game::ObjectData& obj);
+bool Editor(const char* label, hh::game::ObjectData& obj, hh::game::ResObjectWorld* objectWorld = nullptr);