diff --git a/include/MaterialMap.h b/include/MaterialMap.h new file mode 100644 index 00000000..b00fb334 --- /dev/null +++ b/include/MaterialMap.h @@ -0,0 +1,74 @@ +#ifndef __MATERIALMAP_H__ +#define __MATERIALMAP_H__ + +#include + +namespace Ogre +{ + class MaterialMap : public Ogre::Resource + { + String mMaterials[256]; + + protected: + + // must implement these from the Ogre::Resource interface + void loadImpl (); + void unloadImpl (); + size_t calculateSize () const; + + public: + + MaterialMap (Ogre::ResourceManager *creator, const Ogre::String &name, + Ogre::ResourceHandle handle, const Ogre::String &group, bool isManual = false, + Ogre::ManualResourceLoader *loader = 0); + + virtual ~MaterialMap (); + + void clearMaterials(); + String getMaterialAtIndex(uchar uIndex); + void setMaterialAtIndex(uchar uIndex, const String& materialName); + + /*void setString (const Ogre::String &str); + const Ogre::String &getString () const;*/ + }; + + class MaterialMapPtr : public Ogre::SharedPtr + { + public: + MaterialMapPtr () : Ogre::SharedPtr () {} + explicit MaterialMapPtr (MaterialMap *rep) : Ogre::SharedPtr (rep) {} + MaterialMapPtr (const MaterialMapPtr &r) : Ogre::SharedPtr (r) {} + MaterialMapPtr (const Ogre::ResourcePtr &r) : Ogre::SharedPtr () + { + // lock & copy other mutex pointer + OGRE_LOCK_MUTEX (*r.OGRE_AUTO_MUTEX_NAME) + OGRE_COPY_AUTO_SHARED_MUTEX (r.OGRE_AUTO_MUTEX_NAME) + pRep = static_cast (r.getPointer ()); + pUseCount = r.useCountPointer (); + if (pUseCount) + { + ++ (*pUseCount); + } + } + + /// Operator used to convert a ResourcePtr to a TextFilePtr + MaterialMapPtr& operator=(const Ogre::ResourcePtr& r) + { + if (pRep == static_cast (r.getPointer ())) + return *this; + release (); + // lock & copy other mutex pointer + OGRE_LOCK_MUTEX (*r.OGRE_AUTO_MUTEX_NAME) + OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME) + pRep = static_cast (r.getPointer()); + pUseCount = r.useCountPointer (); + if (pUseCount) + { + ++ (*pUseCount); + } + return *this; + } + }; +} + +#endif diff --git a/include/MaterialMapManager.h b/include/MaterialMapManager.h new file mode 100644 index 00000000..16b25807 --- /dev/null +++ b/include/MaterialMapManager.h @@ -0,0 +1,31 @@ +#ifndef __MATERIALMAPMANAGER_H__ +#define __MATERIALMAPMANAGER_H__ + +#include +#include "MaterialMap.h" +#include "TypeDef.h" + +namespace Ogre +{ + class VOXEL_SCENE_MANAGER_API MaterialMapManager : public Ogre::ResourceManager, public Ogre::Singleton + { + protected: + + // must implement this from ResourceManager's interface + Ogre::Resource *createImpl(const Ogre::String &name, Ogre::ResourceHandle handle, + const Ogre::String &group, bool isManual, Ogre::ManualResourceLoader *loader, + const Ogre::NameValuePairList *createParams); + + public: + + MaterialMapManager (); + virtual ~MaterialMapManager (); + + virtual MaterialMapPtr load (const Ogre::String &name, const Ogre::String &group); + + static MaterialMapManager &getSingleton (); + static MaterialMapManager *getSingletonPtr (); + }; +} + +#endif diff --git a/include/MaterialMapSerializer.h b/include/MaterialMapSerializer.h new file mode 100644 index 00000000..c6744e46 --- /dev/null +++ b/include/MaterialMapSerializer.h @@ -0,0 +1,26 @@ +#ifndef __MATERIALMAPSERIALIZER_H__ +#define __MATERIALMAPSERIALIZER_H__ + +#include +#include + +#include + +namespace Ogre +{ + class MaterialMap; // forward declaration + + class MaterialMapSerializer : public Ogre::Serializer + { + public: + MaterialMapSerializer (); + virtual ~MaterialMapSerializer (); + + void importMaterialMap (Ogre::DataStreamPtr &stream, MaterialMap *pDest); + + private: + void tokenize(const String& str, std::vector& tokens, const String& delimiters = " "); + }; +} + +#endif diff --git a/include/SurfacePatch.h b/include/SurfacePatch.h index ad3e2c7a..47cb0128 100644 --- a/include/SurfacePatch.h +++ b/include/SurfacePatch.h @@ -32,4 +32,4 @@ namespace Ogre }; } -#endif /* __SurfacePatch_H__ */ \ No newline at end of file +#endif /* __SurfacePatch_H__ */ diff --git a/include/SurfacePatchRenderable.h b/include/SurfacePatchRenderable.h index e8d5598e..a4d4e42e 100644 --- a/include/SurfacePatchRenderable.h +++ b/include/SurfacePatchRenderable.h @@ -26,4 +26,4 @@ namespace Ogre }; } -#endif /* __SurfacePatchRenderable_H__ */ \ No newline at end of file +#endif /* __SurfacePatchRenderable_H__ */ diff --git a/include/VolumeManager.h b/include/VolumeManager.h new file mode 100644 index 00000000..5ed1f1c4 --- /dev/null +++ b/include/VolumeManager.h @@ -0,0 +1,30 @@ +#ifndef __VOLUMEMANAGER_H__ +#define __VOLUMEMANAGER_H__ + +#include +#include "Volume.h" + +namespace Ogre +{ + class VOXEL_SCENE_MANAGER_API VolumeManager : public Ogre::ResourceManager, public Ogre::Singleton + { + protected: + + // must implement this from ResourceManager's interface + Ogre::Resource *createImpl(const Ogre::String &name, Ogre::ResourceHandle handle, + const Ogre::String &group, bool isManual, Ogre::ManualResourceLoader *loader, + const Ogre::NameValuePairList *createParams); + + public: + + VolumeManager (); + virtual ~VolumeManager (); + + virtual VolumePtr load (const Ogre::String &name, const Ogre::String &group); + + static VolumeManager &getSingleton (); + static VolumeManager *getSingletonPtr (); + }; +} + +#endif diff --git a/include/VolumeSerializer.h b/include/VolumeSerializer.h new file mode 100644 index 00000000..82618faa --- /dev/null +++ b/include/VolumeSerializer.h @@ -0,0 +1,21 @@ +#ifndef __VOLUMESERIALIZER_H__ +#define __VOLUMESERIALIZER_H__ + +#include + +namespace Ogre +{ + class Volume; // forward declaration + + class VolumeSerializer : public Ogre::Serializer + { + public: + VolumeSerializer (); + virtual ~VolumeSerializer (); + + //void exportVolume (const Volume *pText, const Ogre::String &fileName); + void importVolume (Ogre::DataStreamPtr &stream, Volume *pDest); + }; +} + +#endif diff --git a/source/MaterialMap.cpp b/source/MaterialMap.cpp new file mode 100644 index 00000000..476a28c2 --- /dev/null +++ b/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; + }*/ +} diff --git a/source/MaterialMapManager.cpp b/source/MaterialMapManager.cpp new file mode 100644 index 00000000..d369feed --- /dev/null +++ b/source/MaterialMapManager.cpp @@ -0,0 +1,55 @@ +#include "MaterialMapManager.h" + +namespace Ogre +{ + template<> MaterialMapManager *Ogre::Singleton::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); + } +} diff --git a/source/MaterialMapSerializer.cpp b/source/MaterialMapSerializer.cpp new file mode 100644 index 00000000..41ad2ad7 --- /dev/null +++ b/source/MaterialMapSerializer.cpp @@ -0,0 +1,61 @@ +#include "MaterialMapSerializer.h" +#include "MaterialMap.h" + +#include + +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 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& 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); + } + } +} diff --git a/source/SurfacePatch.cpp b/source/SurfacePatch.cpp index b9558cfe..1de59304 100644 --- a/source/SurfacePatch.cpp +++ b/source/SurfacePatch.cpp @@ -126,4 +126,4 @@ namespace Ogre /*vertexData = m_vecVertexData; indexData = m_vecIndexData;*/ } -} \ No newline at end of file +} diff --git a/source/SurfacePatchRenderable.cpp b/source/SurfacePatchRenderable.cpp index 705a67b0..860c7406 100644 --- a/source/SurfacePatchRenderable.cpp +++ b/source/SurfacePatchRenderable.cpp @@ -147,4 +147,4 @@ namespace Ogre { return Vector3::ZERO; } -} \ No newline at end of file +} diff --git a/source/SurfaceTriangle.cpp b/source/SurfaceTriangle.cpp index 5cd04f00..9df3ef44 100644 --- a/source/SurfaceTriangle.cpp +++ b/source/SurfaceTriangle.cpp @@ -12,4 +12,4 @@ namespace Ogre ,v2(v2ToSet) { } -} \ No newline at end of file +} diff --git a/source/SurfaceVertex.cpp b/source/SurfaceVertex.cpp index 3709d5eb..8ca3c05a 100644 --- a/source/SurfaceVertex.cpp +++ b/source/SurfaceVertex.cpp @@ -48,4 +48,4 @@ namespace Ogre } } }*/ -} \ No newline at end of file +} diff --git a/source/VolumeManager.cpp b/source/VolumeManager.cpp new file mode 100644 index 00000000..a5157451 --- /dev/null +++ b/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::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); + } +} diff --git a/source/VolumeSerializer.cpp b/source/VolumeSerializer.cpp index bc6bc3df..0a2d82a5 100644 --- a/source/VolumeSerializer.cpp +++ b/source/VolumeSerializer.cpp @@ -81,4 +81,4 @@ namespace Ogre /*vol.load(stream->getName());*/ //pDest->setVolume(vol); } -} \ No newline at end of file +}