Scene, Editor

// Serialize 함수
void SceneSerializer::serialize(const std::string &filepath)
{
	YAML::Emitter out;
	out << YAML::BeginMap;
	out << YAML::Key << "Scene" << YAML::Value << "Untitled";
	out << YAML::Key << "Entities" << YAML::Value << YAML::BeginSeq;
	m_Scene->m_Registry.view<entt::entity>().each([&](auto entityID) {
		Entity entity{entityID, m_Scene.get()};
		if (!entity)
		{
			return;
		}
		serializeEntity(out, entity, m_Scene.get());
	});

	out << YAML::EndSeq;
	out << YAML::EndMap;
	std::ofstream fout(filepath);
	fout << out.c_str();
}

static void serializeEntity(YAML::Emitter &out, Entity entity, Scene *scene)
{
	out << YAML::BeginMap;
	out << YAML::Key << "Entity" << YAML::Value << entity.getUUID();

	// KEY, KEY - VALUE
	if (entity.hasComponent<TagComponent>())
	{
		out << YAML::Key << "TagComponent";
		out << YAML::BeginMap;
		auto &tag = entity.getComponent<TagComponent>().m_Tag;
		out << YAML::Key << "Tag" << YAML::Value << tag;
		out << YAML::EndMap; // Tag
	}

	// TransformComponent
	if (entity.hasComponent<TransformComponent>())
	{
		out << YAML::Key << "TransformComponent";
		out << YAML::BeginMap;
		auto &tf = entity.getComponent<TransformComponent>();
		out << YAML::Key << "Position" << YAML::Value << tf.m_Position;
		out << YAML::Key << "Rotation" << YAML::Value << tf.m_Rotation;
		out << YAML::Key << "Scale" << YAML::Value << tf.m_Scale;
		out << YAML::EndMap; // Transform
	}

    // ...

	out << YAML::EndMap; // End Serialize Entity
}

// Deserialize 함수
bool SceneSerializer::deserialize(const std::string &filepath)
{
	YAML::Node data;

	try
	{
		data = YAML::LoadFile(filepath);
	}
	catch (const std::exception &e)
	{
		AL_CORE_ERROR("Failed to load .ale file '{0}'\n    {1}", filepath, e.what());
		return false;
	}

	// Scene
	if (!data["Scene"])
	{
		return false;
	}

	// Entities
	auto entities = data["Entities"];
	if (entities)
	{
		for (auto entity : entities)
		{
			// IDComponent
			uint64_t uuid = entity["Entity"].as<uint64_t>();

			// TagComponent
			std::string name;
			auto tagComponent = entity["TagComponent"];
			if (tagComponent)
			{
				name = tagComponent["Tag"].as<std::string>();
			}

			AL_CORE_TRACE("Entity deserialized as ID: {0}, Tag: {1}", uuid, name);

			Entity deserializedEntity = m_Scene->createEntityWithUUID(uuid, name);

			// TransformComponent
			auto tfComponent = entity["TransformComponent"];
			if (tfComponent)
			{
				auto &tf = deserializedEntity.getComponent<TransformComponent>();
				tf.m_Position = tfComponent["Position"].as<glm::vec3>();
				tf.m_Rotation = tfComponent["Rotation"].as<glm::vec3>();
				tf.m_Scale = tfComponent["Scale"].as<glm::vec3>();
				tf.m_WorldTransform = tf.getTransform();
			}
			// ...
        }
	}
	return true;
}

namespace YAML
{
// 템플릿 특수화
template <> struct convert<glm::vec3>
{
	static Node encode(const glm::vec3 &rhs)
	{
		Node node;
		node.push_back(rhs.x);
		node.push_back(rhs.y);
		node.push_back(rhs.z);
		node.SetStyle(EmitterStyle::Flow);
		return node;
	}

	static bool decode(const Node &node, glm::vec3 &rhs)
	{
		if (!node.IsSequence() || node.size() != 3)
			return false;

		rhs.x = node[0].as<float>();
		rhs.y = node[1].as<float>();
		rhs.z = node[2].as<float>();
		return true;
	}
};

template <> struct convert<ale::UUID>
{
	static Node encode(const ale::UUID &uuid)
	{
		Node node;
		node.push_back((uint64_t)uuid);
		return node;
	}

	static bool decode(const Node &node, ale::UUID &uuid)
	{
		uuid = node.as<uint64_t>();
		return true;
	}
};
}

