Asynchronous texture loading is up and running... yeiiiiiiiii!!!!!!!!!!

src/Core/AsyncLoader.cpp

@@ -54,6 +54,7 @@ void AsyncLoader::workingFunc()
 		try
 		{
 			req.loadCallback(req.filename.c_str(), req.storage);
+			INFO("File \"" << req.filename << "\" loaded");
 		}
 		catch(std::exception& e)
 		{
@@ -82,8 +83,8 @@ bool AsyncLoader::pollForFinished(std::string& filename, void* buff, bool& ok)
 		return false;
 	}
 
-	Response resp = responses.back();
-	responses.pop_back();
+	Response resp = responses.front();
+	responses.pop_front();
 	lock.unlock();
 
 	filename = resp.filename;

src/Core/Logger.cpp

@@ -2,6 +2,15 @@
 #include "Logger.h"
 
 
+//======================================================================================================================
+// operator<< [const void*]                                                                                            =
+//======================================================================================================================
+Logger& Logger::operator<<(const void* val)
+{
+	return appendUsingLexicalCast(val);
+}
+
+
 //======================================================================================================================
 // operator<< [const char*]                                                                                            =
 //======================================================================================================================

src/Main.cpp

@@ -142,9 +142,9 @@ void init()
 
 
 	// horse
-	horse = new ModelNode();
+	/*horse = new ModelNode();
 	horse->init("meshes/horse/horse.mdl");
-	horse->setLocalTransform(Transform(Vec3(-2, 0, 1), Mat3::getIdentity(), 1.0));
+	horse->setLocalTransform(Transform(Vec3(-2, 0, 1), Mat3::getIdentity(), 1.0));*/
 
 	// Sponza
 	ModelNode* sponza = new ModelNode();
@@ -152,9 +152,9 @@ void init()
 
 
 	// Pentagram
-	ModelNode* pentagram = new ModelNode();
+	/*ModelNode* pentagram = new ModelNode();
 	pentagram->init("models/pentagram/pentagram.mdl");
-	pentagram->setLocalTransform(Transform(Vec3(2, 0, 0), Mat3::getIdentity(), 1.0));
+	pentagram->setLocalTransform(Transform(Vec3(2, 0, 0), Mat3::getIdentity(), 1.0));*/
 
 
 	// Imp
@@ -314,10 +314,11 @@ void mainLoop()
 		SceneSingleton::getInstance().updateAllControllers();
 		SceneSingleton::getInstance().updateAllWorldStuff();
 		SceneSingleton::getInstance().doVisibilityTests(*AppSingleton::getInstance().getActiveCam());
-		//SceneSingleton::getInstance().doVisibilityTests(spot_lights[0]->getCamera());
 
 		MainRendererSingleton::getInstance().render(*AppSingleton::getInstance().getActiveCam());
 
+		ResourceManagerSingleton::getInstance().serveFinishedRequests(1000);
+
 		//map.octree.root->bounding_box.render();
 
 		// print some debug stuff

src/Renderer/BufferObjects/Vao.cpp

@@ -14,6 +14,8 @@ void Vao::attachArrayBufferVbo(const Vbo& vbo, uint attribVarLocation, GLint siz
 		throw EXCEPTION("Only GL_ARRAY_BUFFER is accepted");
 	}
 
+	ON_GL_FAIL_THROW_EXCEPTION();
+
 	bind();
 	vbo.bind();
 	glVertexAttribPointer(attribVarLocation, size, type, normalized, stride, pointer);

src/Renderer/SceneDrawer.cpp

