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

include/Engine/Rendering/Model.h

@@ -13,7 +13,7 @@ private:
 
 public:
 	~Model();
-    const std::vector<RawModel::MaterialGroup>& TextureGroups() const { return m_RawModel->TextureGroups; }
+    const std::vector<RawModel::MaterialGroup>& MaterialGroups() const { return m_RawModel->MaterialGroups; }
     const glm::mat4& Matrix() const { return m_RawModel->m_Matrix; }
     const std::vector<RawModel::Vertex>& Vertices() const { return m_RawModel->m_Vertices; }
 

include/Engine/Rendering/ModelJob.h

@@ -15,16 +15,16 @@
 
 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::Model::MaterialGroup texGroup, ComponentWrapper modelComponent, World* world)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialGroup matGroup, ComponentWrapper modelComponent, World* world)
         : RenderJob()
     {
         Model = model;
-        TextureID = (texGroup.Texture) ? texGroup.Texture->ResourceID : 0;
+        TextureID = (matGroup.Texture) ? matGroup.Texture->ResourceID : 0;
-        DiffuseTexture = texGroup.Texture.get();
+        DiffuseTexture = matGroup.Texture.get();
-        NormalTexture = texGroup.NormalMap.get();
+        NormalTexture = matGroup.NormalMap.get();
-        SpecularTexture = texGroup.SpecularMap.get();
+        SpecularTexture = matGroup.SpecularMap.get();
-        StartIndex = texGroup.StartIndex;
+        StartIndex = matGroup.StartIndex;
-        EndIndex = texGroup.EndIndex;
+        EndIndex = matGroup.EndIndex;
         Matrix = matrix;
         Color = modelComponent["Color"];
         Entity = modelComponent.EntityID;

include/Engine/Rendering/RawModel.h

@@ -57,7 +57,7 @@ public:
 		unsigned int EndIndex;
 	};
 
-	std::vector<MaterialGroup> TextureGroups;
+	std::vector<MaterialGroup> MaterialGroups;
 
 	std::vector<Vertex> m_Vertices;
 	std::vector<unsigned int> m_Indices;

resources/Schema/Entities/ThreadTestMap.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Transform/>
+  </Components>
+
+  <Children>
+    <Entity>
+      <Components>
+        <c:Camera/>
+        <c:Transform>
+          <Position X="-8.58846378" Y="9.3929615" Z="14.3944101"/>
+          <Orientation X="-0.645772398" Y="-0.314115167" Z="-4.700399e-08"/>
+        </c:Transform>
+      </Components>
+      <Children/>
+    </Entity>
+    <Entity>
+      <Components>
+        <c:Model>
+          <Resource></Resource>
+        </c:Model>
+        <c:Transform/>
+      </Components>
+      <Children/>
+    </Entity>
+  </Children>
+
+</Entity>

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);
+        //Lock the mutex immediately, and unlock it when leaving the code block.
-        resource->ResourceID = GetNewResourceID(resource->TypeID);
+        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) {
+        for (auto matGroup : model->MaterialGroups()) {
-            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, texGroup, modelComponent, world));
+            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
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->TextureGroups()[0].StartIndex);
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
 }
 
 void Renderer::InitializeTextures()