void SceneHierarchyPanel::drawEntityNode(Entity entity)
{
	auto &tag = entity.getComponent<TagComponent>().m_Tag;

	ImGuiTreeNodeFlags flags =
		((m_SelectionContext == entity) ? ImGuiTreeNodeFlags_Selected : 0) | ImGuiTreeNodeFlags_OpenOnArrow;
	flags |= ImGuiTreeNodeFlags_SpanAvailWidth; // 선택 영역이 가장자리까지 넓어지게 설정
	bool opened = ImGui::TreeNodeEx((void *)(uint64_t)(uint32_t)entity, flags, tag.c_str());

	// ...
}

/**
 * @struct RelationshipComponent
 * @brief 개체 간의 부모-자식 관계를 정의하는 컴포넌트.
 */
struct RelationshipComponent
{
	entt::entity parent = entt::null;
	std::vector<entt::entity> children;

	RelationshipComponent() = default;
	RelationshipComponent(const RelationshipComponent &) = default;
};

if (opened)
{
	auto &relation = entity.getComponent<RelationshipComponent>();
	for (auto child : relation.children)
	{
		Entity entity(child, m_Context.get());
		drawEntityNode(entity);
	}
	ImGui::TreePop();
}

if (ImGui::BeginDragDropSource())
{
	Entity e = entity;
	// 문자열("EntityPayload")로 ID 설정
	ImGui::SetDragDropPayload("EntityPayload", &e, sizeof(Entity));
	ImGui::Text("%s", tag.c_str());
	ImGui::EndDragDropSource();
}

if (ImGui::BeginDragDropTarget())
{
	// "EntityPayload" 로 드래그 앤 드롭 UI 식별.
	if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("EntityPayload"))
	{
		Entity *droppedEntity = (Entity *)payload->Data;
		// droppedEntity가 entity의 자식이 되도록 설정

		if (*droppedEntity != entity)
			updateRelationship(entity, *droppedEntity);
	}
	ImGui::EndDragDropTarget();
}

void SceneHierarchyPanel::updateRelationship(Entity &newParent, Entity &child)
{
	// 1. 기존 부모에게서 제거
	auto &childRelation = child.getComponent<RelationshipComponent>();
	entt::entity oldParent = childRelation.parent;

	if (oldParent != entt::null)
	{
		auto &oldParentRelation = m_Context->m_Registry.get<RelationshipComponent>(oldParent);
		auto &siblings = oldParentRelation.children;
		siblings.erase(std::remove(siblings.begin(), siblings.end(), child), siblings.end());
	}

	// 2. 새 부모로 교체
	childRelation.parent = (entt::entity)newParent;

	// 3. 새 부모의 children 목록에 추가
	auto &parentRelation = newParent.getComponent<RelationshipComponent>();
	parentRelation.children.push_back((entt::entity)child);

	// 4. 자식의 위치를 부모 기준 local좌표로 변환
	auto &tc = child.getComponent<TransformComponent>();
	glm::mat4 parentWorld = newParent.getComponent<TransformComponent>().m_WorldTransform; // 부모의 월드 매트릭스
	glm::mat4 childWorld = child.getComponent<TransformComponent>().m_WorldTransform;	   // 자식의 현재 월드 매트릭스
	glm::mat4 childLocalMat = glm::inverse(parentWorld) * childWorld;

	decomposeMatrix(childLocalMat, tc.m_Scale, tc.m_Rotation, tc.m_Position);
}

// 오른쪽 클릭으로 Popup 활성화
if (ImGui::BeginPopupContextWindow(0, ImGuiPopupFlags_MouseButtonRight | ImGuiPopupFlags_NoOpenOverItems))
{
	if (ImGui::MenuItem("Create Empty"))
		m_Context->createEntity("Empty");

	if (ImGui::BeginMenu("3D Object"))
	{
		if (ImGui::MenuItem("Box"))
			m_Context->createPrimitiveMeshEntity("Box", 1);
		if (ImGui::MenuItem("Sphere"))
			m_Context->createPrimitiveMeshEntity("Sphere", 2);
		if (ImGui::MenuItem("Plane"))
			m_Context->createPrimitiveMeshEntity("Plane", 3);
		if (ImGui::MenuItem("Ground"))
			m_Context->createPrimitiveMeshEntity("Ground", 4);
		if (ImGui::MenuItem("Capsule"))
			m_Context->createPrimitiveMeshEntity("Capsule", 5);
		if (ImGui::MenuItem("Cylinder"))
			m_Context->createPrimitiveMeshEntity("Cylinder", 6);
		ImGui::EndMenu();
	}
	ImGui::EndPopup();
}