@@ -178,6 +178,7 @@ void SceneDrawer::setupShaderProg(const Material& mtl, const Transform& nodeWorl
 			case GL_SAMPLER_2D:
 				if(udv.getTexture() != NULL)
 				{
+					udv.getTexture()->setRepeat(true);
 					udv.getUniVar().setTexture(*udv.getTexture(), textureUnit);
 				}
 				else

src/Resources/Core/ResourceManager.h

@@ -53,7 +53,7 @@ class ResourceManager
 		void unload(const typename Types<Type>::Hook& info);
 		
 		/// See RsrcAsyncLoadingReqsHandler::serveFinishedRequests
-		void serveFinishedRequests(uint maxTime) {rsrcAsyncLoadingReqsHandler.serveFinishedRequests();}
+		void serveFinishedRequests(uint maxTime) {rsrcAsyncLoadingReqsHandler.serveFinishedRequests(maxTime);}
 
 	private:
 		/// @name Containers
@@ -74,8 +74,8 @@ class ResourceManager
 
 		RsrcAsyncLoadingReqsHandler rsrcAsyncLoadingReqsHandler;
 		
-		/// This will be used in every new texture until the async loader is finished with the loading of tha actual
-		/// texure. Its initialized when its first needed so that we wont have colflicts with opengl initialization.
+		/// This will be used in every new texture until the async loader is finished with the loading of the actual
+		/// texture. Its initialized when its first needed so that we wont have conflicts with opengl initialization.
 		std::auto_ptr<Texture> dummyTex;
 
 		/// Find a resource using the filename
@@ -96,7 +96,7 @@ class ResourceManager
 		
 		/// Allocate and load a resource.
 		/// This method allocates memory for a resource and loads it (calls the load metod). Its been used by the load
-		/// method. Its a sepperate method because we want to specialize it for async loaded resources
+		/// method. Its a separate method because we want to specialize it for async loaded resources
 		template<typename Type>
 		void allocAndLoadRsrc(const char* filename, Type*& ptr);
 };

src/Resources/Core/ResourceManager.inl.h

@@ -46,7 +46,12 @@ typename ResourceManager::Types<Type>::Hook& ResourceManager::load(const char* f
 	// else create new, load it and update the container
 	else
 	{
-		c.push_back(new typename Types<Type>::Hook(filename, 1, allocAndLoadRsrc<Type>(filename)));
+		typename Types<Type>::Hook* hook = new typename Types<Type>::Hook;
+		hook->uuid = filename;
+		hook->referenceCounter = 1;
+		allocAndLoadRsrc<Type>(filename, hook->resource);
+
+		c.push_back(hook);
 		
 		it = c.end();
 		--it;

src/Resources/Core/RsrcAsyncLoadingReqsHandler.cpp

@@ -1,5 +1,6 @@
 #include "RsrcAsyncLoadingReqsHandler.h"
 #include "Texture.h"
+#include "Logger.h"
 
 
 //======================================================================================================================
@@ -40,7 +41,7 @@ void RsrcAsyncLoadingReqsHandler::serveFinishedRequests(uint /*maxTime*/)
 				TextureRequest& texReq = static_cast<TextureRequest&>(req);
 				Texture* tex = new Texture;
 				tex->load(texReq.getHelperObj());
-				//*texReq.getObjToLoad()->load(texReq.getHelperObj());
+				*texReq.getObjToLoad() = tex;
 				break;
 			}
 				
@@ -61,5 +62,6 @@ void RsrcAsyncLoadingReqsHandler::loadImageCallback(const char* filename, void*
 {
 	Image* img = (Image*)img_;
 	img->load(filename);
+	sleep(2);
 }
 

src/Resources/Core/RsrcHook.h

@@ -8,20 +8,10 @@
 template<typename Type>
 struct RsrcHook
 {
-	RsrcHook(const char* uuid, int reference, Type* resource);
-
 	std::string uuid; ///< Unique identifier
 	int referenceCounter;
 	Type* resource;
 };
 
 
-template<typename Type>
-RsrcHook<Type>::RsrcHook(const char* uuid_, int referenceCounter_, Type* resource_): 
-	uuid(uuid_),
-	referenceCounter(referenceCounter_),
-	resource(resource_)
-{}
-
-
 #endif

src/Resources/ShaderProg.cpp

@@ -18,9 +18,9 @@
 
 std::string ShaderProg::stdSourceCode(
 	"#version 330 core\n"
-	//"precision lowp float;\n"
-	//"#pragma optimize(on)\n"
-	//"#pragma debug(off)\n"
+	"precision lowp float;\n"
+	"#pragma optimize(on)\n"
+	"#pragma debug(off)\n"
 );
 
 

src/Scene/ModelNode.cpp

@@ -1,3 +1,4 @@
+#include <boost/foreach.hpp>
 #include "ModelNode.h"
 #include "Model.h"
 #include "Skeleton.h"
@@ -10,9 +11,9 @@ void ModelNode::init(const char* filename)
 {
 	model.loadRsrc(filename);
 
-	for(uint i = 0; i < model->getModelPatches().size(); i++)
+	BOOST_FOREACH(const ModelPatch& patch, model->getModelPatches())
 	{
-		patches.push_back(new ModelPatchNode(model->getModelPatches()[i], this));
+		patches.push_back(new ModelPatchNode(patch, this));
 	}
 }