Both DX and GL versions load up and work fine even with multithreading

CamelotClient/CamelotClient.cpp

@@ -27,8 +27,8 @@ using namespace CamelotEngine;
 
 int _tmain(int argc, _TCHAR* argv[])
 {
-	//gApplication().startUp("CamelotGLRenderSystem", "CamelotForwardRenderer");
-	gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
+	gApplication().startUp("CamelotGLRenderSystem", "CamelotForwardRenderer");
+	//gApplication().startUp("CamelotD3D9RenderSystem", "CamelotForwardRenderer");
 
 	RenderSystem* renderSystem = RenderSystemManager::getActive();
 	RenderWindow* renderWindow = gApplication().getPrimaryRenderWindow();

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -358,6 +358,9 @@ namespace CamelotEngine
 						size_t logicalIndex = i->first;
 						TextureHandle texture = params->getTexture(i->second.physicalIndex);
 
+						if(!texture.isLoaded())
+							continue;
+
 						const SamplerState& samplerState = params->getSamplerState(i->second.physicalIndex);
 
 						setTextureUnitSettings_internal(logicalIndex, texture.getInternalPtr(), samplerState);

CamelotForwardRenderer/Source/CmForwardRenderer.cpp

@@ -26,13 +26,11 @@ namespace CamelotEngine
 
 	void ForwardRenderer::renderAll() 
 	{
-		return; // TODO - Temporarily I don't want to run this
-
 		RenderSystem* renderSystem = RenderSystemManager::getActive();
 
 		// TODO - No point in setting these each frame?
-		renderSystem->setInvertVertexWinding_internal(false);
-		renderSystem->setDepthBufferParams_internal();
+		renderSystem->setInvertVertexWinding(false);
+		renderSystem->setDepthBufferParams();
 
 		const vector<CameraPtr>::type& allCameras = gSceneManager().getAllCameras();
 		for(auto iter = allCameras.begin(); iter != allCameras.end(); ++iter)
@@ -48,15 +46,15 @@ namespace CamelotEngine
 		vector<RenderablePtr>::type allRenderables = gSceneManager().getVisibleRenderables(camera);
 
 		RenderSystem* renderSystem = RenderSystemManager::getActive();
-		renderSystem->setViewport_internal(*camera->getViewport());
+		renderSystem->setViewport(*camera->getViewport());
 
 		Matrix4 projMatrixCstm = camera->getProjectionMatrix();
 		Matrix4 viewMatrixCstm = camera->getViewMatrix();
 
 		Matrix4 viewProjMatrix = projMatrixCstm * viewMatrixCstm;
 
-		renderSystem->clearFrameBuffer_internal(FBT_COLOUR | FBT_DEPTH, Color::Blue);
-		renderSystem->beginFrame_internal();
+		renderSystem->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH, Color::Blue);
+		renderSystem->beginFrame();
 
 		// TODO - sort renderables by material/pass/parameters to minimize state changes
 		for(auto iter = allRenderables.begin(); iter != allRenderables.end(); ++iter)
@@ -81,11 +79,11 @@ namespace CamelotEngine
 				setPass(material->getPass(i));
 				setPassParameters(material->getPassParameters(i));
 
-				renderSystem->render_internal(mesh->getRenderOperation());
+				renderSystem->render(mesh->getRenderOperation());
 			}
 		}
 
-		renderSystem->endFrame_internal();
+		renderSystem->endFrame();
 
 		// TODO - Sort renderables
 		// Render them
