Add newline at end of files to reduce gcc warnings

source/MaterialMap.cpp

@@ -0,0 +1,86 @@
+#include "MaterialMap.h"
+#include "MaterialMapSerializer.h"
+
+namespace Ogre
+{
+	MaterialMap::MaterialMap (Ogre::ResourceManager* creator, const Ogre::String &name, 
+	   Ogre::ResourceHandle handle, const Ogre::String &group, bool isManual, 
+	   Ogre::ManualResourceLoader *loader) :
+	   Ogre::Resource (creator, name, handle, group, isManual, loader)
+	{
+	   /* If you were storing a pointer to an object, then you would set that pointer to NULL here.
+	   */
+
+		clearMaterials();
+
+	   /* For consistency with StringInterface, but we don't add any parameters here
+	   That's because the Resource implementation of StringInterface is to
+	   list all the options that need to be set before loading, of which 
+	   we have none as such. Full details can be set through scripts.
+	   */ 
+	   createParamDictionary ("MaterialMap");
+	}
+
+	MaterialMap::~MaterialMap ()
+	{
+	   unload ();
+	}
+
+	void MaterialMap::clearMaterials()
+	{
+		for(uint ct = 0; ct < 256; ++ct)
+		{
+			mMaterials[ct] = "";
+		}
+	}
+
+	// farm out to TextFileSerializer
+	void MaterialMap::loadImpl ()
+	{
+	   /* If you were storing a pointer to an object, then you would create that object with 'new' here.
+	   */
+
+	   MaterialMapSerializer serializer;
+	   Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton ().openResource (mName, mGroup, true, this);
+	   serializer.importMaterialMap (stream, this);
+	}
+
+	void MaterialMap::unloadImpl ()
+	{
+	   /* If you were storing a pointer to an object, then you would check the pointer here,
+	   and if it is not NULL, you would destruct the object and set its pointer to NULL again.
+	   */
+
+	   //mString.clear ();
+	}
+
+	size_t MaterialMap::calculateSize () const
+	{
+		size_t uSumOfLengths = 0;
+		for(uint ct = 0; ct < 256; ++ct)
+		{
+			uSumOfLengths += mMaterials[ct].length();
+		}
+	   return uSumOfLengths;
+	}
+
+	String MaterialMap::getMaterialAtIndex(uchar uIndex)
+	{
+		return mMaterials[uIndex];
+	}
+
+	void MaterialMap::setMaterialAtIndex(uchar uIndex, const String& materialName)
+	{
+		mMaterials[uIndex] = materialName;
+	}
+
+	/*void MaterialMap::setString (const Ogre::String &str)
+	{
+	   mString = str;
+	}
+
+	const Ogre::String &MaterialMap::getString () const
+	{
+	   return mString;
+	}*/
+}

source/MaterialMapManager.cpp

@@ -0,0 +1,55 @@
+#include "MaterialMapManager.h"
+
+namespace Ogre
+{
+	template<> MaterialMapManager *Ogre::Singleton<MaterialMapManager>::ms_Singleton = 0;
+
+	MaterialMapManager *MaterialMapManager::getSingletonPtr ()
+	{
+	   return ms_Singleton;
+	}
+
+	MaterialMapManager &MaterialMapManager::getSingleton ()
+	{  
+	   assert (ms_Singleton);  
+		  return (*ms_Singleton);
+	}
+
+	MaterialMapManager::MaterialMapManager ()
+	{
+	   mResourceType = "MaterialMap";
+
+	   // low, because it will likely reference other resources
+	   mLoadOrder = 30.0f;
+
+	   // this is how we register the ResourceManager with OGRE
+	   Ogre::ResourceGroupManager::getSingleton ()._registerResourceManager (mResourceType, this);
+	}
+
+	MaterialMapManager::~MaterialMapManager()
+	{
+	   // and this is how we unregister it
+	   Ogre::ResourceGroupManager::getSingleton ()._unregisterResourceManager (mResourceType);
+	}
+
+	MaterialMapPtr MaterialMapManager::load (const Ogre::String &name, const Ogre::String &group)
+	{
+	   MaterialMapPtr textf = getByName (name);
+
+	   if (textf.isNull ())
+	   {
+		   textf = create (name, group);
+	   }
+
+	   textf->load ();
+
+	   return textf;
+	}
+
+	Ogre::Resource *MaterialMapManager::createImpl (const Ogre::String &name, Ogre::ResourceHandle handle, 
+	   const Ogre::String &group, bool isManual, Ogre::ManualResourceLoader *loader, 
+	   const Ogre::NameValuePairList *createParams)
+	{
+	   return new MaterialMap (this, name, handle, group, isManual, loader);
+	}
+}

source/MaterialMapSerializer.cpp

