Messing with mess initialization

Ignoring a bunch of files
Adding non-Windows files

CamelotD3D9Renderer/Include/CmD3D9Texture.h

@@ -130,7 +130,7 @@ namespace CamelotEngine {
 		void _createSurfaceList(IDirect3DDevice9* d3d9Device, TextureResources* textureResources);
 	 
 		/// Loads this texture into the specified device.
-		void load(IDirect3DDevice9* d3d9Device);
+		void loadImpl(IDirect3DDevice9* d3d9Device);
 
 		/// gets the texture resources attached to the given device.
 		TextureResources* getTextureResources(IDirect3DDevice9* d3d9Device);
@@ -157,7 +157,7 @@ namespace CamelotEngine {
 		void copyToTexture( TexturePtr& target );
 
 		/// overriden from Resource
-		void load();	
+		void loadImpl();	
 
 		/// @copydoc Texture::getBuffer
 		HardwarePixelBufferPtr getBuffer(size_t face, size_t mipmap);

CamelotD3D9Renderer/Source/CmD3D9Texture.cpp

@@ -181,7 +181,7 @@ namespace CamelotEngine
 		}		
 	}
 	/****************************************************************************************/
-	void D3D9Texture::load()
+	void D3D9Texture::loadImpl()
 	{
 		if (!mInternalResourcesCreated)
 		{
@@ -197,12 +197,12 @@ namespace CamelotEngine
 		{
 			IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getResourceCreationDevice(i);
 
-			load(d3d9Device);
+			loadImpl(d3d9Device);
 		}		
 	}
 
 	/****************************************************************************************/
-	void D3D9Texture::load(IDirect3DDevice9* d3d9Device)
+	void D3D9Texture::loadImpl(IDirect3DDevice9* d3d9Device)
 	{		
 		if (mUsage & TU_RENDERTARGET)
 		{

CamelotGLRenderer/Include/CmGLTexture.h

@@ -60,8 +60,8 @@ namespace CamelotEngine {
 		
 		void getCustomAttribute(const String& name, void* pData);
 
-		/// @copydoc Resource::load
-		void load();
+		/// @copydoc Resource::loadImpl
+		void loadImpl();
 
     protected:
 		/// @copydoc Texture::createInternalResourcesImpl

CamelotRenderer/Include/CmMesh.h

@@ -13,8 +13,12 @@ namespace CamelotEngine
 			indexOffset(0), indexCount(0)
 		{ }
 
-		int indexOffset;
-		int indexCount;
+		SubMesh(UINT32 indexOffset, UINT32 indexCount):
+			indexOffset(indexOffset), indexCount(indexCount)
+		{ }
+
+		UINT32 indexOffset;
+		UINT32 indexCount;
 	};
 
 	class Mesh : public Resource
@@ -28,7 +32,7 @@ namespace CamelotEngine
 		 */
 		void prepare(MeshDataPtr meshData);
 
-		virtual void load();
+		virtual void loadImpl();
 
 	private:
 		MeshDataPtr mMeshData;

CamelotRenderer/Include/CmResource.h

@@ -6,6 +6,12 @@
 
 namespace CamelotEngine
 {
+	enum ResourceState
+	{
+		RS_Unloaded,
+		RS_Loaded
+	};
+
 	/**
 	 * @brief	Base class for all resources used in the engine.
 	 */
@@ -13,11 +19,12 @@ namespace CamelotEngine
 	{
 	public:
 		Resource(/*const UUID& sourceUUID*/) // TODO - Temporarily don't initialize UUID, because I want texture to inherit from resource and UUIDs arent set up yet
-			:mSize(0) /*mSourceUUID(sourceUUID),*/
+			:mSize(0), mLoadState(RS_Unloaded) /*mSourceUUID(sourceUUID),*/
 		{}
 		virtual ~Resource() {};
 
-		virtual void load() = 0;
+		void load();
+		virtual void loadImpl() = 0;
 
 	protected:
 		friend class Resources;
@@ -29,6 +36,9 @@ namespace CamelotEngine
 		UUID mSourceUUID; 
 		UINT32 mSize;
 
+		// Transient
+		ResourceState mLoadState;
+
 	/************************************************************************/
 	/* 								SERIALIZATION                      		*/
 	/************************************************************************/

CamelotRenderer/Source/CmMesh.cpp

@@ -1,15 +1,22 @@
 #include "CmMesh.h"
 #include "CmMeshRTTI.h"
+#include "CmHardwareBufferManager.h"
 
 namespace CamelotEngine
 {
 	Mesh::Mesh()
+		:mVertexData(nullptr), mIndexData(nullptr)
 	{
 
 	}
 
 	Mesh::~Mesh()
 	{
+		if(mVertexData)
+			delete mVertexData;
+
+		if(mIndexData)
+			delete mIndexData;
 	}
 
 	void Mesh::prepare(MeshDataPtr meshData)
@@ -17,14 +24,142 @@ namespace CamelotEngine
 		mMeshData = meshData;
 	}
 
-	void Mesh::load()
+	void Mesh::loadImpl()
 	{
 		if(mMeshData == nullptr)
 		{
 			CM_EXCEPT(InternalErrorException, "Cannot load mesh. Mesh data hasn't been set.");
 		}
 
-		throw std::exception("The method or operation is not implemented.");
+		// Submeshes
+		for(int i = 0; i < mMeshData->subMeshes.size(); i++)
+			mSubMeshes.push_back(SubMesh(mMeshData->subMeshes[i].indexOffset, mMeshData->subMeshes[i].indexCount));
+
+		// Indices
+		mIndexData = new IndexData();
+
+		mIndexData->indexCount = mMeshData->indexCount;
+		mIndexData->indexBuffer = HardwareBufferManager::instance().createIndexBuffer(
+			HardwareIndexBuffer::IT_16BIT,
+			mIndexData->indexCount, 
+			HardwareBuffer::HBU_STATIC_WRITE_ONLY);
+
+		UINT16* idxData = static_cast<UINT16*>(mIndexData->indexBuffer->lock(HardwareBuffer::HBL_NORMAL));
+
+		for(int i = 0; i < mIndexData->indexCount; i++)
+		{
+			idxData[i] = (UINT16)mMeshData->index[i];
+		}
+
+		mIndexData->indexBuffer->unlock();
+
+		// Vertices
+		mVertexData = new VertexData();
+
+		mVertexData->vertexStart = 0;
+		mVertexData->vertexCount = mMeshData->vertexCount;
+
+		
+		//mVertexData->vertexDeclaration = mMeshData->declaration.clone();
+		//VertexDeclaration* decl = mVertexData->vertexDeclaration;
+		//decl->removeAllElements();
+
+		//size_t offset = 0;
+		//decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
+		//offset += VertexElement::getTypeSize(VET_FLOAT3);
+		//decl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);
+		//offset += VertexElement::getTypeSize(VET_FLOAT2);
+
+		//decl->addElement(0, offset, VET_COLOUR, VES_DIFFUSE);
+		//offset += VertexElement::getTypeSize(VET_COLOUR);
+
+		//HardwareVertexBufferPtr vertexBuffer = HardwareBufferManager::instance().createVertexBuffer(
+		//	mVertexData->vertexDeclaration->getVertexSize(0),
+		//	mVertexData->vertexCount,
+		//	HardwareBuffer::HBU_STATIC_WRITE_ONLY);
+
+		//mVertexData->vertexBufferBinding->setBinding(0, vertexBuffer);
+
+		//size_t vertexSize = vertexBuffer->getVertexSize();
+		//char* vertBufferData = static_cast<char*>(vertexBuffer->lock(HardwareBuffer::HBL_NORMAL));
+
+		//size_t posSize = VertexElement::getTypeSize(VET_FLOAT3);
+		//size_t uvSize = VertexElement::getTypeSize(VET_FLOAT2);
+
+		//Vector3 position(-5.0f, -5.0f, -5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//Vector2 uv(0.0f, 0.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(-5.0f, 5.0f, -5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(0.0f, 1.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(5.0f, 5.0f, -5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(1.0f, 1.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(5.0f, -5.0f, -5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(1.0f, 0.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(-5.0f, -5.0f, 5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(0.0f, 0.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(5.0f, -5.0f, 5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(1.0f, 0.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(5.0f, 5.0f, 5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(1.0f, 1.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+
+		//position = 	Vector3(-5.0f, 5.0f, 5.0f);
+		//memcpy(vertBufferData, &position, posSize);
+		//vertBufferData += posSize;
+
+		//uv = Vector2(0.0f, 1.0f);
+		//memcpy(vertBufferData, &uv, uvSize);
+		//vertBufferData += uvSize;
+
+		//vertexBuffer->unlock();
+
+		mMeshData = nullptr;
 	}
 
 	/************************************************************************/

CamelotRenderer/Source/CmResource.cpp

@@ -3,49 +3,15 @@
 
 namespace CamelotEngine
 {
-	//void Resource::unload() 
-	//{ 
-	//	// Early-out without lock (mitigate perf cost of ensuring unloaded)
-	//	LoadingState old = mLoadingState.get();
-	//	if (old!=LOADSTATE_LOADED && old!=LOADSTATE_PREPARED) return;
-
-
-	//	if (!mLoadingState.cas(old,LOADSTATE_UNLOADING)) return;
-
-	//	// Scope lock for actual unload
-	//	{
-	//		OGRE_LOCK_AUTO_MUTEX
-	//			if (old==LOADSTATE_PREPARED) {
-	//				unprepareImpl();
-	//			} else {
-	//				preUnloadImpl();
-	//				unloadImpl();
-	//				postUnloadImpl();
-	//			}
-	//	}
-
-	//	mLoadingState.set(LOADSTATE_UNLOADED);
-
-	//	// Notify manager
-	//	// Note if we have gone from PREPARED to UNLOADED, then we haven't actually
-	//	// unloaded, i.e. there is no memory freed on the GPU.
-	//	if(old==LOADSTATE_LOADED && mCreator)
-	//		mCreator->_notifyResourceUnloaded(this);
-
-	//	_fireUnloadingComplete();
-
+	void Resource::load()
+	{
+		if(mLoadState != RS_Loaded)
+		{
+			loadImpl();
 
-	//}
-	////-----------------------------------------------------------------------
-	//void Resource::reload() 
-	//{ 
-	//	OGRE_LOCK_AUTO_MUTEX
-	//		if (mLoadingState.get() == LOADSTATE_LOADED)
-	//		{
-	//			unload();
-	//			load();
-	//		}
-	//}
+			mLoadState = RS_Loaded;
+		}
+	}
 		
 	RTTITypeBase* Resource::getRTTIStatic()
 	{