Entity Scene::createPrimitiveMeshEntity(const std::string &name, uint32_t idx)
{
	Entity entity = createEntity(name);

	auto &mc = entity.addComponent<MeshRendererComponent>();
	
	// Scene이 생성될 때, 기본 도형을 만들어 보관한다.
	std::shared_ptr<Model> &model = getDefaultModel(idx);

	mc.type = idx;
	mc.m_RenderingComponent = RenderingComponent::createRenderingComponent(model);
	mc.cullSphere = mc.m_RenderingComponent->getCullSphere();

	insertEntityInCullTree(entity);

	return entity;
}

// drawEntityNode에서 작성
ImGui::Begin("Inspector");
if (m_SelectionContext)
{
	drawComponents(m_SelectionContext);
}
ImGui::End();

void SceneHierarchyPanel::drawComponents(Entity entity)
{
	if (entity.hasComponent<TagComponent>())
	{
		auto &tc = entity.getComponent<TagComponent>();
		auto &tag = tc.m_Tag;

		char buffer[256];
		memset(buffer, 0, sizeof(buffer));
		strncpy_s(buffer, sizeof(buffer), tag.c_str(), sizeof(buffer));

		std::string label = "##Tag" + std::to_string(entity.getUUID());

		if (ImGui::Checkbox("##Active", &tc.m_selfActive))
		{
			// 자식 엔티티일 경우 부모의 effective 활성 상태를 사용하여 업데이트
			bool parentEffectiveActive = true;
			auto &rc = entity.getComponent<RelationshipComponent>();
			if (rc.parent != entt::null)
			{
				Entity parent{rc.parent, m_Context.get()};
				parentEffectiveActive = parent.getComponent<TagComponent>().m_isActive;
			}
			updateActiveInfo(entity, parentEffectiveActive);
		}

		ImGui::SameLine();

		// ## 뒤의 text는 ImGui 내부의 ID로 사용.
		if (ImGui::InputText(label.c_str(), buffer, sizeof(buffer)))
		{
			tag = std::string(buffer);
		}
	}
	// ...
}

void SceneHierarchyPanel::drawComponents(Entity entity)
{
	//...

	if (ImGui::Button("Add Component"))
	{
		ImGui::OpenPopup("AddComponent");
	}

	ImGui::SetNextWindowSizeConstraints(ImVec2(300, 200), ImVec2(600, 400));
	if (ImGui::BeginPopup("AddComponent"))
	{
		const char *text = "Component";
		float windowWidth = ImGui::GetWindowSize().x;
		float textWidth = ImGui::CalcTextSize(text).x;
		float textPosX = (windowWidth - textWidth) * 0.5f;

		ImGui::SetCursorPosX(textPosX);
		ImGui::Text("%s", text);
		ImGui::Separator();

		displayAddComponentEntry<CameraComponent>("Camera");
		displayAddComponentEntry<ScriptComponent>("Script");
		displayAddComponentEntry<MeshRendererComponent>("Mesh Renderer");
		displayAddComponentEntry<LightComponent>("Light");
		displayAddComponentEntry<RigidbodyComponent>("Rigidbody");
		displayAddComponentEntry<SkeletalAnimatorComponent>("Animator");

		bool hasCollider = m_SelectionContext.hasComponent<BoxColliderComponent>() ||
						   m_SelectionContext.hasComponent<SphereColliderComponent>() ||
						   m_SelectionContext.hasComponent<CapsuleColliderComponent>() ||
						   m_SelectionContext.hasComponent<CylinderColliderComponent>();

		if (!hasCollider)
		{
			displayAddComponentEntry<BoxColliderComponent>("Box Collider");
			displayAddComponentEntry<SphereColliderComponent>("Sphere Collider");
			displayAddComponentEntry<CapsuleColliderComponent>("Capsule Collider");
			displayAddComponentEntry<CylinderColliderComponent>("Cylinder Collider");
		}

		ImGui::EndPopup();
	}
	ImGui::PopItemWidth();

	//...
}

