Better handling for finding modules by file path. Mainly used in asset importer

Engine/source/T3D/assets/assetImporter.cpp

@@ -666,18 +666,13 @@ AssetImportObject* AssetImporter::findImportingAssetByName(String assetName, Ass
 
 ModuleDefinition* AssetImporter::getModuleFromPath(Torque::Path filePath)
 {
-   U32 folderCount = StringUnit::getUnitCount(filePath.getPath().c_str(), "/");
+   //We want to ensure it's a full filepath, because the module system internally uses full paths for the module dirs
+   char fullPath[2048];
+   Platform::makeFullPathName(filePath.getFullPath().c_str(), fullPath, sizeof(fullPath));
 
-   for (U32 i = 0; i < folderCount; i++)
-   {
-      String folderName = StringUnit::getUnit(filePath.getPath().c_str(), i, "/");
+   ModuleDefinition* moduleDef = ModuleDatabase.findModuleByFilePath(StringTable->insert(fullPath));
 
-      ModuleDefinition* moduleDef = ModuleDatabase.findModule(folderName.c_str(), 1);
-      if (moduleDef != nullptr)
-         return moduleDef;
-   }
-
-   return nullptr;
+   return moduleDef;
 }
 
 String AssetImporter::parseImageSuffixes(String assetName, String* suffixType)

Engine/source/module/moduleManager.cpp

@@ -1058,6 +1058,42 @@ ModuleDefinition* ModuleManager::findModule( const char* pModuleId, const U32 ve
 
 //-----------------------------------------------------------------------------
 
+ModuleDefinition* ModuleManager::findModuleByFilePath(StringTableEntry filePath)
+{
+   // Sanity!
+   AssertFatal(filePath != StringTable->EmptyString(), "Cannot find module with an empty filePath.");
+
+   String desiredPath = filePath;
+   StringTableEntry coreModuleId = StringTable->insert("CoreModule");
+   StringTableEntry toolsModuleId = StringTable->insert("ToolsModule");
+
+   for (typeModuleIdDatabaseHash::iterator moduleIdItr = mModuleIdDatabase.begin(); moduleIdItr != mModuleIdDatabase.end(); ++moduleIdItr)
+   {
+      // Fetch module definition entry.
+      ModuleDefinitionEntry* pModuleDefinitionEntry = moduleIdItr->value;
+
+      for (typeModuleDefinitionVector::iterator moduleDefinitionItr = pModuleDefinitionEntry->begin(); moduleDefinitionItr != pModuleDefinitionEntry->end(); ++moduleDefinitionItr)
+      {
+         // Fetch module definition.
+         ModuleDefinition* pModuleDefinition = *moduleDefinitionItr;
+
+         Torque::Path modulePath = pModuleDefinition->getModulePath();
+
+         StringTableEntry asdasd = StringTable->insert(modulePath.getFullPath());
+
+         //We don't deal with CoreModule or ToolsModule having assets for now
+         if (desiredPath.startsWith(asdasd) && pModuleDefinition->mModuleId != coreModuleId)
+         {
+            return pModuleDefinition;
+         }
+      }
+   }
+
+   return nullptr;
+}
+
+//-----------------------------------------------------------------------------
+
 ModuleDefinition* ModuleManager::findLoadedModule( const char* pModuleId )
 {
     // Sanity!

Engine/source/module/moduleManager.h

@@ -173,6 +173,7 @@ public:
 
     /// Module type enumeration.
     ModuleDefinition* findModule( const char* pModuleId, const U32 versionId );
+    ModuleDefinition* findModuleByFilePath(StringTableEntry filePath);
     ModuleDefinition* findLoadedModule( const char* pModuleId );
     void findModules( const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions );
     void findModuleTypes( const char* pModuleType, const bool loadedOnly, typeConstModuleDefinitionVector& moduleDefinitions );

Engine/source/module/moduleManager_ScriptBinding.h

@@ -133,6 +133,24 @@ DefineEngineMethod(ModuleManager, findModule, String, (const char* pModuleId, U3
 
 //-----------------------------------------------------------------------------
 
+DefineEngineMethod(ModuleManager, findModuleByFilePath, String, (const char* filePath), (""),
+   "Find the specific module Id optionally at the specified version Id.\n"
+   "@param moduleId The module Id to find.\n"
+   "@param versionId The version Id to find.\n"
+   "@return The module definition object or NULL if not found.\n")
+{
+   // Find module definition.
+   ModuleDefinition* pModuleDefinition = object->findModuleByFilePath(StringTable->insert(filePath));
+
+   // Return nothing if not found.
+   if (pModuleDefinition == NULL)
+      return StringTable->EmptyString();
+
+   return pModuleDefinition->getIdString();
+}
+
+//-----------------------------------------------------------------------------
+
 DefineEngineMethod(ModuleManager, findModules, String, (bool loadedOnly), (false),
    "Find all the modules registered with the specified loaded state.\n"
    "@param loadedOnly Whether to return only modules that are loaded or not.\n"