The main thread is not mutex blocked while child threads load anymore.

src/Engine/Core/ResourceManager.cpp

@@ -81,8 +81,6 @@ void ResourceManager::Update()
 
 Resource* ResourceManager::createResource(std::string resourceType, std::string resourceName, Resource* parent)
 {
-    //Lock the mutex immediately, and unlock it when leaving the function.
-    boost::lock_guard<decltype(m_Mutex)> guard(m_Mutex);
 	auto facIt = m_FactoryFunctions.find(resourceType);
 	if (facIt == m_FactoryFunctions.end()) {
 		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": type not registered", resourceName.c_str(), resourceType.c_str());
@@ -98,23 +96,29 @@ Resource* ResourceManager::createResource(std::string resourceType, std::string
     } catch (const std::exception& e) {
 		LOG_ERROR("Failed to load resource \"%s\" of type \"%s\": %s", resourceName.c_str(), resourceType.c_str(), e.what());
     }
-    if (resource != nullptr) {
-        // Store IDs
-        resource->TypeID = GetTypeID(resourceType);
-        resource->ResourceID = GetNewResourceID(resource->TypeID);
+
+    {
+        //Lock the mutex immediately, and unlock it when leaving the code block.
+        boost::lock_guard<decltype(m_Mutex)> guard(m_Mutex);
+        if (resource != nullptr) {
+            // Store IDs
+            resource->TypeID = GetTypeID(resourceType);
+            resource->ResourceID = GetNewResourceID(resource->TypeID);
+        }
+
+        // Cache
+        m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;
+        m_ResourceFromName[resourceName] = resource;
+        if (parent != nullptr) {
+            m_ResourceParents[resource] = parent;
+        }
+
+        if (!boost::filesystem::is_directory(resourceName)) {
+            LOG_DEBUG("Adding watch for %s", resourceName.c_str());
+            m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);
+        }
     }
 
-	// Cache
-	m_ResourceCache[std::make_pair(resourceType, resourceName)] = resource;
-	m_ResourceFromName[resourceName] = resource;
-	if (parent != nullptr) {
-		m_ResourceParents[resource] = parent;
-	}
-
-	if (!boost::filesystem::is_directory(resourceName)) {
-		LOG_DEBUG("Adding watch for %s", resourceName.c_str());
-		m_FileWatcher.AddWatch(resourceName, fileWatcherCallback);
-	}
 	return resource;
 }
 

src/Engine/Rendering/Model.cpp

@@ -9,7 +9,7 @@ Model::Model(std::string fileName)
         throw StillLoadingException();
     }
 
-    for (auto& group : m_RawModel->TextureGroups) {
+    for (auto& group : m_RawModel->MaterialGroups) {
         if (!group.TexturePath.empty()) {
             group.Texture = std::shared_ptr<Texture>(ResourceManager::Load<Texture>(group.TexturePath));
         }

src/Engine/Rendering/RawModel.cpp

@@ -163,7 +163,7 @@ RawModel::RawModel(std::string fileName)
 			material->GetTexture(aiTextureType_SPECULAR, 0, &path, &mapping);
             matGroup.SpecularMapPath = (boost::filesystem::path(fileName).branch_path() / path.C_Str()).string();
 		}
-		TextureGroups.push_back(matGroup);
+		MaterialGroups.push_back(matGroup);
 
 		// Bones
 		std::map<int, std::vector<std::tuple<int, float>>> vertexWeights;

src/Engine/Rendering/RenderSystem.cpp

@@ -84,15 +84,15 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World
             continue;
         }
 
-        Model* model = ResourceManager::Load<::Model>(resource);
+        Model* model = ResourceManager::Load<::Model, true>(resource);
         if (model == nullptr) {
             model = ResourceManager::Load<::Model>("Models/Core/Error.obj");
         }
 
         glm::mat4 modelMatrix = Transform::ModelMatrix(modelComponent.EntityID, world);
         
-        for (auto texGroup : model->TextureGroups) {
-            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, texGroup, modelComponent, world));
+        for (auto matGroup : model->MaterialGroups()) {
+            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, matGroup, modelComponent, world));
             jobs.push_back(modelJob);
         }
     }

src/Engine/Rendering/Renderer.cpp

@@ -131,8 +131,8 @@ void Renderer::DrawScreenQuad(GLuint textureToDraw)
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->TextureGroups()[0].EndIndex - m_ScreenQuad->TextureGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->TextureGroups()[0].StartIndex);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
 }
 
 void Renderer::InitializeTextures()