template <typename T> void SceneHierarchyPanel::displayAddComponentEntry(const std::string &entryName)
{
	if (!m_SelectionContext.hasComponent<T>())
	{
		if (ImGui::Selectable(entryName.c_str()))
		{
			m_SelectionContext.addComponent<T>();
			ImGui::CloseCurrentPopup();
		}
	}
}

void SceneHierarchyPanel::drawComponents(Entity entity)
{

	drawComponent<ComponentType>("ComponentType", entity, [](auto &component) {
		// 그리고자 하는 UI
	});
}

template <typename T, typename UIFunction>
static void drawComponent(const std::string &name, Entity entity, UIFunction uiFunction)
{
	const ImGuiTreeNodeFlags treeNodeFlags = ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed |
											 ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_AllowItemOverlap |
											 ImGuiTreeNodeFlags_FramePadding;
	if (entity.hasComponent<T>())
	{
		auto &component = entity.getComponent<T>();
		ImVec2 contentRegionAvailable = ImGui::GetContentRegionAvail();

		ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{4, 4});
		float lineHeight = GImGui->Font->FontSize + GImGui->Style.FramePadding.y * 2.0f;
		ImGui::Separator();
		bool open = ImGui::TreeNodeEx((void *)typeid(T).hash_code(), treeNodeFlags, name.c_str());
		ImGui::PopStyleVar();

		// 컴파일 타임에 타입 비교 수행
		if (!std::is_same<T, TransformComponent>::value)
		{
			ImGui::SameLine(contentRegionAvailable.x - lineHeight * 0.5f);
			if (ImGui::Button("+", ImVec2{lineHeight, lineHeight}))
			{
				ImGui::OpenPopup("ComponentSettings");
			}
		}

		bool removeComponent = false;
		if (ImGui::BeginPopup("ComponentSettings"))
		{
			if (ImGui::MenuItem("Remove component"))
				removeComponent = true;

			ImGui::EndPopup();
		}

		if (open)
		{
			uiFunction(component);
			ImGui::TreePop();
		}

		if (removeComponent)
			entity.removeComponent<T>();
	}
}

drawComponent<CylinderColliderComponent>("CylinderCollider", entity, [](auto &component) {

	drawVec3Control("Center", component.m_Center);
	drawFloatControl("Radius", component.m_Radius);
	drawFloatControl("Radius", component.m_Height);
	drawCheckBox("IsTrigger", component.m_IsTrigger);

});

void ContentBrowserPanel::onImGuiRender()
{
	// ...

	if (m_CurrentDirectory != std::filesystem::path(m_BaseDirectory))
	{
		if (ImGui::Button("<-"))
		{
			m_CurrentDirectory = m_CurrentDirectory.parent_path();
		}
	}

	// ...

	for (auto &directoryEntry : std::filesystem::directory_iterator(m_CurrentDirectory))
	{
		const auto &path = directoryEntry.path();

		if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
		{
			if (directoryEntry.is_directory())
				m_CurrentDirectory /= path.filename();

		}
	}

	// ...
}

for (auto &directoryEntry : std::filesystem::directory_iterator(m_CurrentDirectory))
{
	const auto &path = directoryEntry.path();

	ImTextureID icon = directoryEntry.is_directory() ? reinterpret_cast<ImTextureID>(directoryDescriptorSet)
														: reinterpret_cast<ImTextureID>(fileDescriptorSet);
	ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0, 0, 0, 0));
	ImGui::ImageButton("Icon", icon, {thumbnailSize, thumbnailSize}, {0, 1}, {1, 0});

	if (ImGui::BeginDragDropSource())
	{
		std::filesystem::path relativePath(path);
		const wchar_t *itemPath = relativePath.c_str();
		// KeyString - Value(itemPath) 어디서든 사용 가능
		ImGui::SetDragDropPayload("CONTENT_BROWSER_ITEM", itemPath, (wcslen(itemPath) + 1) * sizeof(wchar_t));
		ImGui::EndDragDropSource();
	}

}

// SceneHierarchyPanel::drawComponents(Entity entity)

if (ImGui::BeginDragDropTarget())
{
	if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("CONTENT_BROWSER_ITEM"))
	{
		// ...
	}
	ImGui::EndDragDropTarget();
}