To server

DeerStudio/headers/DeerStudio/StudioAPI.h

@@ -19,7 +19,7 @@ namespace Deer {
 		int32_t resourceFolder_getSubFolderCount(int32_t&);
 		int32_t resourceFolder_getSubfolderByIndex(int32_t, int32_t&);
 		int32_t resourceFolder_getResourceCount(int32_t&);
-		int32_t resourceFolder_getResourceIdByIndex(int32_t&);
+		ResourceId resourceFolder_getResourceIdByIndex(int32_t, int32_t&);
 
 		std::string resourceId_getName(ResourceId&);
 		std::string resourceId_getPath(ResourceId&);

DeerStudio/src/DeerStudio/StudioAPI.cpp

@@ -10,20 +10,122 @@
 #include "scriptdictionary.h"
 
 namespace Deer {
-	int32_t StudioAPI::getResourceFolder(std::string& path) {
+	namespace StudioResources {
-	}
+		extern std::vector<ResourceInformation> resources;
-	bool StudioAPI::resourceFolder_isValid(int32_t&);
+		extern std::unordered_map<std::string, size_t> resourcePathToIndex;
-	bool StudioAPI::resourceFolder_isRoot(int32_t&);
+		extern std::unordered_map<uint32_t, size_t> resourceIdToIndex;
-	std::string StudioAPI::resourceFolder_getName(int32_t&);
-	std::string StudioAPI::resourceFolder_getFullPath(int32_t&);
-	int32_t StudioAPI::resourceFolder_getParentFolder(int32_t&);
-	int32_t StudioAPI::resourceFolder_getSubFolderCount(int32_t&);
-	int32_t StudioAPI::resourceFolder_getSubfolderByIndex(int32_t, int32_t&);
-	int32_t StudioAPI::resourceFolder_getResourceCount(int32_t&);
-	int32_t StudioAPI::resourceFolder_getResourceIdByIndex(int32_t&);
 
-	std::string StudioAPI::resourceId_getName(ResourceId&);
+		extern std::vector<FolderInfo> folders;
-	std::string StudioAPI::resourceId_getPath(ResourceId&);
+		extern std::unordered_map<std::string, size_t> folderPathToFolderIndex;
-	int32_t StudioAPI::resourceId_getFolder(ResourceId&);
+	} // namespace StudioResources
-	ResourceType StudioAPI::resourceId_getType(ResourceId&);
+
+	int32_t StudioAPI::getResourceFolder(std::string& path) {
+		if (!StudioResources::folderPathToFolderIndex.contains(path))
+			return -1;
+		return StudioResources::folderPathToFolderIndex[path];
+	}
+
+	bool StudioAPI::resourceFolder_isValid(int32_t& folderIndex) {
+		return folderIndex >= 0;
+	}
+
+	bool StudioAPI::resourceFolder_isRoot(int32_t& folderIndex) {
+		return folderIndex == 0;
+	}
+
+	std::string StudioAPI::resourceFolder_getName(int32_t& folderIndex) {
+		if (folderIndex < 0) {
+			return "NULL";
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+		return folderInfo.name;
+	}
+
+	std::string StudioAPI::resourceFolder_getFullPath(int32_t& folderIndex) {
+		if (folderIndex < 0) {
+			return "NULL";
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+		return folderInfo.fullPath;
+	}
+
+	int32_t StudioAPI::resourceFolder_getParentFolder(int32_t& folderIndex) {
+		if (folderIndex <= 0) {
+			return 0;
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+
+		return getResourceFolder(folderInfo.fullPath);
+	}
+
+	int32_t StudioAPI::resourceFolder_getSubFolderCount(int32_t& folderIndex) {
+		if (folderIndex < 0) {
+			return 0;
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+		return folderInfo.subfolders.size();
+	}
+
+	int32_t StudioAPI::resourceFolder_getSubfolderByIndex(int32_t subFolderIndex, int32_t& folderIndex) {
+		if (folderIndex < 0) {
+			return 0;
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+		return getResourceFolder(folderInfo.subfolders[subFolderIndex]);
+	}
+
+	int32_t StudioAPI::resourceFolder_getResourceCount(int32_t& folderIndex) {
+		if (folderIndex < 0) {
+			return 0;
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+		return folderInfo.resources.size();
+	}
+
+	ResourceId StudioAPI::resourceFolder_getResourceIdByIndex(int32_t resourceIndex, int32_t& folderIndex) {
+		if (folderIndex < 0) {
+			return 0;
+		}
+
+		FolderInfo& folderInfo = StudioResources::folders[folderIndex];
+		return folderInfo.resources[resourceIndex];
+	}
+
+	std::string StudioAPI::resourceId_getName(ResourceId& resourceId) {
+		ResourceInformation* data = StudioResources::getResourceInfoFromId(resourceId);
+		if (!data)
+			return "NULL";
+
+		return data->resourceName;
+	}
+
+	std::string StudioAPI::resourceId_getPath(ResourceId& resourceId) {
+		ResourceInformation* data = StudioResources::getResourceInfoFromId(resourceId);
+		if (!data)
+			return "NULL";
+
+		return data->resourcePath;
+	}
+
+	int32_t StudioAPI::resourceId_getFolder(ResourceId& resourceId) {
+		ResourceInformation* data = StudioResources::getResourceInfoFromId(resourceId);
+		if (!data)
+			return -1;
+
+		return getResourceFolder(data->folderPath);
+	}
+
+	ResourceType StudioAPI::resourceId_getType(ResourceId& resourceId) {
+		ResourceInformation* data = StudioResources::getResourceInfoFromId(resourceId);
+		if (!data)
+			return ResourceType::NONE;
+
+		return data->resourceType;
+	}
 } // namespace Deer

DeerStudio/src/DeerStudio/StudioResources.cpp

@@ -56,7 +56,12 @@ namespace Deer {
 		void registerResource(ResourceInformation& resource, size_t index);
 		FolderInfo& getCreateFolderInfo(std::string folderStr);
 
-		ResourceType getResourceType(const std::string& dir) {
+		void clearFolderContent();
+
+		ResourceType getResourceType(const std::string& dir);
+	} // namespace StudioResources
+
+	ResourceType StudioResources::getResourceType(const std::string& dir) {
 		Path path(dir);
 		std::string extension = path.extension().string();
 
@@ -74,7 +79,12 @@ namespace Deer {
 
 		return ResourceType::NONE;
 	};
-	} // namespace StudioResources
+
+	void StudioResources::clearFolderContent() {
+		for (FolderInfo& folder : folders) {
+			folder.resources.clear();
+		}
+	}
 
 	FolderInfo* StudioResources::getFolderInfoFromPath(std::string path) {
 		if (!folderPathToFolderIndex.contains(path))
@@ -97,7 +107,21 @@ namespace Deer {
 		return &resources[resourceIdToIndex[resource]];
 	}
 
-	FolderInfo& getCreateFolderInfo(std::string folderStr) {
+	FolderInfo& StudioResources::getCreateFolderInfo(std::string folderStr) {
+		// If size == 0, we create the root folder
+		if (folders.size() == 0) {
+			Path resourcePath("Resources");
+
+			FolderInfo rootFolder{
+			    .name = "Resources",
+			    .parent = "",
+			    .fullPath = "",
+			};
+
+			folders.push_back(rootFolder);
+			folderPathToFolderIndex[""] = 0;
+		}
+
 		FolderInfo* folderInfo;
 		if (folderPathToFolderIndex.contains(folderStr)) {
 			size_t folderIndex = folderPathToFolderIndex[folderStr];
@@ -114,11 +138,6 @@ namespace Deer {
 			folders.push_back(newFolder);
 			folderInfo = &folders.back();
 			folderPathToFolderIndex[folderStr] = folders.size() - 1;
-
-			if (!folderStr.empty()) {
-				FolderInfo& parentPathInfo = getCreateFolderInfo(folderInfo->parent);
-				parentPathInfo.subfolders.push_back(folderStr);
-			}
 		}
 
 		return *folderInfo;
@@ -143,8 +162,7 @@ namespace Deer {
 		resourcePathToIndex.clear();
 		resourceIdToIndex.clear();
 
-		folders.clear();
+		clearFolderContent();
-		folderPathToFolderIndex.clear();
 
 		Path resourcePath("Resources");
 		Path resourceJsonPath = resourcePath / "ResourceData.json";

DeerStudio/src/DeerStudio/StudioScripting.cpp

@@ -14,14 +14,13 @@ namespace Deer {
 	void StudioScripting::registerStudioScripting() {
 		asIScriptEngine* scriptEngine = Scripting::getScriptEngine();
 
-		scriptEngine->RegisterEnum("Resources");
+		scriptEngine->RegisterEnum("ResourceType");
 		scriptEngine->RegisterEnumValue("ResourceType", "None", (int)ResourceType::NONE);
 		scriptEngine->RegisterEnumValue("ResourceType", "Mesh", (int)ResourceType::MESH);
 		scriptEngine->RegisterEnumValue("ResourceType", "Shader", (int)ResourceType::SHADER);
 		scriptEngine->RegisterEnumValue("ResourceType", "Texture", (int)ResourceType::TEXTURE);
-		scriptEngine->SetDefaultNamespace("");
 
-		scriptEngine->SetDefaultNamespace("StudioResources");
+		scriptEngine->SetDefaultNamespace("Resources");
 		scriptEngine->RegisterGlobalFunction("GPUMesh loadGPUMesh(StorageId)", asFUNCTION(ResourceManager<GPUMesh>::loadResource<EditorDataSource>), asCALL_CDECL);
 		scriptEngine->RegisterGlobalFunction("Shader loadShader(StorageId)", asFUNCTION(ResourceManager<Shader>::loadResource<EditorDataSource>), asCALL_CDECL);
 		scriptEngine->RegisterGlobalFunction("Texture loadTexture(StorageId)", asFUNCTION(ResourceManager<Texture>::loadResource<EditorDataSource>), asCALL_CDECL);