added inventory & active object

2026-04-09 15:33:55 +06:00
1 parent e1b491be73
commit b3fda88784
@@ -50,6 +50,17 @@ namespace ZL {

 				data.scale = item.value("scale", 1.0f);

+				// Interactive object properties
+				data.interactive = item.value("interactive", false);
+				if (data.interactive && item.contains("item") && item["item"].is_object()) {
+					const auto& itemData = item["item"];
+					data.itemId = itemData.value("id", "");
+					data.itemName = itemData.value("name", "Unknown Item");
+					data.itemDescription = itemData.value("description", "");
+					data.itemIcon = itemData.value("icon", "");
+					data.interactionRadius = itemData.value("radius", 2.0f);
+				}
+
 				if (!data.meshPath.empty()) {
 					objects.push_back(data);
 				}
@@ -73,6 +84,8 @@ namespace ZL {
 		std::vector<GameObjectData> objectsData = loadFromJson(jsonPath, zipPath);

 		for (const auto& objData : objectsData) {
+			if (objData.interactive) continue; // Skip interactive objects, they're handled separately
+
 			std::cout << "Loading game object: " << objData.name << std::endl;

 			LoadedGameObject gameObj;
@@ -131,4 +144,104 @@ namespace ZL {
 		return gameObjects;
 	}

+	std::vector<InteractiveObject> GameObjectLoader::loadAndCreateInteractiveObjects(
+		const std::string& jsonPath,
+		Renderer& renderer,
+		const std::string& zipPath)
+	{
+		std::vector<InteractiveObject> interactiveObjects;
+		std::vector<GameObjectData> objectsData = loadFromJson(jsonPath, zipPath);
+
+		for (const auto& objData : objectsData) {
+			if (!objData.interactive) continue;
+
+			std::cout << "Loading interactive object: " << objData.name << std::endl;
+
+			InteractiveObject intObj;
+			intObj.id = objData.name;
+			intObj.name = objData.name;
+			intObj.interactionRadius = objData.interactionRadius;
+
+			// Load texture
+			try {
+				intObj.texture = std::make_shared<Texture>(CreateTextureDataFromPng(objData.texturePath, zipPath.c_str()));
+			}
+			catch (const std::exception& e) {
+				std::cerr << "GameObjectLoader: Failed to load texture for interactive '" << objData.name << "': " << e.what() << std::endl;
+				continue;
+			}
+
+			// Load mesh
+			try {
+				intObj.mesh.data = LoadFromTextFile02(objData.meshPath, zipPath);
+			}
+			catch (const std::exception& e) {
+				std::cerr << "GameObjectLoader: Failed to load mesh for interactive '" << objData.name << "': " << e.what() << std::endl;
+				continue;
+			}
+
+			// Apply rotation
+			Eigen::Quaternionf rotationQuat = Eigen::Quaternionf::Identity();
+
+			if (objData.rotationX != 0.0f) {
+				rotationQuat = Eigen::Quaternionf(Eigen::AngleAxisf(objData.rotationX, Eigen::Vector3f::UnitX())) * rotationQuat;
+			}
+			if (objData.rotationY != 0.0f) {
+				rotationQuat = Eigen::Quaternionf(Eigen::AngleAxisf(objData.rotationY, Eigen::Vector3f::UnitY())) * rotationQuat;
+			}
+			if (objData.rotationZ != 0.0f) {
+				rotationQuat = Eigen::Quaternionf(Eigen::AngleAxisf(objData.rotationZ, Eigen::Vector3f::UnitZ())) * rotationQuat;
+			}
+
+			intObj.mesh.data.RotateByMatrix(rotationQuat.toRotationMatrix());
+
+			// Apply scale
+			if (objData.scale != 1.0f) {
+				intObj.mesh.data.Scale(objData.scale);
+			}
+
+			intObj.mesh.RefreshVBO();
+
+			// Calculate mesh bounds to properly offset position
+			if (!intObj.mesh.data.PositionData.empty()) {
+				Eigen::Vector3f meshMin = intObj.mesh.data.PositionData[0];
+				Eigen::Vector3f meshMax = intObj.mesh.data.PositionData[0];
+				
+				for (const auto& vert : intObj.mesh.data.PositionData) {
+					meshMin = meshMin.cwiseMin(vert);
+					meshMax = meshMax.cwiseMax(vert);
+				}
+				
+				Eigen::Vector3f meshCenter = (meshMin + meshMax) * 0.5f;
+				std::cout << "[LOADER] Mesh bounds:" << std::endl;
+				std::cout << "  Min: (" << meshMin.x() << ", " << meshMin.y() << ", " << meshMin.z() << ")" << std::endl;
+				std::cout << "  Max: (" << meshMax.x() << ", " << meshMax.y() << ", " << meshMax.z() << ")" << std::endl;
+				std::cout << "  Center: (" << meshCenter.x() << ", " << meshCenter.y() << ", " << meshCenter.z() << ")" << std::endl;
+				
+				// Translate mesh so it's centered at origin
+				intObj.mesh.data.Move(-meshCenter);
+				intObj.mesh.RefreshVBO();
+				
+				// Adjust position to account for mesh offset
+				intObj.position = Eigen::Vector3f(objData.positionX, objData.positionY, objData.positionZ) + meshCenter;
+				
+				std::cout << "[LOADER] Corrected position: (" << intObj.position.x() << ", " 
+					      << intObj.position.y() << ", " << intObj.position.z() << ")" << std::endl;
+			} else {
+				// Fallback if no vertices
+				intObj.position = Eigen::Vector3f(objData.positionX, objData.positionY, objData.positionZ);
+			}
+
+			// Create item
+			intObj.dropItem = Item(objData.itemId, objData.itemName, objData.itemDescription, objData.itemIcon);
+
+			interactiveObjects.push_back(intObj);
+
+			std::cout << "Successfully loaded interactive: " << objData.name << " (item: " << objData.itemName << ")" << std::endl;
+		}
+
+		std::cout << "Total interactive objects loaded: " << interactiveObjects.size() << std::endl;
+		return interactiveObjects;
+	}
+
 } // namespace ZL