@@ -138,7 +136,7 @@ namespace CamelotEngine
 		// Set scene blending
 		if ( pass->hasSeparateSceneBlending( ) )
 		{
-			renderSystem->setSeparateSceneBlending_internal(
+			renderSystem->setSeparateSceneBlending(
 				pass->getSourceBlendFactor(), pass->getDestBlendFactor(),
 				pass->getSourceBlendFactorAlpha(), pass->getDestBlendFactorAlpha(),
 				pass->getSceneBlendingOperation(), 
@@ -148,20 +146,20 @@ namespace CamelotEngine
 		{
 			if(pass->hasSeparateSceneBlendingOperations( ) )
 			{
-				renderSystem->setSeparateSceneBlending_internal(
+				renderSystem->setSeparateSceneBlending(
 					pass->getSourceBlendFactor(), pass->getDestBlendFactor(),
 					pass->getSourceBlendFactor(), pass->getDestBlendFactor(),
 					pass->getSceneBlendingOperation(), pass->getSceneBlendingOperationAlpha() );
 			}
 			else
 			{
-				renderSystem->setSceneBlending_internal(
+				renderSystem->setSceneBlending(
 					pass->getSourceBlendFactor(), pass->getDestBlendFactor(), pass->getSceneBlendingOperation() );
 			}
 		}
 
 		// Set point parameters
-		renderSystem->setPointParameters_internal(
+		renderSystem->setPointParameters(
 			pass->getPointSize(),
 			false, 
 			false, 
@@ -178,25 +176,25 @@ namespace CamelotEngine
 
 		// Set up non-texture related material settings
 		// Depth buffer settings
-		renderSystem->setDepthBufferFunction_internal(pass->getDepthFunction());
-		renderSystem->setDepthBufferCheckEnabled_internal(pass->getDepthCheckEnabled());
-		renderSystem->setDepthBufferWriteEnabled_internal(pass->getDepthWriteEnabled());
-		renderSystem->setDepthBias_internal(pass->getDepthBiasConstant(), pass->getDepthBiasSlopeScale());
+		renderSystem->setDepthBufferFunction(pass->getDepthFunction());
+		renderSystem->setDepthBufferCheckEnabled(pass->getDepthCheckEnabled());
+		renderSystem->setDepthBufferWriteEnabled(pass->getDepthWriteEnabled());
+		renderSystem->setDepthBias(pass->getDepthBiasConstant(), pass->getDepthBiasSlopeScale());
 
 		// Alpha-reject settings
-		renderSystem->setAlphaRejectSettings_internal(
+		renderSystem->setAlphaRejectSettings(
 			pass->getAlphaRejectFunction(), pass->getAlphaRejectValue(), pass->isAlphaToCoverageEnabled());
 
 		// Set colour write mode
 		// Right now we only use on/off, not per-channel
 		bool colWrite = pass->getColourWriteEnabled();
-		renderSystem->setColorBufferWriteEnabled_internal(colWrite, colWrite, colWrite, colWrite);
+		renderSystem->setColorBufferWriteEnabled(colWrite, colWrite, colWrite, colWrite);
 
 		// Culling mode
-		renderSystem->setCullingMode_internal(pass->getCullingMode());
+		renderSystem->setCullingMode(pass->getCullingMode());
 
 		// Polygon mode
-		renderSystem->setPolygonMode_internal(pass->getPolygonMode());
+		renderSystem->setPolygonMode(pass->getPolygonMode());
 	}
 
 	void ForwardRenderer::setPassParameters(PassParametersPtr params)

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -354,6 +354,10 @@ namespace CamelotEngine {
 					|| def.constType == GCT_SAMPLER2DSHADOW || def.constType == GCT_SAMPLER3D || def.constType == GCT_SAMPLER1DSHADOW)
 				{
 					TextureHandle curTexture = params->getTexture(def.physicalIndex);
+
+					if(!curTexture.isLoaded())
+						continue;
+
 					setTexture_internal(def.physicalIndex, true, curTexture.getInternalPtr());
 
 					const SamplerState& samplerState = params->getSamplerState(def.physicalIndex);
@@ -798,8 +802,8 @@ namespace CamelotEngine {
 		// unbind GPU programs at end of frame
 		// this is mostly to avoid holding bound programs that might get deleted
 		// outside via the resource manager
-		unbindGpuProgram(GPT_VERTEX_PROGRAM);
-		unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
+		unbindGpuProgram_internal(GPT_VERTEX_PROGRAM);
+		unbindGpuProgram_internal(GPT_FRAGMENT_PROGRAM);
 	}
 
 	//-----------------------------------------------------------------------------

CamelotRenderer/Include/CmMesh.h

@@ -40,6 +40,7 @@ namespace CamelotEngine
 		 * @brief	Gets the mesh data from the GPU. This method is slow so be careful when you call it.
 		 */
 		MeshDataPtr getMeshData();
+		void getMeshData_internal(AsyncOp& asyncOp);
 
 		RenderOperation getRenderOperation(UINT32 subMeshIdx = 0) const;
 

CamelotRenderer/Source/CmMesh.cpp

@@ -7,6 +7,7 @@
 #include "CmHardwareBufferManager.h"
 #include "CmRenderSystem.h"
 #include "CmRenderSystemManager.h"
+#include "CmAsyncOp.h"
 
 #if CM_DEBUG_MODE
 #define THROW_IF_NOT_RENDER_THREAD throwIfNotRenderThread();
@@ -166,6 +167,13 @@ namespace CamelotEngine
 	}
 
 	MeshDataPtr Mesh::getMeshData()
+	{
+		AsyncOp op = RenderSystemManager::getActive()->queueResourceReturnCommand(boost::bind(&Mesh::getMeshData_internal, this, _1), true);
+
+		return op.getReturnValue<MeshDataPtr>();
+	}
+
+	void Mesh::getMeshData_internal(AsyncOp& asyncOp)
 	{
 		MeshDataPtr meshData(new MeshData());
 
@@ -276,7 +284,7 @@ namespace CamelotEngine
 			}
 		}		
 
-		return meshData;
+		asyncOp.completeOperation(meshData);
 	}
 
 	RenderOperation Mesh::getRenderOperation(UINT32 subMeshIdx) const