More macro renames

CamelotRenderer/OgreBuildSettings.h

@@ -31,7 +31,7 @@
 
 #define OGRE_MEMORY_TRACKER_RELEASE_MODE 0
 
-#define OGRE_THREAD_SUPPORT 0
+#define CM_THREAD_SUPPORT 0
 
 #define OGRE_THREAD_PROVIDER 0
 

CamelotRenderer/OgreCommon.h

@@ -743,7 +743,7 @@ namespace Ogre {
 	protected:
 		String mPrefix;
 		unsigned long long int mNext;
-		OGRE_AUTO_MUTEX
+		CM_AUTO_MUTEX
 	public:
 		NameGenerator(const NameGenerator& rhs)
 			: mPrefix(rhs.mPrefix), mNext(rhs.mNext) {}
@@ -753,7 +753,7 @@ namespace Ogre {
 		/// Generate a new name
 		String generate()
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			std::ostringstream s;
 			s << mPrefix << mNext++;
 			return s.str();
@@ -762,14 +762,14 @@ namespace Ogre {
 		/// Reset the internal counter
 		void reset()
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			mNext = 1ULL;
 		}
 
 		/// Manually set the internal counter (use caution)
 		void setNext(unsigned long long int val)
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			mNext = val;
 		}
 
@@ -777,7 +777,7 @@ namespace Ogre {
 		unsigned long long int getNext() const
 		{
 			// lock even on get because 64-bit may not be atomic read
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			return mNext;
 		}
 
@@ -794,7 +794,7 @@ namespace Ogre {
 	protected:
 		typedef typename list<T>::type ItemList;
 		ItemList mItems;
-		OGRE_AUTO_MUTEX
+		CM_AUTO_MUTEX
 	public:
 		Pool() {} 
 		virtual ~Pool() {}
@@ -804,7 +804,7 @@ namespace Ogre {
 		*/
 		virtual std::pair<bool, T> removeItem()
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			std::pair<bool, T> ret;
 			if (mItems.empty())
 			{
@@ -823,13 +823,13 @@ namespace Ogre {
 		*/
 		virtual void addItem(const T& i)
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			mItems.push_front(i);
 		}
 		/// Clear the pool
 		virtual void clear()
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			mItems.clear();
 		}
 

CamelotRenderer/OgreConfig.h

@@ -120,16 +120,16 @@ THE SOFTWARE.
 
 /** Support for multithreading, there are 3 options
 
-OGRE_THREAD_SUPPORT = 0
+CM_THREAD_SUPPORT = 0
 	No support for threading.		
-OGRE_THREAD_SUPPORT = 1
+CM_THREAD_SUPPORT = 1
 	Thread support for background loading, by both loading and constructing resources
 	in a background thread. Resource management and SharedPtr handling becomes
 	thread-safe, and resources may be completely loaded in the background. 
 	The places where threading is available are clearly
 	marked, you should assume state is NOT thread safe unless otherwise
 	stated in relation to this flag.
-OGRE_THREAD_SUPPORT = 2
+CM_THREAD_SUPPORT = 2
 	Thread support for background resource preparation. This means that resource
 	data can streamed into memory in the background, but the final resource
 	construction (including RenderSystem dependencies) is still done in the primary
@@ -137,11 +137,11 @@ OGRE_THREAD_SUPPORT = 2
 	while still allowing the major blocking aspects of resource management (I/O)
 	to be done in the background.
 */
-#ifndef OGRE_THREAD_SUPPORT
-#define OGRE_THREAD_SUPPORT 0
+#ifndef CM_THREAD_SUPPORT
+#define CM_THREAD_SUPPORT 0
 #endif
-#if OGRE_THREAD_SUPPORT != 0 && OGRE_THREAD_SUPPORT != 1 && OGRE_THREAD_SUPPORT != 2
-#define OGRE_THREAD_SUPPORT 0
+#if CM_THREAD_SUPPORT != 0 && CM_THREAD_SUPPORT != 1 && CM_THREAD_SUPPORT != 2
+#define CM_THREAD_SUPPORT 0
 #endif
 
 /** Provider for threading functionality, there are 4 options.

CamelotRenderer/OgreD3D9DeviceManager.cpp

@@ -363,7 +363,7 @@ namespace Ogre
 		//if (opti != options.end() && opti->second.currentValue == "Consistent")
 		//	extraFlags |= D3DCREATE_FPU_PRESERVE;
 
-#if OGRE_THREAD_SUPPORT == 1
+#if CM_THREAD_SUPPORT == 1
 		extraFlags |= D3DCREATE_MULTITHREADED;
 #endif
 

CamelotRenderer/OgreD3D9HLSLProgram.cpp

@@ -371,7 +371,7 @@ namespace Ogre {
 				if (def.isFloat())
 				{
 					def.physicalIndex = mFloatLogicalToPhysical->bufferSize;
-					OGRE_LOCK_MUTEX(mFloatLogicalToPhysical->mutex)
+					CM_LOCK_MUTEX(mFloatLogicalToPhysical->mutex)
 					mFloatLogicalToPhysical->map.insert(
 						GpuLogicalIndexUseMap::value_type(paramIndex, 
 						GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, GPV_GLOBAL)));
@@ -381,7 +381,7 @@ namespace Ogre {
 				else
 				{
 					def.physicalIndex = mIntLogicalToPhysical->bufferSize;
-					OGRE_LOCK_MUTEX(mIntLogicalToPhysical->mutex)
+					CM_LOCK_MUTEX(mIntLogicalToPhysical->mutex)
 					mIntLogicalToPhysical->map.insert(
 						GpuLogicalIndexUseMap::value_type(paramIndex, 
 						GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, GPV_GLOBAL)));

CamelotRenderer/OgreD3D9HardwareBufferManager.cpp

@@ -72,7 +72,7 @@ namespace Ogre {
 		D3D9HardwareVertexBuffer* vbuf = new D3D9HardwareVertexBuffer(
 			this, vertexSize, numVerts, usage, false, useShadowBuffer);
 		{
-			OGRE_LOCK_MUTEX(mVertexBuffersMutex)
+			CM_LOCK_MUTEX(mVertexBuffersMutex)
 			mVertexBuffers.insert(vbuf);
 		}
         return HardwareVertexBufferPtr(vbuf);
@@ -104,7 +104,7 @@ namespace Ogre {
 		D3D9HardwareIndexBuffer* idx = new D3D9HardwareIndexBuffer(
 			this, itype, numIndexes, usage, false, useShadowBuffer);
 		{
-			OGRE_LOCK_MUTEX(mIndexBuffersMutex)
+			CM_LOCK_MUTEX(mIndexBuffersMutex)
 			mIndexBuffers.insert(idx);
 		}
 		return HardwareIndexBufferPtr(idx);

CamelotRenderer/OgreD3D9HardwarePixelBuffer.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 
 namespace Ogre {
 
-OGRE_STATIC_MUTEX_INSTANCE(D3D9HardwarePixelBuffer::msDeviceAccessMutex)
+CM_STATIC_MUTEX_INSTANCE(D3D9HardwarePixelBuffer::msDeviceAccessMutex)
 //-----------------------------------------------------------------------------  
 
 D3D9HardwarePixelBuffer::D3D9HardwarePixelBuffer(HardwareBuffer::Usage usage, 

CamelotRenderer/OgreD3D9HardwarePixelBuffer.h

@@ -75,7 +75,7 @@ namespace Ogre {
 		DWORD mLockFlags;
 
 		// Device access mutex.
-		OGRE_STATIC_MUTEX(msDeviceAccessMutex)		
+		CM_STATIC_MUTEX(msDeviceAccessMutex)		
 	protected:
 		/// Lock a box
 		PixelBox lockImpl(const Box lockBox,  LockOptions options);

CamelotRenderer/OgreD3D9Prerequisites.h

@@ -33,7 +33,7 @@ THE SOFTWARE.
 #  include "WIN32/OgreMinGWSupport.h" // extra defines for MinGW to deal with DX SDK
 #endif
 
-#if OGRE_THREAD_SUPPORT
+#if CM_THREAD_SUPPORT
 #define OGRE_LOCK_RECURSIVE_MUTEX(name)   name.lock();
 #define OGRE_UNLOCK_RECURSIVE_MUTEX(name) name.unlock();
 #else
@@ -42,10 +42,10 @@ THE SOFTWARE.
 #endif
 
 
-#if OGRE_THREAD_SUPPORT == 1
+#if CM_THREAD_SUPPORT == 1
 #define D3D9_DEVICE_ACCESS_LOCK				OGRE_LOCK_RECURSIVE_MUTEX(msDeviceAccessMutex);
 #define D3D9_DEVICE_ACCESS_UNLOCK			OGRE_UNLOCK_RECURSIVE_MUTEX(msDeviceAccessMutex);
-#define D3D9_DEVICE_ACCESS_CRITICAL_SECTION	OGRE_LOCK_MUTEX(msDeviceAccessMutex)
+#define D3D9_DEVICE_ACCESS_CRITICAL_SECTION	CM_LOCK_MUTEX(msDeviceAccessMutex)
 #else
 #define D3D9_DEVICE_ACCESS_LOCK	
 #define D3D9_DEVICE_ACCESS_UNLOCK

CamelotRenderer/OgreD3D9RenderSystem.cpp

@@ -3130,7 +3130,7 @@ namespace Ogre
 		case GPT_VERTEX_PROGRAM:
 			mActiveVertexGpuProgramParameters = params;
 			{
-				OGRE_LOCK_MUTEX(floatLogical->mutex)
+				CM_LOCK_MUTEX(floatLogical->mutex)
 
 					for (GpuLogicalIndexUseMap::const_iterator i = floatLogical->map.begin();
 						i != floatLogical->map.end(); ++i)
@@ -3157,7 +3157,7 @@ namespace Ogre
 			}
 			// bind ints
 			{
-				OGRE_LOCK_MUTEX(intLogical->mutex)
+				CM_LOCK_MUTEX(intLogical->mutex)
 
 					for (GpuLogicalIndexUseMap::const_iterator i = intLogical->map.begin();
 						i != intLogical->map.end(); ++i)
@@ -3186,7 +3186,7 @@ namespace Ogre
 		case GPT_FRAGMENT_PROGRAM:
 			mActiveFragmentGpuProgramParameters = params;
 			{
-				OGRE_LOCK_MUTEX(floatLogical->mutex)
+				CM_LOCK_MUTEX(floatLogical->mutex)
 
 					for (GpuLogicalIndexUseMap::const_iterator i = floatLogical->map.begin();
 						i != floatLogical->map.end(); ++i)
@@ -3212,7 +3212,7 @@ namespace Ogre
 			}
 			// bind ints
 			{
-				OGRE_LOCK_MUTEX(intLogical->mutex)
+				CM_LOCK_MUTEX(intLogical->mutex)
 
 					for (GpuLogicalIndexUseMap::const_iterator i = intLogical->map.begin();
 						i != intLogical->map.end(); ++i)

CamelotRenderer/OgreD3D9Resource.cpp

@@ -31,7 +31,7 @@ THE SOFTWARE.
 
 namespace Ogre
 {
-	OGRE_STATIC_MUTEX_INSTANCE(D3D9Resource::msDeviceAccessMutex)
+	CM_STATIC_MUTEX_INSTANCE(D3D9Resource::msDeviceAccessMutex)
 
 	D3D9Resource::D3D9Resource()
 	{				

CamelotRenderer/OgreD3D9Resource.h

@@ -70,7 +70,7 @@ namespace Ogre {
 		virtual ~D3D9Resource	();
 
 	protected:
-		OGRE_STATIC_MUTEX(msDeviceAccessMutex)		
+		CM_STATIC_MUTEX(msDeviceAccessMutex)		
 	};
 }
 #endif

CamelotRenderer/OgreD3D9ResourceManager.cpp

@@ -60,7 +60,7 @@ namespace Ogre
 	 //-----------------------------------------------------------------------
 	void D3D9ResourceManager::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device)
 	{				
-		OGRE_LOCK_MUTEX(mResourcesMutex)
+		CM_LOCK_MUTEX(mResourcesMutex)
 
 		ResourceContainerIterator it = mResources.begin();
 		while (it != mResources.end())
@@ -73,7 +73,7 @@ namespace Ogre
 	 //-----------------------------------------------------------------------
 	void D3D9ResourceManager::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device)
 	{
-		OGRE_LOCK_MUTEX(mResourcesMutex)
+		CM_LOCK_MUTEX(mResourcesMutex)
 
 		ResourceContainerIterator it = mResources.begin();
 		while (it != mResources.end())
@@ -86,7 +86,7 @@ namespace Ogre
 	 //-----------------------------------------------------------------------
 	void D3D9ResourceManager::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device)
 	{
-		OGRE_LOCK_MUTEX(mResourcesMutex)
+		CM_LOCK_MUTEX(mResourcesMutex)
 
 		ResourceContainerIterator it = mResources.begin();
 		while (it != mResources.end())
@@ -99,7 +99,7 @@ namespace Ogre
 	 //-----------------------------------------------------------------------
 	void D3D9ResourceManager::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device)
 	{		
-		OGRE_LOCK_MUTEX(mResourcesMutex)
+		CM_LOCK_MUTEX(mResourcesMutex)
 
 		ResourceContainerIterator it = mResources.begin();
 		while (it != mResources.end())
@@ -112,14 +112,14 @@ namespace Ogre
 	//-----------------------------------------------------------------------
 	void D3D9ResourceManager::_notifyResourceCreated(D3D9Resource* pResource)
 	{		
-		OGRE_LOCK_MUTEX(mResourcesMutex)		
+		CM_LOCK_MUTEX(mResourcesMutex)		
 		mResources.push_back(pResource);
 	}
 	
 	//-----------------------------------------------------------------------
 	void D3D9ResourceManager::_notifyResourceDestroyed(D3D9Resource* pResource)
 	{		
-		OGRE_LOCK_MUTEX(mResourcesMutex)
+		CM_LOCK_MUTEX(mResourcesMutex)
 
 		ResourceContainerIterator it = mResources.begin();
 

CamelotRenderer/OgreD3D9ResourceManager.h

@@ -103,7 +103,7 @@ namespace Ogre {
 
 	// Attributes.
 	protected:		
-		OGRE_MUTEX(mResourcesMutex)
+		CM_MUTEX(mResourcesMutex)
 		ResourceContainer			mResources;
 		D3D9ResourceCreationPolicy	mResourceCreationPolicy;
 		long						mDeviceAccessLockCount;		

CamelotRenderer/OgreGpuProgramManager.cpp

@@ -58,7 +58,7 @@ namespace Ogre {
     {
 		GpuProgramPtr prg;
 		{
-			OGRE_LOCK_AUTO_MUTEX
+			CM_LOCK_AUTO_MUTEX
 			prg = createProgram( code, gptype, syntaxCode);
 		}
         prg->load();

CamelotRenderer/OgreGpuProgramParams.cpp

@@ -1023,7 +1023,7 @@ namespace Ogre
 			return 0;
 
 		GpuLogicalIndexUse* indexUse = 0;
-		OGRE_LOCK_MUTEX(mFloatLogicalToPhysical->mutex)
+		CM_LOCK_MUTEX(mFloatLogicalToPhysical->mutex)
 
 			GpuLogicalIndexUseMap::iterator logi = mFloatLogicalToPhysical->map.find(logicalIndex);
 		if (logi == mFloatLogicalToPhysical->map.end())
@@ -1130,7 +1130,7 @@ namespace Ogre
 			"GpuProgramParameters::_getIntConstantPhysicalIndex");
 
 		GpuLogicalIndexUse* indexUse = 0;
-		OGRE_LOCK_MUTEX(mIntLogicalToPhysical->mutex)
+		CM_LOCK_MUTEX(mIntLogicalToPhysical->mutex)
 
 			GpuLogicalIndexUseMap::iterator logi = mIntLogicalToPhysical->map.find(logicalIndex);
 		if (logi == mIntLogicalToPhysical->map.end())

CamelotRenderer/OgreGpuProgramParams.h

@@ -325,7 +325,7 @@ namespace Ogre {
 	/// Container struct to allow params to safely & update shared list of logical buffer assignments
 	struct _OgreExport GpuLogicalBufferStruct
 	{
-		OGRE_MUTEX(mutex)
+		CM_MUTEX(mutex)
 			/// Map from logical index to physical buffer location
 			GpuLogicalIndexUseMap map;
 		/// Shortcut to know the buffer size needs

CamelotRenderer/OgreHardwareBufferManager.cpp

@@ -76,14 +76,14 @@ namespace Ogre {
     VertexDeclaration* HardwareBufferManagerBase::createVertexDeclaration(void)
     {
         VertexDeclaration* decl = createVertexDeclarationImpl();
-		OGRE_LOCK_MUTEX(mVertexDeclarationsMutex)
+		CM_LOCK_MUTEX(mVertexDeclarationsMutex)
         mVertexDeclarations.insert(decl);
         return decl;
     }
     //-----------------------------------------------------------------------
     void HardwareBufferManagerBase::destroyVertexDeclaration(VertexDeclaration* decl)
     {
-		OGRE_LOCK_MUTEX(mVertexDeclarationsMutex)
+		CM_LOCK_MUTEX(mVertexDeclarationsMutex)
         mVertexDeclarations.erase(decl);
         destroyVertexDeclarationImpl(decl);
     }
@@ -91,14 +91,14 @@ namespace Ogre {
 	VertexBufferBinding* HardwareBufferManagerBase::createVertexBufferBinding(void)
 	{
 		VertexBufferBinding* ret = createVertexBufferBindingImpl();
-		OGRE_LOCK_MUTEX(mVertexBufferBindingsMutex)
+		CM_LOCK_MUTEX(mVertexBufferBindingsMutex)
 		mVertexBufferBindings.insert(ret);
 		return ret;
 	}
     //-----------------------------------------------------------------------
 	void HardwareBufferManagerBase::destroyVertexBufferBinding(VertexBufferBinding* binding)
 	{
-		OGRE_LOCK_MUTEX(mVertexBufferBindingsMutex)
+		CM_LOCK_MUTEX(mVertexBufferBindingsMutex)
 		mVertexBufferBindings.erase(binding);
 		destroyVertexBufferBindingImpl(binding);
 	}
@@ -125,7 +125,7 @@ namespace Ogre {
     //-----------------------------------------------------------------------
     void HardwareBufferManagerBase::destroyAllDeclarations(void)
     {
-		OGRE_LOCK_MUTEX(mVertexDeclarationsMutex)
+		CM_LOCK_MUTEX(mVertexDeclarationsMutex)
         VertexDeclarationList::iterator decl;
         for (decl = mVertexDeclarations.begin(); decl != mVertexDeclarations.end(); ++decl)
         {
@@ -136,7 +136,7 @@ namespace Ogre {
     //-----------------------------------------------------------------------
     void HardwareBufferManagerBase::destroyAllBindings(void)
     {
-		OGRE_LOCK_MUTEX(mVertexBufferBindingsMutex)
+		CM_LOCK_MUTEX(mVertexBufferBindingsMutex)
         VertexBufferBindingList::iterator bind;
         for (bind = mVertexBufferBindings.begin(); bind != mVertexBufferBindings.end(); ++bind)
         {
@@ -154,9 +154,9 @@ namespace Ogre {
 		//  makeBufferCopy / createVertexBuffer
 		// this prevents a deadlock in _notifyVertexBufferDestroyed
 		// which locks the same mutexes (via other methods) but in reverse order
-		OGRE_LOCK_MUTEX(mVertexBuffersMutex)
+		CM_LOCK_MUTEX(mVertexBuffersMutex)
 		{
-			OGRE_LOCK_MUTEX(mTempBuffersMutex)
+			CM_LOCK_MUTEX(mTempBuffersMutex)
 			HardwareVertexBufferPtr vbuf;
 
 			// Locate existing buffer copy in temporary vertex buffers
@@ -179,7 +179,7 @@ namespace Ogre {
 	//-----------------------------------------------------------------------
 	void HardwareBufferManagerBase::_notifyVertexBufferDestroyed(HardwareVertexBuffer* buf)
 	{
-		OGRE_LOCK_MUTEX(mVertexBuffersMutex)
+		CM_LOCK_MUTEX(mVertexBuffersMutex)
 
 		VertexBufferList::iterator i = mVertexBuffers.find(buf);
 		if (i != mVertexBuffers.end())
@@ -191,7 +191,7 @@ namespace Ogre {
 	//-----------------------------------------------------------------------
 	void HardwareBufferManagerBase::_notifyIndexBufferDestroyed(HardwareIndexBuffer* buf)
 	{
-		OGRE_LOCK_MUTEX(mIndexBuffersMutex)
+		CM_LOCK_MUTEX(mIndexBuffersMutex)
 
 		IndexBufferList::iterator i = mIndexBuffers.find(buf);
 		if (i != mIndexBuffers.end())

CamelotRenderer/OgreHardwareBufferManager.h

@@ -74,10 +74,10 @@ namespace Ogre {
 		VertexBufferBindingList mVertexBufferBindings;
 
 		// Mutexes
-		OGRE_MUTEX(mVertexBuffersMutex)
-		OGRE_MUTEX(mIndexBuffersMutex)
-		OGRE_MUTEX(mVertexDeclarationsMutex)
-		OGRE_MUTEX(mVertexBufferBindingsMutex)
+		CM_MUTEX(mVertexBuffersMutex)
+		CM_MUTEX(mIndexBuffersMutex)
+		CM_MUTEX(mVertexDeclarationsMutex)
+		CM_MUTEX(mVertexBufferBindingsMutex)
 
         /// Internal method for destroys all vertex declarations
         virtual void destroyAllDeclarations(void);

CamelotRenderer/OgreHighLevelGpuProgram.cpp

@@ -75,7 +75,7 @@ namespace Ogre
     {
 		// Lock mutex before allowing this since this is a top-level method
 		// called outside of the load()
-		OGRE_LOCK_AUTO_MUTEX
+		CM_LOCK_AUTO_MUTEX
 
         // Make sure param defs are loaded
         GpuProgramParametersSharedPtr params = GpuProgramParametersSharedPtr(OGRE_NEW GpuProgramParameters());

CamelotRenderer/OgreStdHeaders.h

@@ -112,7 +112,7 @@ extern "C" {
 }
 #endif
 
-#if OGRE_THREAD_SUPPORT
+#if CM_THREAD_SUPPORT
 #   include "Threading/OgreThreadHeaders.h"
 #endif
 

CamelotRenderer/OgreThreadDefines.h

@@ -23,39 +23,36 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE
 -------------------------------------------------------------------------*/
-#ifndef __OgreThreadDefines_H__
-#define __OgreThreadDefines_H__
+#pragma once
 
-#define OGRE_AUTO_MUTEX_NAME mutex
-#define OGRE_AUTO_MUTEX
-#define OGRE_LOCK_AUTO_MUTEX
-#define OGRE_MUTEX(name)
-#define OGRE_STATIC_MUTEX(name)
-#define OGRE_STATIC_MUTEX_INSTANCE(name)
-#define OGRE_LOCK_MUTEX(name)
-#define OGRE_LOCK_MUTEX_NAMED(mutexName, lockName)
-#define OGRE_AUTO_SHARED_MUTEX
-#define OGRE_LOCK_AUTO_SHARED_MUTEX
-#define OGRE_NEW_AUTO_SHARED_MUTEX
-#define OGRE_DELETE_AUTO_SHARED_MUTEX
-#define OGRE_COPY_AUTO_SHARED_MUTEX(from)
-#define OGRE_SET_AUTO_SHARED_MUTEX_NULL
-#define OGRE_MUTEX_CONDITIONAL(name) if(true)
-#define OGRE_RW_MUTEX(name)
-#define OGRE_LOCK_RW_MUTEX_READ(name)
-#define OGRE_LOCK_RW_MUTEX_WRITE(name)
-#define OGRE_THREAD_SYNCHRONISER(sync) 
-#define OGRE_THREAD_WAIT(sync, lock) 
-#define OGRE_THREAD_NOTIFY_ONE(sync) 
-#define OGRE_THREAD_NOTIFY_ALL(sync) 
-#define OGRE_THREAD_POINTER(T, var) T* var
-#define OGRE_THREAD_POINTER_INIT(var) var(0)
-#define OGRE_THREAD_POINTER_VAR(T, var) T* var = 0
-#define OGRE_THREAD_POINTER_SET(var, expr) var = expr
-#define OGRE_THREAD_POINTER_GET(var) var
-#define OGRE_THREAD_POINTER_DELETE(var) { OGRE_DELETE var; var = 0; }
-#define OGRE_THREAD_SLEEP(ms)
-#define OGRE_THREAD_WORKER_INHERIT
-
-#endif
+#define CM_AUTO_MUTEX_NAME mutex
+#define CM_AUTO_MUTEX
+#define CM_LOCK_AUTO_MUTEX
+#define CM_MUTEX(name)
+#define CM_STATIC_MUTEX(name)
+#define CM_STATIC_MUTEX_INSTANCE(name)
+#define CM_LOCK_MUTEX(name)
+#define CM_LOCK_MUTEX_NAMED(mutexName, lockName)
+#define CM_AUTO_SHARED_MUTEX
+#define CM_LOCK_AUTO_SHARED_MUTEX
+#define CM_NEW_AUTO_SHARED_MUTEX
+#define CM_DELETE_AUTO_SHARED_MUTEX
+#define CM_COPY_AUTO_SHARED_MUTEX(from)
+#define CM_SET_AUTO_SHARED_MUTEX_NULL
+#define CM_MUTEX_CONDITIONAL(name) if(true)
+#define CM_RW_MUTEX(name)
+#define CM_LOCK_RW_MUTEX_READ(name)
+#define CM_LOCK_RW_MUTEX_WRITE(name)
+#define CM_THREAD_SYNCHRONISER(sync) 
+#define CM_THREAD_WAIT(sync, lock) 
+#define CM_THREAD_NOTIFY_ONE(sync) 
+#define CM_THREAD_NOTIFY_ALL(sync) 
+#define CM_THREAD_POINTER(T, var) T* var
+#define CM_THREAD_POINTER_INIT(var) var(0)
+#define CM_THREAD_POINTER_VAR(T, var) T* var = 0
+#define CM_THREAD_POINTER_SET(var, expr) var = expr
+#define CM_THREAD_POINTER_GET(var) var
+#define CM_THREAD_POINTER_DELETE(var) { delete var; var = 0; }
+#define CM_THREAD_SLEEP(ms)
+#define CM_THREAD_WORKER_INHERIT
 

CamelotRenderer/RenderSystemGL/Include/OgreGLHardwareBufferManager.h

@@ -42,7 +42,7 @@ namespace Ogre {
     {
 	protected:
 		char* mScratchBufferPool;
-		OGRE_MUTEX(mScratchMutex)
+		CM_MUTEX(mScratchMutex)
 		size_t mMapBufferThreshold;
 
     public:

CamelotRenderer/RenderSystemGL/Include/OgreGLPrerequisites.h

@@ -44,7 +44,7 @@ namespace Ogre {
     class GLRenderBuffer;
 }
 
-#if OGRE_THREAD_SUPPORT == 1
+#if CM_THREAD_SUPPORT == 1
 #	define GLEW_MX
 #endif
 
@@ -72,7 +72,7 @@ namespace Ogre {
 #   include <OpenGLES/ES1/glext.h>
 #endif
 
-#if OGRE_THREAD_SUPPORT == 1
+#if CM_THREAD_SUPPORT == 1
 	// implemented in OgreGLContext.cpp
 	GLEWContext * glewGetContext();
 

CamelotRenderer/RenderSystemGL/Include/OgreGLRenderSystem.h

@@ -460,7 +460,7 @@ namespace Ogre {
         Real getVerticalTexelOffset(void);
         Real getMinimumDepthInputValue(void);
         Real getMaximumDepthInputValue(void);
-		OGRE_MUTEX(mThreadInitMutex)
+		CM_MUTEX(mThreadInitMutex)
 		void registerThread();
 		void unregisterThread();
 		void preExtraThreadsStarted();

CamelotRenderer/RenderSystemGL/Source/OgreGLContext.cpp

@@ -42,19 +42,19 @@ namespace Ogre {
     
 }
 
-#if OGRE_THREAD_SUPPORT == 1
+#if CM_THREAD_SUPPORT == 1
 
 // declared in OgreGLPrerequisites.h 
 GLEWContext * glewGetContext()
 {
 	using namespace Ogre;
-	static OGRE_THREAD_POINTER_VAR(GLEWContext, GLEWContextsPtr);
+	static CM_THREAD_POINTER_VAR(GLEWContext, GLEWContextsPtr);
 
-	GLEWContext * currentGLEWContextsPtr =  OGRE_THREAD_POINTER_GET(GLEWContextsPtr);
+	GLEWContext * currentGLEWContextsPtr =  CM_THREAD_POINTER_GET(GLEWContextsPtr);
 	if (currentGLEWContextsPtr == NULL)
 	{
 		currentGLEWContextsPtr = new GLEWContext();
-		OGRE_THREAD_POINTER_SET(GLEWContextsPtr, currentGLEWContextsPtr);
+		CM_THREAD_POINTER_SET(GLEWContextsPtr, currentGLEWContextsPtr);
 		memset(currentGLEWContextsPtr, 0, sizeof(GLEWContext));
 		glewInit();
 	}

CamelotRenderer/RenderSystemGL/Source/OgreGLHardwareBufferManager.cpp

@@ -88,7 +88,7 @@ namespace Ogre {
 		GLHardwareVertexBuffer* buf = 
 			new GLHardwareVertexBuffer(this, vertexSize, numVerts, usage, useShadowBuffer);
 		{
-			OGRE_LOCK_MUTEX(mVertexBuffersMutex)
+			CM_LOCK_MUTEX(mVertexBuffersMutex)
 			mVertexBuffers.insert(buf);
 		}
 		return HardwareVertexBufferPtr(buf);
@@ -102,7 +102,7 @@ namespace Ogre {
 		GLHardwareIndexBuffer* buf = 
 			new GLHardwareIndexBuffer(this, itype, numIndexes, usage, useShadowBuffer);
 		{
-			OGRE_LOCK_MUTEX(mIndexBuffersMutex)
+			CM_LOCK_MUTEX(mIndexBuffersMutex)
 			mIndexBuffers.insert(buf);
 		}
 		return HardwareIndexBufferPtr(buf);
@@ -155,7 +155,7 @@ namespace Ogre {
 		// simple forward link search based on alloc sizes
 		// not that fast but the list should never get that long since not many
 		// locks at once (hopefully)
-		OGRE_LOCK_MUTEX(mScratchMutex)
+		CM_LOCK_MUTEX(mScratchMutex)
 
 
 		// Alignment - round up the size to 32 bits
@@ -205,7 +205,7 @@ namespace Ogre {
 	//---------------------------------------------------------------------
 	void GLHardwareBufferManagerBase::deallocateScratch(void* ptr)
 	{
-		OGRE_LOCK_MUTEX(mScratchMutex)
+		CM_LOCK_MUTEX(mScratchMutex)
 
 		// Simple linear search dealloc
 		uint32 bufferPos = 0;

CamelotRenderer/RenderSystemGL/Source/OgreGLRenderSystem.cpp

@@ -52,7 +52,7 @@ THE SOFTWARE.s
 // Convenience macro from ARB_vertex_buffer_object spec
 #define VBO_BUFFER_OFFSET(i) ((char *)NULL + (i))
 
-#if OGRE_THREAD_SUPPORT != 1
+#if CM_THREAD_SUPPORT != 1
 GLenum glewContextInit (Ogre::GLSupport *glSupport);
 #endif
 
@@ -1022,7 +1022,7 @@ namespace Ogre {
 		mGLSupport->initialiseExtensions();
 
 		// Get extension function pointers
-#if OGRE_THREAD_SUPPORT != 1
+#if CM_THREAD_SUPPORT != 1
 		glewContextInit(mGLSupport);
 #endif
 	}
@@ -3382,7 +3382,7 @@ GL_RGB_SCALE : GL_ALPHA_SCALE, 1);
 	//---------------------------------------------------------------------
 	void GLRenderSystem::registerThread()
 	{
-		OGRE_LOCK_MUTEX(mThreadInitMutex)
+		CM_LOCK_MUTEX(mThreadInitMutex)
 		// This is only valid once we've created the main context
 		if (!mMainContext)
 		{
@@ -3418,14 +3418,14 @@ GL_RGB_SCALE : GL_ALPHA_SCALE, 1);
 	//---------------------------------------------------------------------
 	void GLRenderSystem::preExtraThreadsStarted()
 	{
-		OGRE_LOCK_MUTEX(mThreadInitMutex)
+		CM_LOCK_MUTEX(mThreadInitMutex)
 		// free context, we'll need this to share lists
 		mCurrentContext->endCurrent();
 	}
 	//---------------------------------------------------------------------
 	void GLRenderSystem::postExtraThreadsStarted()
 	{
-		OGRE_LOCK_MUTEX(mThreadInitMutex)
+		CM_LOCK_MUTEX(mThreadInitMutex)
 		// reacquire context
 		mCurrentContext->setCurrent();
 	}

CamelotRenderer/RenderSystemGL/Source/OgreWin32GLSupport.cpp

@@ -11,7 +11,7 @@
 
 using namespace Ogre;
 
-#if OGRE_THREAD_SUPPORT != 1
+#if CM_THREAD_SUPPORT != 1
 GLenum wglewContextInit (Ogre::GLSupport *glSupport);
 #endif
 
@@ -397,7 +397,7 @@ namespace Ogre {
 		// First, initialise the normal extensions
 		GLSupport::initialiseExtensions();
 		// wglew init
-#if OGRE_THREAD_SUPPORT != 1
+#if CM_THREAD_SUPPORT != 1
 		wglewContextInit(this);
 #endif
 

CamelotRenderer/RenderSystemGL/Source/win32/OgreWin32Context.cpp

@@ -99,19 +99,19 @@ namespace Ogre {
 	}
 }
 
-#if OGRE_THREAD_SUPPORT == 1
+#if CM_THREAD_SUPPORT == 1
 
 // declared in OgreGLPrerequisites.h 
 WGLEWContext * wglewGetContext()
 {
 	using namespace Ogre;
-	static OGRE_THREAD_POINTER_VAR(WGLEWContext, WGLEWContextsPtr);
+	static CM_THREAD_POINTER_VAR(WGLEWContext, WGLEWContextsPtr);
 
-	WGLEWContext * currentWGLEWContextsPtr = OGRE_THREAD_POINTER_GET(WGLEWContextsPtr);
+	WGLEWContext * currentWGLEWContextsPtr = CM_THREAD_POINTER_GET(WGLEWContextsPtr);
 	if (currentWGLEWContextsPtr == NULL)
 	{
 		currentWGLEWContextsPtr = new WGLEWContext();
-		OGRE_THREAD_POINTER_SET(WGLEWContextsPtr, currentWGLEWContextsPtr);
+		CM_THREAD_POINTER_SET(WGLEWContextsPtr, currentWGLEWContextsPtr);
 		ZeroMemory(currentWGLEWContextsPtr, sizeof(WGLEWContext));
 		wglewInit();
 

CamelotUtility/Include/CmPrerequisitesUtil.h

@@ -27,6 +27,8 @@ THE SOFTWARE
 
 #include <assert.h>
 
+#define CM_THREAD_SUPPORT 0 // No thread support for now
+
 // Platform-specific stuff
 #include "CmPlatform.h"
 

CamelotUtility/Include/CmThreadDefines.h

@@ -25,33 +25,33 @@ THE SOFTWARE
 -------------------------------------------------------------------------*/
 #pragma once
 
-#define OGRE_AUTO_MUTEX_NAME mutex
-#define OGRE_AUTO_MUTEX
-#define OGRE_LOCK_AUTO_MUTEX
-#define OGRE_MUTEX(name)
-#define OGRE_STATIC_MUTEX(name)
-#define OGRE_STATIC_MUTEX_INSTANCE(name)
-#define OGRE_LOCK_MUTEX(name)
-#define OGRE_LOCK_MUTEX_NAMED(mutexName, lockName)
-#define OGRE_AUTO_SHARED_MUTEX
-#define OGRE_LOCK_AUTO_SHARED_MUTEX
-#define OGRE_NEW_AUTO_SHARED_MUTEX
-#define OGRE_DELETE_AUTO_SHARED_MUTEX
-#define OGRE_COPY_AUTO_SHARED_MUTEX(from)
-#define OGRE_SET_AUTO_SHARED_MUTEX_NULL
-#define OGRE_MUTEX_CONDITIONAL(name) if(true)
-#define OGRE_RW_MUTEX(name)
-#define OGRE_LOCK_RW_MUTEX_READ(name)
-#define OGRE_LOCK_RW_MUTEX_WRITE(name)
-#define OGRE_THREAD_SYNCHRONISER(sync) 
-#define OGRE_THREAD_WAIT(sync, lock) 
-#define OGRE_THREAD_NOTIFY_ONE(sync) 
-#define OGRE_THREAD_NOTIFY_ALL(sync) 
-#define OGRE_THREAD_POINTER(T, var) T* var
-#define OGRE_THREAD_POINTER_INIT(var) var(0)
-#define OGRE_THREAD_POINTER_VAR(T, var) T* var = 0
-#define OGRE_THREAD_POINTER_SET(var, expr) var = expr
-#define OGRE_THREAD_POINTER_GET(var) var
-#define OGRE_THREAD_POINTER_DELETE(var) { OGRE_DELETE var; var = 0; }
-#define OGRE_THREAD_SLEEP(ms)
-#define OGRE_THREAD_WORKER_INHERIT
+#define CM_AUTO_MUTEX_NAME mutex
+#define CM_AUTO_MUTEX
+#define CM_LOCK_AUTO_MUTEX
+#define CM_MUTEX(name)
+#define CM_STATIC_MUTEX(name)
+#define CM_STATIC_MUTEX_INSTANCE(name)
+#define CM_LOCK_MUTEX(name)
+#define CM_LOCK_MUTEX_NAMED(mutexName, lockName)
+#define CM_AUTO_SHARED_MUTEX
+#define CM_LOCK_AUTO_SHARED_MUTEX
+#define CM_NEW_AUTO_SHARED_MUTEX
+#define CM_DELETE_AUTO_SHARED_MUTEX
+#define CM_COPY_AUTO_SHARED_MUTEX(from)
+#define CM_SET_AUTO_SHARED_MUTEX_NULL
+#define CM_MUTEX_CONDITIONAL(name) if(true)
+#define CM_RW_MUTEX(name)
+#define CM_LOCK_RW_MUTEX_READ(name)
+#define CM_LOCK_RW_MUTEX_WRITE(name)
+#define CM_THREAD_SYNCHRONISER(sync) 
+#define CM_THREAD_WAIT(sync, lock) 
+#define CM_THREAD_NOTIFY_ONE(sync) 
+#define CM_THREAD_NOTIFY_ALL(sync) 
+#define CM_THREAD_POINTER(T, var) T* var
+#define CM_THREAD_POINTER_INIT(var) var(0)
+#define CM_THREAD_POINTER_VAR(T, var) T* var = 0
+#define CM_THREAD_POINTER_SET(var, expr) var = expr
+#define CM_THREAD_POINTER_GET(var) var
+#define CM_THREAD_POINTER_DELETE(var) { delete var; var = 0; }
+#define CM_THREAD_SLEEP(ms)
+#define CM_THREAD_WORKER_INHERIT