@@ -0,0 +1,61 @@
+#include "MaterialMapSerializer.h"
+#include "MaterialMap.h"
+
+#include <OgreStringConverter.h>
+
+using namespace std;
+
+namespace Ogre
+{
+	MaterialMapSerializer::MaterialMapSerializer ()
+	{
+
+	}
+
+	MaterialMapSerializer::~MaterialMapSerializer ()
+	{
+
+	}
+
+	void MaterialMapSerializer::importMaterialMap (Ogre::DataStreamPtr &stream, MaterialMap *pDest)
+	{
+		pDest->clearMaterials();
+		while(!stream->eof())
+		{
+			String line = stream->getLine();
+			vector<String> tokens;
+			tokenize(line, tokens, " =");
+			if(tokens.size() == 2)
+			{
+				//Get the index
+				String sIndex = tokens[0];
+				if(StringConverter::isNumber(sIndex))
+				{
+					int iIndex = StringConverter::parseInt(sIndex);
+					if((iIndex > 0) && (iIndex < 256))
+					{
+						pDest->setMaterialAtIndex(iIndex, tokens[1]);
+					}
+				}
+			}
+		}
+	}
+
+	void MaterialMapSerializer::tokenize(const String& str, vector<String>& tokens, const String& delimiters)
+	{
+		// Skip delimiters at beginning.
+		String::size_type lastPos = str.find_first_not_of(delimiters, 0);
+		// Find first "non-delimiter".
+		String::size_type pos     = str.find_first_of(delimiters, lastPos);
+
+		while (String::npos != pos || String::npos != lastPos)
+		{
+			// Found a token, add it to the vector.
+			tokens.push_back(str.substr(lastPos, pos - lastPos));
+			// Skip delimiters.  Note the "not_of"
+			lastPos = str.find_first_not_of(delimiters, pos);
+			// Find next "non-delimiter"
+			pos = str.find_first_of(delimiters, lastPos);
+		}
+	}
+}

source/SurfacePatch.cpp

@@ -126,4 +126,4 @@ namespace Ogre
 		/*vertexData = m_vecVertexData;
 		indexData = m_vecIndexData;*/
 	}
-}
+}

source/SurfacePatchRenderable.cpp

@@ -147,4 +147,4 @@ namespace Ogre
 	{
 	   return Vector3::ZERO;
 	}
-}
+}

source/SurfaceTriangle.cpp

@@ -12,4 +12,4 @@ namespace Ogre
 		,v2(v2ToSet)
 	{
 	}
-}
+}

source/SurfaceVertex.cpp

@@ -48,4 +48,4 @@ namespace Ogre
 	}
 	}
 	}*/
-}
+}

source/VolumeManager.cpp

@@ -0,0 +1,59 @@
+#include "VolumeManager.h"
+
+#include "OgreLogManager.h" //FIXME - shouldn't realy need this in this class?'
+
+namespace Ogre
+{
+	template<> VolumeManager *Ogre::Singleton<VolumeManager>::ms_Singleton = 0;
+
+	VolumeManager *VolumeManager::getSingletonPtr ()
+	{
+		return ms_Singleton;
+	}
+
+	VolumeManager &VolumeManager::getSingleton ()
+	{  
+		assert (ms_Singleton);  
+		return (*ms_Singleton);
+	}
+
+	VolumeManager::VolumeManager ()
+	{
+		mResourceType = "Volume";
+
+		// low, because it will likely reference other resources
+		mLoadOrder = 30.0f;
+
+		// this is how we register the ResourceManager with OGRE
+		Ogre::ResourceGroupManager::getSingleton ()._registerResourceManager (mResourceType, this);
+	}
+
+	VolumeManager::~VolumeManager()
+	{
+		// and this is how we unregister it
+		Ogre::ResourceGroupManager::getSingleton ()._unregisterResourceManager (mResourceType);
+	}
+
+	VolumePtr VolumeManager::load (const Ogre::String &name, const Ogre::String &group)
+	{
+		Ogre::LogManager::getSingleton().logMessage("DAVID - calling getByName");
+		VolumePtr textf = getByName (name);
+		Ogre::LogManager::getSingleton().logMessage("DAVID - done getByName");
+
+		if (textf.isNull ())
+		{
+			textf = create (name, group);
+		}
+
+		textf->load ();
+
+		return textf;
+	}
+
+	Ogre::Resource *VolumeManager::createImpl (const Ogre::String &name, Ogre::ResourceHandle handle, 
+												const Ogre::String &group, bool isManual, Ogre::ManualResourceLoader *loader, 
+												const Ogre::NameValuePairList *createParams)
+	{
+		return new Volume (this, name, handle, group, isManual, loader);
+	}
+}

source/VolumeSerializer.cpp

@@ -81,4 +81,4 @@ namespace Ogre
 		/*vol.load(stream->getName());*/
 		//pDest->setVolume(vol);
 	}
-}
+}