Renamed std containers so they start with capital letters to be standardized with other Camelot classes

BansheeEngine/Include/BsBuiltinMaterialManager.h

@@ -39,7 +39,7 @@ namespace BansheeEngine
 		void setActive(const CM::String& renderSystemName);
 
 	private:
-		CM::unordered_map<CM::String, BuiltinMaterialFactory*>::type mAvailableFactories;
+		CM::UnorderedMap<CM::String, BuiltinMaterialFactory*>::type mAvailableFactories;
 		BuiltinMaterialFactory* mActiveFactory;
 	};
 }

BansheeEngine/Include/BsDebugDraw.h

@@ -47,7 +47,7 @@ namespace BansheeEngine
 		CM::HMaterial mTriangleMaterial;
 		CM::HMaterial mLineMaterial;
 
-		CM::vector<DebugDrawCommand>::type mCommands;
+		CM::Vector<DebugDrawCommand>::type mCommands;
 
 		static const int VertexSize = 16;
 

BansheeEngine/Include/BsGUILayout.h

@@ -97,8 +97,8 @@ namespace BansheeEngine
 
 		virtual void _updateOptimalSizes() = 0;
 	protected:
-		CM::vector<GUILayoutEntry>::type mChildren;	
-		CM::vector<CM::Int2>::type mOptimalSizes;
+		CM::Vector<GUILayoutEntry>::type mChildren;	
+		CM::Vector<CM::Int2>::type mOptimalSizes;
 		CM::UINT32 mOptimalWidth;
 		CM::UINT32 mOptimalHeight;
 

BansheeEngine/Include/BsGUIManager.h

@@ -21,10 +21,10 @@ namespace BansheeEngine
 				:isDirty(true)
 			{ }
 
-			CM::vector<CM::HMesh>::type cachedMeshes;
-			CM::vector<CM::HMaterial>::type cachedMaterials;
-			CM::vector<GUIWidget*>::type cachedWidgetsPerMesh;
-			CM::vector<GUIWidget*>::type widgets;
+			CM::Vector<CM::HMesh>::type cachedMeshes;
+			CM::Vector<CM::HMaterial>::type cachedMaterials;
+			CM::Vector<GUIWidget*>::type cachedWidgetsPerMesh;
+			CM::Vector<GUIWidget*>::type widgets;
 			bool isDirty;
 		};
 
@@ -38,8 +38,8 @@ namespace BansheeEngine
 		void update();
 		void render(CM::ViewportPtr& target, CM::RenderContext& renderContext);
 	private:
-		CM::vector<GUIWidget*>::type mWidgets;
-		CM::unordered_map<const CM::Viewport*, GUIRenderData>::type mCachedGUIData;
+		CM::Vector<GUIWidget*>::type mWidgets;
+		CM::UnorderedMap<const CM::Viewport*, GUIRenderData>::type mCachedGUIData;
 
 		// Element and widget mouse is currently over
 		GUIWidget* mMouseOverWidget;

BansheeEngine/Include/BsGUIMaterialManager.h

@@ -50,7 +50,7 @@ namespace BansheeEngine
 			CM::UINT32 refCount;
 		};
 
-		mutable CM::vector<GUIMaterial>::type mTextMaterials;
-		mutable CM::vector<GUIMaterial>::type mImageMaterials;
+		mutable CM::Vector<GUIMaterial>::type mTextMaterials;
+		mutable CM::Vector<GUIMaterial>::type mImageMaterials;
 	};
 }

BansheeEngine/Include/BsGUISkin.h

@@ -14,6 +14,6 @@ namespace BansheeEngine
 	private:
 		static GUIElementStyle DefaultStyle;
 
-		CM::unordered_map<CM::String, GUIElementStyle>::type mStyles;
+		CM::UnorderedMap<CM::String, GUIElementStyle>::type mStyles;
 	};
 }

BansheeEngine/Include/BsGUIWidget.h

@@ -43,7 +43,7 @@ namespace BansheeEngine
 
 		CM::RenderWindow* getOwnerWindow() const { return mOwnerWindow; }
 		CM::Viewport* getTarget() const { return mTarget; }
-		const CM::vector<GUIElement*>::type& getElements() const { return mElements; }
+		const CM::Vector<GUIElement*>::type& getElements() const { return mElements; }
 
 		void _updateLayout();
 
@@ -80,8 +80,8 @@ namespace BansheeEngine
 
 		CM::RenderWindow* mOwnerWindow;
 		CM::Viewport* mTarget;
-		CM::vector<GUIElement*>::type mElements;
-		CM::vector<GUIArea*>::type mAreas;
+		CM::Vector<GUIElement*>::type mElements;
+		CM::Vector<GUIArea*>::type mAreas;
 		CM::UINT8 mDepth;
 
 		CM::Vector3 mLastFramePosition;
@@ -93,8 +93,8 @@ namespace BansheeEngine
 
 		mutable bool mWidgetIsDirty;
 		mutable CM::Rect mBounds;
-		mutable CM::vector<CM::HMesh>::type mCachedMeshes;
-		mutable CM::vector<CM::HMaterial>::type mCachedMaterials;
+		mutable CM::Vector<CM::HMesh>::type mCachedMeshes;
+		mutable CM::Vector<CM::HMaterial>::type mCachedMaterials;
 
 		const GUISkin* mSkin;
 		static GUISkin DefaultSkin;

BansheeEngine/Include/BsOverlayManager.h

@@ -31,6 +31,6 @@ namespace BansheeEngine
 		void detachOverlay(const CM::Viewport* target, const Overlay* overlay);
 		void detachOverlayFromAll(const Overlay* overlay);
 
-		CM::unordered_map<const CM::Viewport*, CM::set<const Overlay*, OverlayComparer>::type>::type mOverlaysPerTarget;
+		CM::UnorderedMap<const CM::Viewport*, CM::Set<const Overlay*, OverlayComparer>::type>::type mOverlaysPerTarget;
 	};
 }

BansheeEngine/Include/BsSceneManager.h

@@ -14,12 +14,12 @@ namespace BansheeEngine
 		/**
 		 * @brief	Returns all cameras in the scene.
 		 */
-		virtual const CM::vector<HCamera>::type& getAllCameras() const = 0;
+		virtual const CM::Vector<HCamera>::type& getAllCameras() const = 0;
 
 		/**
 		 * @brief	Returns all renderables visible to the specified camera.
 		 */
-		virtual CM::vector<HRenderable>::type getVisibleRenderables(const HCamera& camera) const = 0;
+		virtual CM::Vector<HRenderable>::type getVisibleRenderables(const HCamera& camera) const = 0;
 	};
 
 	BS_EXPORT SceneManager& gSceneManager();

BansheeEngine/Include/BsSprite.h

@@ -93,7 +93,7 @@ namespace BansheeEngine
 
 	protected:
 		mutable CM::Rect mBounds;
-		mutable CM::vector<SpriteRenderElement>::type mCachedRenderElements;
+		mutable CM::Vector<SpriteRenderElement>::type mCachedRenderElements;
 
 		void updateBounds() const;
 		void clearMesh() const;

BansheeEngine/Source/BsDebugDraw.cpp

@@ -104,7 +104,7 @@ namespace BansheeEngine
 		UINT32 lineVertexOffset = 0;
 		UINT32 triangleIndexOffset = 0;
 		UINT32 triangleVertexOffset = 0;
-		vector<DebugDrawCommand>::type newCommands;
+		Vector<DebugDrawCommand>::type newCommands;
 		for(auto& command : mCommands)
 		{
 			if(command.type == DebugDrawType::Line)

BansheeEngine/Source/BsEngineGUI.cpp

@@ -56,7 +56,7 @@ namespace BansheeEngine
 			{
 				FontImportOptions* importOptions = static_cast<FontImportOptions*>(fontImportOptions.get());
 
-				vector<CamelotFramework::UINT32>::type fontSizes;
+				Vector<CamelotFramework::UINT32>::type fontSizes;
 				fontSizes.push_back(DefaultFontSize);
 				importOptions->setFontSizes(fontSizes);
 				importOptions->setAntialiasing(false);

BansheeEngine/Source/BsGUIManager.cpp

@@ -37,7 +37,7 @@ namespace BansheeEngine
 		UINT32 numQuads;
 		UINT32 depth;
 		Rect bounds;
-		vector<GUIGroupElement>::type elements;
+		Vector<GUIGroupElement>::type elements;
 	};
 
 	GUIManager::GUIManager()
@@ -205,11 +205,11 @@ namespace BansheeEngine
 				return aDepth > bDepth || (aDepth ==bDepth && a.element > b.element); 
 			};
 
-			set<GUIGroupElement, std::function<bool(const GUIGroupElement&, const GUIGroupElement&)>>::type allElements(elemComp);
+			Set<GUIGroupElement, std::function<bool(const GUIGroupElement&, const GUIGroupElement&)>>::type allElements(elemComp);
 
 			for(auto& widget : renderData.widgets)
 			{
-				const vector<GUIElement*>::type& elements = widget->getElements();
+				const Vector<GUIElement*>::type& elements = widget->getElements();
 
 				for(auto& element : elements)
 				{
@@ -223,7 +223,7 @@ namespace BansheeEngine
 
 			// Group the elements in such a way so that we end up with a smallest amount of
 			// meshes, without breaking back to front rendering order
-			unordered_map<UINT64, vector<GUIMaterialGroup>::type>::type materialGroups;
+			UnorderedMap<UINT64, Vector<GUIMaterialGroup>::type>::type materialGroups;
 			for(auto& elem : allElements)
 			{
 				GUIElement* guiElem = elem.element;
@@ -241,13 +241,13 @@ namespace BansheeEngine
 				// If this is a new material, add a new list of groups
 				auto findIterMaterial = materialGroups.find(materialId);
 				if(findIterMaterial == end(materialGroups))
-					materialGroups[materialId] = vector<GUIMaterialGroup>::type();
+					materialGroups[materialId] = Vector<GUIMaterialGroup>::type();
 
 				// Try to find a group this material will fit in:
 				//  - Group that has a depth value same or one below elements depth will always be a match
 				//  - Otherwise, we search higher depth values as well, but we only use them if no elements in between those depth values
 				//    overlap the current elements bounds.
-				vector<GUIMaterialGroup>::type& allGroups = materialGroups[materialId];
+				Vector<GUIMaterialGroup>::type& allGroups = materialGroups[materialId];
 				GUIMaterialGroup* foundGroup = nullptr;
 				for(auto groupIter = allGroups.rbegin(); groupIter != allGroups.rend(); ++groupIter)
 				{
@@ -325,7 +325,7 @@ namespace BansheeEngine
 				// requires all elements to be unique
 			};
 
-			set<GUIMaterialGroup*, std::function<bool(GUIMaterialGroup*, GUIMaterialGroup*)>>::type sortedGroups(groupComp);
+			Set<GUIMaterialGroup*, std::function<bool(GUIMaterialGroup*, GUIMaterialGroup*)>>::type sortedGroups(groupComp);
 			for(auto& material : materialGroups)
 			{
 				for(auto& group : material.second)
@@ -442,7 +442,7 @@ namespace BansheeEngine
 
 #if CM_DEBUG_MODE
 		// Checks if all referenced windows actually exist
-		vector<RenderWindow*>::type activeWindows = RenderWindowManager::instance().getRenderWindows();
+		Vector<RenderWindow*>::type activeWindows = RenderWindowManager::instance().getRenderWindows();
 		for(auto& widget : mWidgets)
 		{
 			auto iterFind = std::find(begin(activeWindows), end(activeWindows), widget->getOwnerWindow());
@@ -495,7 +495,7 @@ namespace BansheeEngine
 					Vector4 vecLocalPos = worldTfrm.inverse() * vecScreenPos;
 					localPos = Int2(Math::RoundToInt(vecLocalPos.x), Math::RoundToInt(vecLocalPos.y));
 
-					vector<GUIElement*>::type sortedElements = widget->getElements();
+					Vector<GUIElement*>::type sortedElements = widget->getElements();
 					std::sort(sortedElements.begin(), sortedElements.end(), 
 						[](GUIElement* a, GUIElement* b)
 					{

BansheeEngine/Source/BsTextSprite.cpp

@@ -20,8 +20,8 @@ namespace BansheeEngine
 		if(textData == nullptr)
 			return;
 
-		const CM::vector<TextUtility::TextLine>::type& lines = textData->getLines();
-		const CM::vector<UINT32>::type& quadsPerPage = textData->getNumQuadsPerPage();
+		const CM::Vector<TextUtility::TextLine>::type& lines = textData->getLines();
+		const CM::Vector<UINT32>::type& quadsPerPage = textData->getNumQuadsPerPage();
 
 		UINT32 curHeight = 0;
 		for(auto& line : lines)
@@ -75,7 +75,7 @@ namespace BansheeEngine
 			mCachedRenderElements.resize(quadsPerPage.size());
 
 		// Actually generate a mesh
-		const CM::vector<HTexture>::type& texturePages = textData->getTexturePages();
+		const CM::Vector<HTexture>::type& texturePages = textData->getTexturePages();
 		UINT32 texPage = 0;
 		for(auto& cachedElem : mCachedRenderElements)
 		{
@@ -108,7 +108,7 @@ namespace BansheeEngine
 		Int2 offset = getAnchorOffset(desc.anchor, desc.width, desc.height);
 		UINT32 numPages = (UINT32)quadsPerPage.size();
 		UINT32 curY = 0;
-		vector<UINT32>::type faceOffsets(mCachedRenderElements.size(), 0);
+		Vector<UINT32>::type faceOffsets(mCachedRenderElements.size(), 0);
 		for(size_t i = 0; i < lines.size(); i++)
 		{
 			UINT32 horzOffset = 0;

BansheeForwardRenderer/Source/BsForwardRenderer.cpp

@@ -34,10 +34,10 @@ namespace BansheeEngine
 	void ForwardRenderer::renderAll() 
 	{
 		RenderContext& renderContext = gMainRC();
-		const vector<HCamera>::type& allCameras = gSceneManager().getAllCameras();
+		const Vector<HCamera>::type& allCameras = gSceneManager().getAllCameras();
 
 		// Find all unique render targets
-		unordered_set<RenderTargetPtr>::type renderTargets;
+		UnorderedSet<RenderTargetPtr>::type renderTargets;
 		for(auto& camera : allCameras)
 		{
 			RenderTargetPtr target = camera->getViewport()->getTarget();
@@ -78,7 +78,7 @@ namespace BansheeEngine
 
 	void ForwardRenderer::render(const HCamera& camera) 
 	{
-		vector<HRenderable>::type allRenderables;
+		Vector<HRenderable>::type allRenderables;
 		
 		if(!camera->getIgnoreSceneRenderables())
 			allRenderables = gSceneManager().getVisibleRenderables(camera);

BansheeOctreeSM/Include/BsOctreeSceneManager.h

@@ -11,13 +11,13 @@ namespace BansheeEngine
 		OctreeSceneManager() {}
 		~OctreeSceneManager() {}
 
-		const CM::vector<HCamera>::type& getAllCameras() const { return mCachedCameras; }
+		const CM::Vector<HCamera>::type& getAllCameras() const { return mCachedCameras; }
 
-		CM::vector<HRenderable>::type getVisibleRenderables(const HCamera& camera) const;
+		CM::Vector<HRenderable>::type getVisibleRenderables(const HCamera& camera) const;
 	private:
 		void notifyComponentAdded(const CM::HComponent& component);
 		void notifyComponentRemoved(const CM::HComponent& component);
 
-		CM::vector<HCamera>::type mCachedCameras;
+		CM::Vector<HCamera>::type mCachedCameras;
 	};
 }

BansheeOctreeSM/Source/BsOctreeSceneManager.cpp

@@ -9,13 +9,13 @@ using namespace CamelotFramework;
 
 namespace BansheeEngine
 {
-	vector<HRenderable>::type OctreeSceneManager::getVisibleRenderables(const HCamera& camera) const
+	Vector<HRenderable>::type OctreeSceneManager::getVisibleRenderables(const HCamera& camera) const
 	{
 		// TODO - Cull invisible objects
 
-		vector<HRenderable>::type renderables;
+		Vector<HRenderable>::type renderables;
 
-		stack<HSceneObject>::type todo;
+		Stack<HSceneObject>::type todo;
 		todo.push(mRootNode);
 
 		while(!todo.empty())

CamelotClient/BsGUITabbedTitleBar.h

@@ -22,8 +22,8 @@ namespace BansheeEditor
 		boost::signal<void(CM::UINT32)> onTabAdded;
 		boost::signal<void(CM::UINT32)> onTabRemoved;
 	protected:
-		CM::vector<BS::GUITexture*>::type mDragDropElements;
-		CM::vector<BS::GUIToggle*>::type mTabButtons;
+		CM::Vector<BS::GUITexture*>::type mDragDropElements;
+		CM::Vector<BS::GUIToggle*>::type mTabButtons;
 
 		BS::GUIArea* mMainArea;
 		BS::GUILayout* mMainLayout;

CamelotCore/Include/CmApplication.h

@@ -26,7 +26,7 @@ namespace CamelotFramework
 
 		RENDER_WINDOW_DESC primaryWindowDesc;
 
-		vector<String>::type importers;
+		Vector<String>::type importers;
 
 		String resourceCacheDirectory;
 	};

CamelotCore/Include/CmCgProgram.h

@@ -72,7 +72,7 @@ namespace CamelotFramework {
 		CGprofile mSelectedCgProfile;
 
 		CgProgram(CGcontext context, const String& source, const String& entryPoint, const String& language, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, 
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, 
 			bool isAdjacencyInfoRequired = false);
 
         /** Internal load implementation, must be implemented by subclasses.

CamelotCore/Include/CmCgProgramFactory.h

@@ -46,7 +46,7 @@ namespace CamelotFramework
 		/// Get the name of the language this factory creates programs for
 		const String& getLanguage(void) const;
         HighLevelGpuProgramPtr create(const String& source, const String& entryPoint, GpuProgramType gptype, 
-			GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes = nullptr);
+			GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes = nullptr);
 		HighLevelGpuProgramPtr create();
     };
 }

CamelotCore/Include/CmCommandQueue.h

@@ -117,12 +117,12 @@ namespace CamelotFramework
 		 * @param	notifyCallback  	Callback that will be called if a command that has "notifyOnComplete" flag set.
 		 * 								The callback will receive "callbackId" of the command.
 		 */
-		void playback(queue<QueuedCommand>::type* commands, boost::function<void(UINT32)> notifyCallback);
+		void playback(Queue<QueuedCommand>::type* commands, boost::function<void(UINT32)> notifyCallback);
 
 		/**
 		 * @brief	Plays all provided commands. To get the commands call flush().
 		 */
-		void playback(queue<QueuedCommand>::type* commands);
+		void playback(Queue<QueuedCommand>::type* commands);
 
 		/**
 		 * @brief	Allows you to set a breakpoint that will trigger when the specified command is executed.
@@ -176,7 +176,7 @@ namespace CamelotFramework
 		 * @brief	Returns a copy of all queued commands and makes room for new ones. Must be called from the thread
 		 * 			that created the command queue. Returned commands MUST be passed to "playback" method.
 		 */
-		CamelotFramework::queue<QueuedCommand>::type* flush();
+		CamelotFramework::Queue<QueuedCommand>::type* flush();
 
 		/**
 		 * @brief	Cancels all currently queued commands.
@@ -192,7 +192,7 @@ namespace CamelotFramework
 		void throwInvalidThreadException(const String& message) const;
 
 	private:
-		CamelotFramework::queue<QueuedCommand>::type* mCommands;
+		CamelotFramework::Queue<QueuedCommand>::type* mCommands;
 
 		bool mAllowAllThreads;
 		
@@ -229,7 +229,7 @@ namespace CamelotFramework
 		UINT32 mCommandQueueIdx;
 
 		static UINT32 MaxCommandQueueIdx;
-		static unordered_set<QueueBreakpoint, QueueBreakpoint::HashFunction, QueueBreakpoint::EqualFunction>::type SetBreakpoints;
+		static UnorderedSet<QueueBreakpoint, QueueBreakpoint::HashFunction, QueueBreakpoint::EqualFunction>::type SetBreakpoints;
 		CM_STATIC_MUTEX(CommandQueueBreakpointMutex);
 
 		static void breakIfNeeded(UINT32 queueIdx, UINT32 commandIdx);
@@ -299,7 +299,7 @@ namespace CamelotFramework
 		/**
 		 * @copydoc CommandQueueBase::flush
 		 */
-		CamelotFramework::queue<QueuedCommand>::type* flush()
+		CamelotFramework::Queue<QueuedCommand>::type* flush()
 		{
 #if CM_DEBUG_MODE
 #if CM_THREAD_SUPPORT != 0
@@ -309,7 +309,7 @@ namespace CamelotFramework
 #endif
 
 			lock();
-			CamelotFramework::queue<QueuedCommand>::type* commands = CommandQueueBase::flush();
+			CamelotFramework::Queue<QueuedCommand>::type* commands = CommandQueueBase::flush();
 			unlock();
 
 			return commands;

CamelotCore/Include/CmCommonEnums.h

@@ -327,7 +327,7 @@ namespace CamelotFramework {
 	};
     
 	/// Name / value parameter pair (first = name, second = value)
-	typedef map<String, String>::type NameValuePairList;
+	typedef Map<String, String>::type NameValuePairList;
 
 	/** @} */
 }

CamelotCore/Include/CmCoreObjectManager.h

@@ -18,7 +18,7 @@ namespace CamelotFramework
 	private:
 		// Keeps a list of ALL loaded core GPU objects
 		UINT64 mNextAvailableID;
-		map<UINT64, CoreObject*>::type mObjects;
+		Map<UINT64, CoreObject*>::type mObjects;
 		CM_MUTEX(mObjectsMutex);
 	};
 }

CamelotCore/Include/CmDeferredRenderContext.h

@@ -247,7 +247,7 @@ namespace CamelotFramework
 		 */
 		void submitToGpu(bool blockUntilComplete = false)
 		{
-			queue<QueuedCommand>::type* commands = mCommandQueue->flush();
+			Queue<QueuedCommand>::type* commands = mCommandQueue->flush();
 
 			RenderSystem* rs = RenderSystem::instancePtr();
 			rs->queueCommand(boost::bind(&CommandQueueBase::playback, mCommandQueue, commands), blockUntilComplete);

CamelotCore/Include/CmFont.h

@@ -10,7 +10,7 @@ namespace CamelotFramework
 	{
 		UINT32 size;
 		FONT_DESC fontDesc;
-		vector<HTexture>::type texturePages;
+		Vector<HTexture>::type texturePages;
 
 		const CHAR_DESC& getCharDesc(UINT32 charId) const;
 
@@ -33,7 +33,7 @@ namespace CamelotFramework
 	public:
 		virtual ~Font();
 
-		void initialize(vector<FontData>::type& fontData);
+		void initialize(Vector<FontData>::type& fontData);
 
 		const FontData* getFontDataForSize(UINT32 size) const;
 		INT32 getClosestAvailableSize(UINT32 size) const;
@@ -44,7 +44,7 @@ namespace CamelotFramework
 		Font();
 
 	private:
-		map<UINT32, FontData>::type mFontDataPerSize;
+		Map<UINT32, FontData>::type mFontDataPerSize;
 
 		/************************************************************************/
 		/* 								SERIALIZATION                      		*/
@@ -59,6 +59,6 @@ namespace CamelotFramework
 		/************************************************************************/
 		
 	public:
-		static HFont create(vector<FontData>::type& fontInitData);
+		static HFont create(Vector<FontData>::type& fontInitData);
 	};
 }

CamelotCore/Include/CmFontDesc.h

@@ -20,12 +20,12 @@ namespace CamelotFramework
 		INT32 xOffset, yOffset;
 		INT32 xAdvance, yAdvance;
 
-		vector<KerningPair>::type kerningPairs;
+		Vector<KerningPair>::type kerningPairs;
 	};
 
 	struct FONT_DESC
 	{
-		map<UINT32, CHAR_DESC>::type characters;
+		Map<UINT32, CHAR_DESC>::type characters;
 		INT32 baselineOffset;
 		UINT32 lineHeight;
 		CHAR_DESC missingGlyph;
@@ -96,7 +96,7 @@ namespace CamelotFramework
 				+ sizeof(data.yOffset)
 				+ sizeof(data.xAdvance)
 				+ sizeof(data.yAdvance)
-				+ RTTIPlainType<vector<KerningPair>::type>::getDynamicSize(data.kerningPairs);
+				+ RTTIPlainType<Vector<KerningPair>::type>::getDynamicSize(data.kerningPairs);
 
 			dataSize += sizeof(UINT32);
 
@@ -116,7 +116,7 @@ namespace CamelotFramework
 			memcpy(memory, &size, sizeof(UINT32));
 			memory += sizeof(UINT32);
 			
-			RTTIPlainType<map<UINT32, CHAR_DESC>::type>::toMemory(data.characters, memory);
+			RTTIPlainType<Map<UINT32, CHAR_DESC>::type>::toMemory(data.characters, memory);
 			rttiWriteElem(data.baselineOffset, memory);
 			rttiWriteElem(data.lineHeight, memory);
 			rttiWriteElem(data.missingGlyph, memory);
@@ -129,7 +129,7 @@ namespace CamelotFramework
 			memcpy(&size, memory, sizeof(UINT32)); 
 			memory += sizeof(UINT32);
 
-			RTTIPlainType<map<UINT32, CHAR_DESC>::type>::fromMemory(data.characters, memory);
+			RTTIPlainType<Map<UINT32, CHAR_DESC>::type>::fromMemory(data.characters, memory);
 			rttiReadElem(data.baselineOffset, memory);
 			rttiReadElem(data.lineHeight, memory);
 			rttiReadElem(data.missingGlyph, memory);
@@ -141,7 +141,7 @@ namespace CamelotFramework
 		static UINT32 getDynamicSize(const FONT_DESC& data)	
 		{ 
 			UINT64 dataSize = sizeof(UINT32);
-			dataSize += RTTIPlainType<map<UINT32, CHAR_DESC>::type>::getDynamicSize(data.characters);
+			dataSize += RTTIPlainType<Map<UINT32, CHAR_DESC>::type>::getDynamicSize(data.characters);
 			dataSize += rttiGetElemSize(data.baselineOffset);
 			dataSize += rttiGetElemSize(data.lineHeight);
 			dataSize += rttiGetElemSize(data.missingGlyph);

CamelotCore/Include/CmFontImportOptions.h

@@ -11,14 +11,14 @@ namespace CamelotFramework
 	public:
 		FontImportOptions();
 
-		void setFontSizes(const vector<UINT32>::type& fontSizes) { mFontSizes = fontSizes; }
+		void setFontSizes(const Vector<UINT32>::type& fontSizes) { mFontSizes = fontSizes; }
 		void addCharIndexRange(UINT32 from, UINT32 to);
 		void clearCharIndexRanges();
 		void setDPI(UINT32 dpi) { mDPI = dpi; }
 		void setAntialiasing(bool enabled) { mAntialiasing = enabled; }
 
-		vector<UINT32>::type getFontSizes() const { return mFontSizes; }
-		vector<std::pair<UINT32, UINT32>>::type getCharIndexRanges() const { return mCharIndexRanges; }
+		Vector<UINT32>::type getFontSizes() const { return mFontSizes; }
+		Vector<std::pair<UINT32, UINT32>>::type getCharIndexRanges() const { return mCharIndexRanges; }
 		UINT32 getDPI() const { return mDPI; }
 		bool getAntialiasing() const { return mAntialiasing; }
 
@@ -31,8 +31,8 @@ namespace CamelotFramework
 		virtual RTTITypeBase* getRTTI() const;
 
 	private:
-		vector<UINT32>::type mFontSizes;
-		vector<std::pair<UINT32, UINT32>>::type mCharIndexRanges;
+		Vector<UINT32>::type mFontSizes;
+		Vector<std::pair<UINT32, UINT32>>::type mCharIndexRanges;
 		UINT32 mDPI;
 		bool mAntialiasing;
 	};

CamelotCore/Include/CmFontManager.h

@@ -8,7 +8,7 @@ namespace CamelotFramework
 	class CM_EXPORT FontManager : public Module<FontManager>
 	{
 	public:
-		FontPtr create(vector<FontData>::type& fontData) const;
+		FontPtr create(Vector<FontData>::type& fontData) const;
 		FontPtr createEmpty() const;
 	};
 }

CamelotCore/Include/CmFontRTTI.h

@@ -80,14 +80,14 @@ namespace CamelotFramework
 	{
 		struct FontInitData
 		{
-			vector<FontData>::type fontDataPerSize;
+			Vector<FontData>::type fontDataPerSize;
 		};
 
 	private:
 		FontData& getFontData(Font* obj, UINT32 idx)
 		{
 			if(idx >= obj->mFontDataPerSize.size())
-				CM_EXCEPT(InternalErrorException, "Index out of range: " + toString(idx) + ". Valid range: 0 .. " + toString(obj->mFontDataPerSize.size()));
+				CM_EXCEPT(InternalErrorException, "Index out of range: " + toString(idx) + ". Valid range: 0 .. " + toString((int)obj->mFontDataPerSize.size()));
 
 			auto iter = obj->mFontDataPerSize.begin();
 			for(UINT32 i = 0; i < idx; i++, ++iter)

CamelotCore/Include/CmGpuBuffer.h

@@ -53,7 +53,7 @@ namespace CamelotFramework
 			UINT32 refCount;
 		};
 
-		unordered_map<GPU_BUFFER_DESC, GpuBufferReference*, GpuBufferView::HashFunction, GpuBufferView::EqualFunction>::type mBufferViews;
+		UnorderedMap<GPU_BUFFER_DESC, GpuBufferReference*, GpuBufferView::HashFunction, GpuBufferView::EqualFunction>::type mBufferViews;
 
 	protected:
 		GpuBufferType mType;

CamelotCore/Include/CmGpuParamDesc.h

@@ -37,11 +37,11 @@ namespace CamelotFramework
 
 	struct GpuParamDesc
 	{
-		map<String, GpuParamBlockDesc>::type paramBlocks;
-		map<String, GpuParamDataDesc>::type params;
+		Map<String, GpuParamBlockDesc>::type paramBlocks;
+		Map<String, GpuParamDataDesc>::type params;
 
-		map<String, GpuParamObjectDesc>::type samplers;
-		map<String, GpuParamObjectDesc>::type textures;
-		map<String, GpuParamObjectDesc>::type buffers;
+		Map<String, GpuParamObjectDesc>::type samplers;
+		Map<String, GpuParamObjectDesc>::type textures;
+		Map<String, GpuParamObjectDesc>::type buffers;
 	};
 }

CamelotCore/Include/CmGpuParams.h

@@ -74,10 +74,10 @@ namespace CamelotFramework
 
 		GpuParamDataDesc* getParamDesc(const String& name) const;
 
-		vector<GpuParamBlock*>::type mParamBlocks;
-		vector<GpuParamBlockBufferPtr>::type mParamBlockBuffers;
-		vector<HTexture>::type mTextures;
-		vector<HSamplerState>::type mSamplerStates;
+		Vector<GpuParamBlock*>::type mParamBlocks;
+		Vector<GpuParamBlockBufferPtr>::type mParamBlockBuffers;
+		Vector<HTexture>::type mTextures;
+		Vector<HSamplerState>::type mSamplerStates;
 	};
 
 	/**

CamelotCore/Include/CmGpuProgram.h

@@ -148,7 +148,7 @@ namespace CamelotFramework {
 		friend class GpuProgramManager;
 
 		GpuProgram(const String& source, const String& entryPoint, const String& language, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, 
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, 
 			bool isAdjacencyInfoRequired = false);
 
         /** Internal method returns whether required capabilities for this program is supported.

CamelotCore/Include/CmGpuProgramImportOptions.h

@@ -15,13 +15,13 @@ namespace CamelotFramework
 		void setLanguage(const String& language) { mLanguage = language; }
 		void setProfile(GpuProgramProfile profile) { mProfile = profile; }
 		void setType(GpuProgramType type) { mType = type; }
-		void setIncludes(const vector<HGpuProgInclude>::type& includes) { mIncludes = includes; }
+		void setIncludes(const Vector<HGpuProgInclude>::type& includes) { mIncludes = includes; }
 
 		const String& getEntryPoint() const { return mEntryPoint; }
 		const String& getLanguage() const { return mLanguage; }
 		GpuProgramProfile getProfile() const { return mProfile; }
 		GpuProgramType getType() const { return mType; }
-		const vector<HGpuProgInclude>::type& getIncludes() const { return mIncludes; }
+		const Vector<HGpuProgInclude>::type& getIncludes() const { return mIncludes; }
 
 		/************************************************************************/
 		/* 								SERIALIZATION                      		*/
@@ -36,6 +36,6 @@ namespace CamelotFramework
 		String mLanguage;
 		GpuProgramProfile mProfile;
 		GpuProgramType mType;
-		vector<HGpuProgInclude>::type mIncludes;
+		Vector<HGpuProgInclude>::type mIncludes;
 	};
 }

CamelotCore/Include/CmGpuProgramManager.h

@@ -46,7 +46,7 @@ namespace CamelotFramework {
 	{
 	public:
 
-		typedef set<String>::type SyntaxCodes;
+		typedef Set<String>::type SyntaxCodes;
 
 	protected:
 		/** General create method

CamelotCore/Include/CmGpuProgramParams.h

@@ -252,7 +252,7 @@ namespace CamelotFramework {
 			, arraySize(1)
 			, variability(GPV_GLOBAL) {}
 	};
-	typedef map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap;
+	typedef Map<String, GpuConstantDefinition>::type GpuConstantDefinitionMap;
 	typedef GpuConstantDefinitionMap::const_iterator GpuConstantDefinitionIterator;
 
 	/// Struct collecting together the information for named constants.
@@ -325,7 +325,7 @@ namespace CamelotFramework {
 		GpuLogicalIndexUse(UINT32 bufIdx, UINT32 curSz, UINT32 v) 
 			: physicalIndex(bufIdx), currentSize(curSz), variability(v) {}
 	};
-	typedef map<UINT32, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap;
+	typedef Map<UINT32, GpuLogicalIndexUse>::type GpuLogicalIndexUseMap;
 	/// Container struct to allow params to safely & update shared list of logical buffer assignments
 	struct CM_EXPORT GpuLogicalBufferStruct
 	{
@@ -341,12 +341,12 @@ namespace CamelotFramework {
 	@note Not necessarily in direct index order to constant indexes, logical
 	to physical index map is derived from GpuProgram
 	*/
-	typedef vector<float>::type FloatConstantList;
+	typedef Vector<float>::type FloatConstantList;
 	/** Definition of container that holds the current float constants.
 	@note Not necessarily in direct index order to constant indexes, logical
 	to physical index map is derived from GpuProgram
 	*/
-	typedef vector<int>::type IntConstantList;
+	typedef Vector<int>::type IntConstantList;
 
 	/** Collects together the program parameters used for a GpuProgram.
 	@remarks
@@ -406,9 +406,9 @@ namespace CamelotFramework {
 		/// Packed list of integer constants (physical indexing)
 		IntConstantList mIntConstants;
 		/// List of all texture parameters
-		vector<HTexture>::type mTextures;
+		Vector<HTexture>::type mTextures;
 		// List of all sampler states
-		vector<SamplerStatePtr>::type mSamplerStates;
+		Vector<SamplerStatePtr>::type mSamplerStates;
 		/** Logical index to physical index map - for low-level programs
 		or high-level programs which pass params this way. */
 		GpuLogicalBufferStructPtr mFloatLogicalToPhysical;
@@ -726,9 +726,9 @@ namespace CamelotFramework {
 		const GpuLogicalBufferStructPtr& getSamplerLogicalBufferStruct() const { return mSamplerLogicalToPhysical; }
 		SamplerStatePtr getSamplerState(UINT32 pos) const;
 		/// Get a reference to the list of textures
-		const vector<HTexture>::type& getTextureList() const { return mTextures; }
+		const Vector<HTexture>::type& getTextureList() const { return mTextures; }
 		UINT32 getNumTextures() const { return (UINT32)mTextures.size(); }
-		const vector<SamplerStatePtr>::type& getSamplerStateList() const { return mSamplerStates; }
+		const Vector<SamplerStatePtr>::type& getSamplerStateList() const { return mSamplerStates; }
 		UINT32 getNumSamplerStates() const { return (UINT32)mSamplerStates.size(); }
 
 		/** Tells the program whether to ignore missing parameters or not.

CamelotCore/Include/CmHighLevelGpuProgram.h

@@ -73,7 +73,7 @@ namespace CamelotFramework {
 
 		/** Constructor, should be used only by factory classes. */
 		HighLevelGpuProgram(const String& source, const String& entryPoint, const String& language, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes,
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes,
 			bool isAdjacencyInfoRequired = false);
 
 		/**
@@ -94,7 +94,7 @@ namespace CamelotFramework {
 		/************************************************************************/
 	public:
 		static HHighLevelGpuProgram create(const String& source, const String& entryPoint, 
-			const String& language, GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes = nullptr);
+			const String& language, GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes = nullptr);
     };
 
 	/** @} */

CamelotCore/Include/CmHighLevelGpuProgramManager.h

@@ -50,7 +50,7 @@ namespace CamelotFramework {
 		/// Get the name of the language this factory creates programs for
 		virtual const String& getLanguage(void) const = 0;
         virtual HighLevelGpuProgramPtr create(const String& source, const String& entryPoint, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes) = 0;
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes) = 0;
 		virtual HighLevelGpuProgramPtr create() = 0;
 	};
 	/** This ResourceManager manages high-level vertex and fragment programs. 
@@ -69,7 +69,7 @@ namespace CamelotFramework {
 	class CM_EXPORT HighLevelGpuProgramManager : public Module<HighLevelGpuProgramManager>
 	{
 	public:
-		typedef map<String, HighLevelGpuProgramFactory*>::type FactoryMap;
+		typedef Map<String, HighLevelGpuProgramFactory*>::type FactoryMap;
 	protected:
 		/// Factories capable of creating HighLevelGpuProgram instances
 		FactoryMap mFactories;
@@ -100,7 +100,7 @@ namespace CamelotFramework {
 		@param gptype The type of program to create
 		*/
 		HighLevelGpuProgramPtr create(const String& source, const String& entryPoint, const String& language, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes);
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes);
 
 		/** Create a new HighLevelGpuProgram. 
 		@par

CamelotCore/Include/CmImporter.h

@@ -69,7 +69,7 @@ namespace CamelotFramework
 		 */
 		void registerAssetImporter(SpecificImporter* importer);
 	private:
-		vector<SpecificImporter*>::type mAssetImporters;
+		Vector<SpecificImporter*>::type mAssetImporters;
 
 		SpecificImporter* getImporterForFile(const String& inputFilePath) const;
 	};

CamelotCore/Include/CmMaterial.h

@@ -107,23 +107,23 @@ namespace CamelotFramework
 		ShaderPtr mShader;
 		TechniquePtr mBestTechnique;
 
-		set<String>::type mValidShareableParamBlocks;
-		map<String, String>::type mValidParams; // Also maps Shader param name -> gpu variable name
+		Set<String>::type mValidShareableParamBlocks;
+		Map<String, String>::type mValidParams; // Also maps Shader param name -> gpu variable name
 
-		vector<PassParametersPtr>::type mParametersPerPass;
-		vector<GpuParamBlockBufferPtr>::type mParamBuffers;
+		Vector<PassParametersPtr>::type mParametersPerPass;
+		Vector<GpuParamBlockBufferPtr>::type mParamBuffers;
 
 		// These maps aren't necessary as we can read these values from the GpuParams directly
 		// but they make many things (especially serializing and getting values) so much easier
-		map<String, vector<float>::type>::type mFloatValues;
-		map<String, vector<Vector2>::type>::type mVec2Values;
-		map<String, vector<Vector3>::type>::type mVec3Values;
-		map<String, vector<Vector4>::type>::type mVec4Values;
-		map<String, vector<Matrix3>::type>::type mMat3Values;
-		map<String, vector<Matrix4>::type>::type mMat4Values;
-		map<String, vector<StructData>::type>::type mStructValues;
-		map<String, HTexture>::type mTextureValues;
-		map<String, HSamplerState>::type mSamplerValues;
+		Map<String, Vector<float>::type>::type mFloatValues;
+		Map<String, Vector<Vector2>::type>::type mVec2Values;
+		Map<String, Vector<Vector3>::type>::type mVec3Values;
+		Map<String, Vector<Vector4>::type>::type mVec4Values;
+		Map<String, Vector<Matrix3>::type>::type mMat3Values;
+		Map<String, Vector<Matrix4>::type>::type mMat4Values;
+		Map<String, Vector<StructData>::type>::type mStructValues;
+		Map<String, HTexture>::type mTextureValues;
+		Map<String, HSamplerState>::type mSamplerValues;
 
 		Material();
 
@@ -148,14 +148,14 @@ namespace CamelotFramework
 			}
 		}
 
-		const map<String, String>::type& getValidParamNames() const { return mValidParams; }
+		const Map<String, String>::type& getValidParamNames() const { return mValidParams; }
 
 		void initBestTechnique();
 
-		map<String, const GpuParamDataDesc*>::type determineValidDataParameters(const vector<const GpuParamDesc*>::type& paramDescs) const;
-		set<String>::type determineValidObjectParameters(const vector<const GpuParamDesc*>::type& paramDescs) const;
-		set<String>::type determineValidShareableParamBlocks(const vector<const GpuParamDesc*>::type& paramDescs) const;
-		map<String, String>::type determineParameterToBlockMapping(const vector<const GpuParamDesc*>::type& paramDescs);
+		Map<String, const GpuParamDataDesc*>::type determineValidDataParameters(const Vector<const GpuParamDesc*>::type& paramDescs) const;
+		Set<String>::type determineValidObjectParameters(const Vector<const GpuParamDesc*>::type& paramDescs) const;
+		Set<String>::type determineValidShareableParamBlocks(const Vector<const GpuParamDesc*>::type& paramDescs) const;
+		Map<String, String>::type determineParameterToBlockMapping(const Vector<const GpuParamDesc*>::type& paramDescs);
 
 		bool areParamsEqual(const GpuParamDataDesc& paramA, const GpuParamDataDesc& paramB, bool ignoreBufferOffsets = false) const;
 

CamelotCore/Include/CmMaterialRTTI.h

@@ -131,15 +131,15 @@ namespace CamelotFramework
 	class CM_EXPORT MaterialParams : public IReflectable
 	{
 	public:
-		vector<MaterialFloatParam>::type floatParams;
-		vector<MaterialVec2Param>::type vec2Params;
-		vector<MaterialVec3Param>::type vec3Params;
-		vector<MaterialVec4Param>::type vec4Params;
-		vector<MaterialMat3Param>::type mat3Params;
-		vector<MaterialMat4Param>::type mat4Params;
-		vector<MaterialStructParam>::type structParams;
-		vector<MaterialTextureParam>::type textureParams;
-		vector<MaterialSamplerStateParam>::type samplerStateParams;
+		Vector<MaterialFloatParam>::type floatParams;
+		Vector<MaterialVec2Param>::type vec2Params;
+		Vector<MaterialVec3Param>::type vec3Params;
+		Vector<MaterialVec4Param>::type vec4Params;
+		Vector<MaterialMat3Param>::type mat3Params;
+		Vector<MaterialMat4Param>::type mat4Params;
+		Vector<MaterialStructParam>::type structParams;
+		Vector<MaterialTextureParam>::type textureParams;
+		Vector<MaterialSamplerStateParam>::type samplerStateParams;
 
 		friend class MaterialParamsRTTI;
 		static RTTITypeBase* getRTTIStatic();

CamelotCore/Include/CmMesh.h

@@ -73,7 +73,7 @@ namespace CamelotFramework
 		VertexData* mVertexData;
 		IndexData* mIndexData;
 
-		vector<SubMesh>::type mSubMeshes;
+		Vector<SubMesh>::type mSubMeshes;
 
 		void throwIfNotRenderThread() const;
 

CamelotCore/Include/CmMeshData.h

@@ -199,7 +199,7 @@ namespace CamelotFramework
 
 		UINT32 getVertexStride(UINT32 streamIdx = 0) const;
 		
-		static MeshDataPtr combine(const vector<MeshDataPtr>::type& elements);
+		static MeshDataPtr combine(const Vector<MeshDataPtr>::type& elements);
 
 	protected:
 		UINT32 getInternalBufferSize();
@@ -214,8 +214,8 @@ namespace CamelotFramework
 		UINT32 mNumVertices;
 		IndexBuffer::IndexType mIndexType;
 
-		vector<IndexElementData>::type mSubMeshes;
-		vector<VertexElement>::type mVertexElements;
+		Vector<IndexElementData>::type mSubMeshes;
+		Vector<VertexElement>::type mVertexElements;
 
 		UINT32 getMaxStreamIdx() const;
 		bool hasStream(UINT32 streamIdx) const;

CamelotCore/Include/CmMultiRenderTexture.h

@@ -7,7 +7,7 @@ namespace CamelotFramework
 {
 	struct CM_EXPORT MULTI_RENDER_TEXTURE_DESC
 	{
-		vector<RENDER_SURFACE_DESC>::type colorSurfaces;
+		Vector<RENDER_SURFACE_DESC>::type colorSurfaces;
 		RENDER_SURFACE_DESC depthStencilSurface;
 	};
 
@@ -26,7 +26,7 @@ namespace CamelotFramework
 		bool requiresTextureFlipping() const { return false; }
 
 	protected:
-		vector<TextureViewPtr>::type mColorSurfaces;
+		Vector<TextureViewPtr>::type mColorSurfaces;
 		TextureViewPtr mDepthStencilSurface;
 
 		MultiRenderTexture();

CamelotCore/Include/CmPixelData.h

@@ -85,7 +85,7 @@ namespace CamelotFramework
 		// Number of pixel formats currently defined
         PF_COUNT = 30
     };
-	typedef vector<PixelFormat>::type PixelFormatList;
+	typedef Vector<PixelFormat>::type PixelFormatList;
 
     /**
      * Flags defining some on/off properties of pixel formats

CamelotCore/Include/CmRenderSystem.h

@@ -61,7 +61,7 @@ namespace CamelotFramework
 	*  @{
 	*/
 
-	typedef multimap<UINT8, RenderTarget * >::type RenderTargetPriorityMap;
+	typedef Multimap<UINT8, RenderTarget * >::type RenderTargetPriorityMap;
 
 	class TextureManager;
 
@@ -439,7 +439,7 @@ namespace CamelotFramework
 		CommandQueue<CommandQueueSync>* mCommandQueue;
 
 		UINT32 mMaxCommandNotifyId; // ID that will be assigned to the next command with a notifier callback
-		vector<UINT32>::type mCommandsCompleted; // Completed commands that have notifier callbacks set up
+		Vector<UINT32>::type mCommandsCompleted; // Completed commands that have notifier callbacks set up
 
 		SyncedRenderContext* mSyncedRenderContext;
 

CamelotCore/Include/CmRenderSystemCapabilities.h

@@ -198,7 +198,7 @@ namespace CamelotFramework
 
 		void fromString(const String& versionString)
 		{
-			vector<CamelotFramework::String>::type tokens = StringUtil::split(versionString, ".");
+			Vector<CamelotFramework::String>::type tokens = StringUtil::split(versionString, ".");
 			if(!tokens.empty())
 			{
 				major = parseInt(tokens[0]);
@@ -242,7 +242,7 @@ namespace CamelotFramework
 
 	public:
 
-		typedef set<String>::type ShaderProfiles;
+		typedef Set<String>::type ShaderProfiles;
 	private:
 		/// This is used to build a database of RSC's
 		/// if a RSC with same name, but newer version is introduced, the older one 
@@ -251,17 +251,17 @@ namespace CamelotFramework
 		/// GPU Vendor
 		GPUVendor mVendor;
 
-		static vector<CamelotFramework::String>::type msGPUVendorStrings;
+		static Vector<CamelotFramework::String>::type msGPUVendorStrings;
 		static void initVendorStrings();
 
 		/// The number of world matrices available
 		UINT16 mNumWorldMatrices;
 		/// The number of texture units available per stage
-		map<GpuProgramType, UINT16>::type mNumTextureUnitsPerStage;
+		Map<GpuProgramType, UINT16>::type mNumTextureUnitsPerStage;
 		/// Total number of texture units available
 		UINT16 mNumCombinedTextureUnits;
 		/// The number of uniform blocks available per stage
-		map<GpuProgramType, UINT16>::type mNumUniformBlocksPerStage;
+		Map<GpuProgramType, UINT16>::type mNumUniformBlocksPerStage;
 		/// Total number of uniform blocks available
 		UINT16 mNumCombinedUniformBlocks;
 		/// The stencil buffer bit depth
@@ -310,7 +310,7 @@ namespace CamelotFramework
 		ShaderProfiles mSupportedShaderProfiles;
 
 		// Allows us to convert a generic shader profile to a render-system specific one
-		unordered_map<GpuProgramProfile, String>::type mGenericToSpecificShaderProfileMap;
+		UnorderedMap<GpuProgramProfile, String>::type mGenericToSpecificShaderProfileMap;
 	public:	
 		RenderSystemCapabilities ();
 		virtual ~RenderSystemCapabilities ();

CamelotCore/Include/CmRenderSystemManager.h

@@ -15,7 +15,7 @@ namespace CamelotFramework
 
 		void registerRenderSystemFactory(RenderSystemFactoryPtr factory);
 	private:
-		vector<RenderSystemFactoryPtr>::type mAvailableFactories;
+		Vector<RenderSystemFactoryPtr>::type mAvailableFactories;
 	};
 }
 

CamelotCore/Include/CmRenderWindowManager.h

@@ -13,12 +13,12 @@ namespace CamelotFramework
 		*/
 		RenderWindowPtr create(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow);
 
-		vector<RenderWindow*>::type getRenderWindows() const;
+		Vector<RenderWindow*>::type getRenderWindows() const;
 	protected:
 		friend class RenderWindow;
 
 		CM_MUTEX(mWindowMutex);
-		vector<RenderWindow*>::type mCreatedWindows;
+		Vector<RenderWindow*>::type mCreatedWindows;
 
 		virtual RenderWindowPtr createImpl(RENDER_WINDOW_DESC& desc, RenderWindowPtr parentWindow) = 0;
 

CamelotCore/Include/CmRendererManager.h

@@ -23,7 +23,7 @@ namespace CamelotFramework
 
 		void registerFactory(RendererFactoryPtr factory);
 	private:
-		vector<RendererFactoryPtr>::type mAvailableFactories;
+		Vector<RendererFactoryPtr>::type mAvailableFactories;
 
 		RendererPtr mActiveRenderer;
 	};

CamelotCore/Include/CmResources.h

@@ -144,8 +144,8 @@ namespace CamelotFramework
 
 	private:
 		typedef std::shared_ptr<ResourceMetaData> ResourceMetaDataPtr;
-		map<String, ResourceMetaDataPtr>::type mResourceMetaData;
-		map<String, ResourceMetaDataPtr>::type mResourceMetaData_FilePath;
+		Map<String, ResourceMetaDataPtr>::type mResourceMetaData;
+		Map<String, ResourceMetaDataPtr>::type mResourceMetaData_FilePath;
 
 		CM_MUTEX(mInProgressResourcesMutex);
 		CM_MUTEX(mLoadedResourceMutex);
@@ -156,8 +156,8 @@ namespace CamelotFramework
 		WorkQueue* mWorkQueue;
 		UINT16 mWorkQueueChannel;
 
-		unordered_map<String, HResource>::type mLoadedResources; // TODO Low priority - I'm not sure how will UUID (a string) do as key do performance wise
-		unordered_map<String, ResourceAsyncOp>::type mInProgressResources; // Resources that are being asynchronously loaded
+		UnorderedMap<String, HResource>::type mLoadedResources; // TODO Low priority - I'm not sure how will UUID (a string) do as key do performance wise
+		UnorderedMap<String, ResourceAsyncOp>::type mInProgressResources; // Resources that are being asynchronously loaded
 
 		HResource loadInternal(const String& filePath, bool synchronous); 
 		ResourcePtr loadFromDiskAndDeserialize(const String& filePath);

CamelotCore/Include/CmSceneObject.h

@@ -188,7 +188,7 @@ namespace CamelotFramework
 
 	private:
 		HSceneObject mParent;
-		vector<HSceneObject>::type mChildren;
+		Vector<HSceneObject>::type mChildren;
 
 		/**
 		 * @brief	Adds a child to the child array. This method doesn't check for null or duplicate values.
@@ -286,10 +286,10 @@ namespace CamelotFramework
 		/**
 		 * @brief	Returns all components on this SceneObject.
 		 */
-		vector<HComponent>::type& getComponents() { return mComponents; }
+		Vector<HComponent>::type& getComponents() { return mComponents; }
 
 	private:
-		vector<HComponent>::type mComponents;
+		Vector<HComponent>::type mComponents;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/

CamelotCore/Include/CmShader.h

@@ -82,9 +82,9 @@ namespace CamelotFramework
 		bool hasDataParam(const String& name) const;
 		bool hasObjectParam(const String& name) const;
 
-		const map<String, SHADER_DATA_PARAM_DESC>::type& getDataParams() const { return mDataParams; }
-		const map<String, SHADER_OBJECT_PARAM_DESC>::type& getObjectParams() const { return mObjectParams; }
-		const map<String, SHADER_PARAM_BLOCK_DESC>::type& getParamBlocks() const { return mParamBlocks; }
+		const Map<String, SHADER_DATA_PARAM_DESC>::type& getDataParams() const { return mDataParams; }
+		const Map<String, SHADER_OBJECT_PARAM_DESC>::type& getObjectParams() const { return mObjectParams; }
+		const Map<String, SHADER_PARAM_BLOCK_DESC>::type& getParamBlocks() const { return mParamBlocks; }
 
 		static bool isSampler(GpuParamObjectType type);
 		static bool isTexture(GpuParamObjectType type);
@@ -93,11 +93,11 @@ namespace CamelotFramework
 		static ShaderPtr create(const String& name);
 	private:
 		String mName;
-		vector<TechniquePtr>::type mTechniques;
+		Vector<TechniquePtr>::type mTechniques;
 
-		map<String, SHADER_DATA_PARAM_DESC>::type mDataParams;
-		map<String, SHADER_OBJECT_PARAM_DESC>::type mObjectParams;
-		map<String, SHADER_PARAM_BLOCK_DESC>::type mParamBlocks;
+		Map<String, SHADER_DATA_PARAM_DESC>::type mDataParams;
+		Map<String, SHADER_OBJECT_PARAM_DESC>::type mObjectParams;
+		Map<String, SHADER_PARAM_BLOCK_DESC>::type mParamBlocks;
 
 		Shader(const String& name);
 

CamelotCore/Include/CmTechnique.h

@@ -22,7 +22,7 @@ namespace CamelotFramework
 		String mRenderSystem;
 		String mRenderer;
 
-		vector<PassPtr>::type mPasses;
+		Vector<PassPtr>::type mPasses;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/

CamelotCore/Include/CmTextUtility.h

@@ -23,10 +23,10 @@ namespace CamelotFramework
 			UINT32 getHeight() const { return mHeight; }
 			bool isSpacer() const { return mSpacer; }
 
-			const vector<CHAR_DESC>::type& getChars() const { return mChars; }
+			const Vector<CHAR_DESC>::type& getChars() const { return mChars; }
 
 		private:
-			vector<CHAR_DESC>::type mChars;
+			Vector<CHAR_DESC>::type mChars;
 			UINT32 mWidth;
 			UINT32 mHeight;
 			bool mSpacer;
@@ -57,7 +57,7 @@ namespace CamelotFramework
 			 * 			
 			 *			One character is represented with a single quad. Some pages might be empty.
 			 */
-			vector<UINT32>::type getNumQuadsPerPage() const;
+			Vector<UINT32>::type getNumQuadsPerPage() const;
 
 			/**
 			 * @brief	Fills the vertex/uv/index buffers for the specified page, with all the character data
@@ -83,7 +83,7 @@ namespace CamelotFramework
 			UINT32 mBaselineOffset;
 			UINT32 mLineHeight;
 			UINT32 mSpaceWidth;
-			vector<TextWord>::type mWords;
+			Vector<TextWord>::type mWords;
 			TextWord* mLastWord;
 
 			void add(const CHAR_DESC& charDesc);
@@ -100,18 +100,18 @@ namespace CamelotFramework
 		public:
 			~TextData();
 
-			const vector<TextLine>::type& getLines() const { return mLines; }
-			const vector<HTexture>::type& getTexturePages() const { return mTexturePages; }
-			const vector<UINT32>::type& getNumQuadsPerPage() const  { return mQuadsPerPage; }
+			const Vector<TextLine>::type& getLines() const { return mLines; }
+			const Vector<HTexture>::type& getTexturePages() const { return mTexturePages; }
+			const Vector<UINT32>::type& getNumQuadsPerPage() const  { return mQuadsPerPage; }
 			UINT32 getWidth() const;
 			UINT32 getHeight() const;
 
 		private:
 			friend class TextUtility;
 
-			vector<UINT32>::type mQuadsPerPage;
-			vector<TextLine>::type mLines;
-			vector<HTexture>::type mTexturePages;
+			Vector<UINT32>::type mQuadsPerPage;
+			Vector<TextLine>::type mLines;
+			Vector<HTexture>::type mTexturePages;
 		};
 
 		static std::shared_ptr<TextUtility::TextData> getTextData(const WString& text, const HFont& font, UINT32 fontSize, UINT32 width = 0, UINT32 height = 0, bool wordWrap = false);

CamelotCore/Include/CmTexture.h

@@ -208,7 +208,7 @@ namespace CamelotFramework {
 			UINT32 refCount;
 		};
 
-		unordered_map<TEXTURE_VIEW_DESC, TextureViewReference*, TextureView::HashFunction, TextureView::EqualFunction>::type mTextureViews;
+		UnorderedMap<TEXTURE_VIEW_DESC, TextureViewReference*, TextureView::HashFunction, TextureView::EqualFunction>::type mTextureViews;
 
     protected:
 		friend class TextureManager;

CamelotCore/Include/CmTextureRTTI.h

@@ -47,7 +47,7 @@ namespace CamelotFramework
 
 		void setPixelData(Texture* obj, UINT32 idx, PixelDataPtr data)
 		{
-			vector<PixelDataPtr>::type* pixelData = boost::any_cast<vector<PixelDataPtr>::type*>(obj->mRTTIData);
+			Vector<PixelDataPtr>::type* pixelData = boost::any_cast<Vector<PixelDataPtr>::type*>(obj->mRTTIData);
 
 			(*pixelData)[idx] = data;
 		}
@@ -59,7 +59,7 @@ namespace CamelotFramework
 
 		void setPixelDataArraySize(Texture* obj, UINT32 size)
 		{
-			vector<PixelDataPtr>::type* pixelData = boost::any_cast<vector<PixelDataPtr>::type*>(obj->mRTTIData);
+			Vector<PixelDataPtr>::type* pixelData = boost::any_cast<Vector<PixelDataPtr>::type*>(obj->mRTTIData);
 
 			pixelData->resize(size);
 		}
@@ -88,7 +88,7 @@ namespace CamelotFramework
 		{
 			Texture* texture = static_cast<Texture*>(obj);
 
-			texture->mRTTIData = cm_new<vector<PixelDataPtr>::type, PoolAlloc>();
+			texture->mRTTIData = cm_new<Vector<PixelDataPtr>::type, PoolAlloc>();
 		}
 
 		virtual void onDeserializationEnded(IReflectable* obj)
@@ -104,7 +104,7 @@ namespace CamelotFramework
 				texture->getNumMipmaps(), texture->getFormat(), texture->getUsage(), texture->isHardwareGammaEnabled(), 
 				texture->getFSAA(), texture->getFSAAHint());
 
-			vector<PixelDataPtr>::type* pixelData = boost::any_cast<vector<PixelDataPtr>::type*>(texture->mRTTIData);
+			Vector<PixelDataPtr>::type* pixelData = boost::any_cast<Vector<PixelDataPtr>::type*>(texture->mRTTIData);
 			for(size_t i = 0; i < pixelData->size(); i++)
 			{
 				UINT32 face = (size_t)Math::Floor(i / (float)(texture->getNumMipmaps() + 1));

CamelotCore/Include/CmVertexData.h

@@ -70,7 +70,7 @@ namespace CamelotFramework {
 		void setBuffer(UINT32 index, VertexBufferPtr buffer);
 		/// Gets the buffer bound to the given source index
 		VertexBufferPtr getBuffer(UINT32 index) const;
-		const unordered_map<UINT32, VertexBufferPtr>::type& getBuffers() const { return mVertexBuffers; }
+		const UnorderedMap<UINT32, VertexBufferPtr>::type& getBuffers() const { return mVertexBuffers; }
 		/// Gets whether a buffer is bound to the given source index
 		bool isBufferBound(UINT32 index) const;
 
@@ -98,7 +98,7 @@ namespace CamelotFramework {
 		/** The vertex buffer bindings to be used. 
 		@remarks Note that this is created for you on construction.
 		*/
-		unordered_map<UINT32, VertexBufferPtr>::type mVertexBuffers;
+		UnorderedMap<UINT32, VertexBufferPtr>::type mVertexBuffers;
 	};
 
 	/** Vertex cache profiler.

CamelotCore/Include/CmVertexDeclaration.h

@@ -249,7 +249,7 @@ namespace CamelotFramework
     {
     public:
 		/// Defines the list of vertex elements that makes up this declaration
-        typedef list<VertexElement>::type VertexElementList;
+        typedef List<VertexElement>::type VertexElementList;
         /// Sort routine for vertex elements
         static bool vertexElementLess(const VertexElement& e1, const VertexElement& e2);
 

CamelotCore/Include/CmWindowEventUtilities.h

@@ -174,10 +174,10 @@ namespace CamelotFramework
 #endif
 
 		//These are public only so GLXProc can access them without adding Xlib headers header
-		typedef multimap<RenderWindow*, WindowEventListener*>::type WindowEventListeners;
+		typedef Multimap<RenderWindow*, WindowEventListener*>::type WindowEventListeners;
 		static WindowEventListeners _msListeners;
 
-		typedef vector<RenderWindow*>::type Windows;
+		typedef Vector<RenderWindow*>::type Windows;
 		static Windows _msWindows;
 	};
 	/** @} */

CamelotCore/Source/CmCgProgram.cpp

@@ -139,7 +139,7 @@ namespace CamelotFramework {
 	}
 
 	CgProgram::CgProgram(CGcontext context, const String& source, const String& entryPoint, const String& language, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired)
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired)
         : HighLevelGpuProgram(source, entryPoint, language, gptype, profile, includes, isAdjacencyInfoRequired), 
         mCgContext(context), mCgProgram(0), 
         mSelectedCgProfile(CG_PROFILE_UNKNOWN)

CamelotCore/Source/CmCgProgramFactory.cpp

@@ -55,7 +55,7 @@ namespace CamelotFramework {
     }
     //-----------------------------------------------------------------------
     HighLevelGpuProgramPtr CgProgramFactory::create(const String& source, const String& entryPoint, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes)
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes)
     {
 		CgProgram* prog = new (cm_alloc<CgProgram, PoolAlloc>()) CgProgram(mCgContext, source, entryPoint, sLanguageName, gptype, profile, includes);
 

CamelotCore/Source/CmCommandQueue.cpp

@@ -10,7 +10,7 @@ namespace CamelotFramework
 	CommandQueueBase::CommandQueueBase(CM_THREAD_ID_TYPE threadId, bool allowAllThreads)
 		:mMyThreadId(threadId), mAllowAllThreads(allowAllThreads), mMaxDebugIdx(0)
 	{
-		mCommands = cm_new<CamelotFramework::queue<QueuedCommand>::type, PoolAlloc>();
+		mCommands = cm_new<CamelotFramework::Queue<QueuedCommand>::type, PoolAlloc>();
 
 		{
 			CM_LOCK_MUTEX(CommandQueueBreakpointMutex);
@@ -22,7 +22,7 @@ namespace CamelotFramework
 	CommandQueueBase::CommandQueueBase(CM_THREAD_ID_TYPE threadId, bool allowAllThreads)
 		:mMyThreadId(threadId), mAllowAllThreads(allowAllThreads)
 	{
-		mCommands = cm_new<CamelotFramework::queue<QueuedCommand>::type, PoolAlloc>();
+		mCommands = cm_new<CamelotFramework::Queue<QueuedCommand>::type, PoolAlloc>();
 	}
 #endif
 
@@ -70,15 +70,15 @@ namespace CamelotFramework
 #endif
 	}
 
-	CamelotFramework::queue<QueuedCommand>::type* CommandQueueBase::flush()
+	CamelotFramework::Queue<QueuedCommand>::type* CommandQueueBase::flush()
 	{
-		CamelotFramework::queue<QueuedCommand>::type* oldCommands = mCommands;
-		mCommands = cm_new<CamelotFramework::queue<QueuedCommand>::type, PoolAlloc>();
+		CamelotFramework::Queue<QueuedCommand>::type* oldCommands = mCommands;
+		mCommands = cm_new<CamelotFramework::Queue<QueuedCommand>::type, PoolAlloc>();
 
 		return oldCommands;
 	}
 
-	void CommandQueueBase::playback(CamelotFramework::queue<QueuedCommand>::type* commands, boost::function<void(UINT32)> notifyCallback)
+	void CommandQueueBase::playback(CamelotFramework::Queue<QueuedCommand>::type* commands, boost::function<void(UINT32)> notifyCallback)
 	{
 #if CM_DEBUG_MODE
 		RenderSystem* rs = RenderSystem::instancePtr();
@@ -121,14 +121,14 @@ namespace CamelotFramework
 		cm_delete<PoolAlloc>(commands);
 	}
 
-	void CommandQueueBase::playback(CamelotFramework::queue<QueuedCommand>::type* commands)
+	void CommandQueueBase::playback(CamelotFramework::Queue<QueuedCommand>::type* commands)
 	{
 		playback(commands, boost::function<void(UINT32)>());
 	}
 
 	void CommandQueueBase::cancelAll()
 	{
-		CamelotFramework::queue<QueuedCommand>::type* commands = flush();
+		CamelotFramework::Queue<QueuedCommand>::type* commands = flush();
 		cm_delete<PoolAlloc>(commands);
 	}
 
@@ -150,7 +150,7 @@ namespace CamelotFramework
 
 	UINT32 CommandQueueBase::MaxCommandQueueIdx = 0;
 
-	unordered_set<CommandQueueBase::QueueBreakpoint, CommandQueueBase::QueueBreakpoint::HashFunction, 
+	UnorderedSet<CommandQueueBase::QueueBreakpoint, CommandQueueBase::QueueBreakpoint::HashFunction, 
 		CommandQueueBase::QueueBreakpoint::EqualFunction>::type CommandQueueBase::SetBreakpoints;
 
 	inline size_t CommandQueueBase::QueueBreakpoint::HashFunction::operator()(const QueueBreakpoint& v) const

CamelotCore/Source/CmFont.cpp

@@ -32,7 +32,7 @@ namespace CamelotFramework
 	Font::~Font()
 	{ }
 
-	void Font::initialize(vector<FontData>::type& fontData)
+	void Font::initialize(Vector<FontData>::type& fontData)
 	{
 		for(auto iter = fontData.begin(); iter != fontData.end(); ++iter)
 			mFontDataPerSize[iter->size] = *iter;
@@ -82,7 +82,7 @@ namespace CamelotFramework
 		return bestSize;
 	}
 
-	HFont Font::create(vector<FontData>::type& fontData)
+	HFont Font::create(Vector<FontData>::type& fontData)
 	{
 		FontPtr newFont = FontManager::instance().create(fontData);
 

CamelotCore/Source/CmFontManager.cpp

@@ -3,7 +3,7 @@
 
 namespace CamelotFramework
 {
-	FontPtr FontManager::create(vector<FontData>::type& fontData) const
+	FontPtr FontManager::create(Vector<FontData>::type& fontData) const
 	{
 		FontPtr newFont = cm_core_ptr<Font, PoolAlloc>(new (cm_alloc<Font, PoolAlloc>()) Font());
 		newFont->setThisPtr(newFont);

CamelotCore/Source/CmGpuParams.cpp

@@ -53,7 +53,7 @@ namespace CamelotFramework
 		if(slot < 0 || slot >= (UINT32)mParamBlocks.size())
 		{
 			CM_EXCEPT(InvalidParametersException, "Index out of range: Valid range: 0 .. " + 
-				toString(mParamBlocks.size() - 1) + ". Requested: " + toString(slot));
+				toString((int)mParamBlocks.size() - 1) + ". Requested: " + toString(slot));
 		}
 
 		return mParamBlockBuffers[slot];
@@ -77,7 +77,7 @@ namespace CamelotFramework
 		if(slot < 0 || slot >= (UINT32)mParamBlocks.size())
 		{
 			CM_EXCEPT(InvalidParametersException, "Index out of range: Valid range: 0 .. " + 
-				toString(mParamBlocks.size() - 1) + ". Requested: " + toString(slot));
+				toString((int)mParamBlocks.size() - 1) + ". Requested: " + toString(slot));
 		}
 
 		if(mParamBlocks[slot] != nullptr)
@@ -264,7 +264,7 @@ namespace CamelotFramework
 		if(slot < 0 || slot >= (UINT32)mTextures.size())
 		{
 			CM_EXCEPT(InvalidParametersException, "Index out of range: Valid range: 0 .. " + 
-				toString(mTextures.size() - 1) + ". Requested: " + toString(slot));
+				toString((int)mTextures.size() - 1) + ". Requested: " + toString(slot));
 		}
 
 		return mTextures[slot];
@@ -287,7 +287,7 @@ namespace CamelotFramework
 		if(slot < 0 || slot >= (UINT32)mSamplerStates.size())
 		{
 			CM_EXCEPT(InvalidParametersException, "Index out of range: Valid range: 0 .. " + 
-				toString(mSamplerStates.size() - 1) + ". Requested: " + toString(slot));
+				toString((int)mSamplerStates.size() - 1) + ". Requested: " + toString(slot));
 		}
 
 		return mSamplerStates[slot];

CamelotCore/Source/CmGpuProgram.cpp

@@ -47,7 +47,7 @@ namespace CamelotFramework
 {
     //-----------------------------------------------------------------------------
     GpuProgram::GpuProgram(const String& source, const String& entryPoint, const String& language, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired) 
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired) 
         :mEntryPoint(entryPoint), mSyntaxCode(language), mType(gptype),
 		mProfile(profile), mNeedsAdjacencyInfo(isAdjacencyInfoRequired)
     {

CamelotCore/Source/CmGpuProgramImporter.cpp

@@ -35,7 +35,7 @@ namespace CamelotFramework
 		GpuProgramProfile profile = gpuProgImportOptions->getProfile();
 		String language = gpuProgImportOptions->getLanguage();
 		GpuProgramType gptype = gpuProgImportOptions->getType();
-		vector<HGpuProgInclude>::type includes = gpuProgImportOptions->getIncludes();
+		Vector<HGpuProgInclude>::type includes = gpuProgImportOptions->getIncludes();
 
 		HHighLevelGpuProgram gpuProgram = HighLevelGpuProgram::create(shaderSource, entryPoint, language, gptype, profile, &includes);
 		gpuProgram.waitUntilLoaded();

CamelotCore/Source/CmHighLevelGpuProgram.cpp

@@ -42,7 +42,7 @@ namespace CamelotFramework
 {
     //---------------------------------------------------------------------------
 	HighLevelGpuProgram::HighLevelGpuProgram(const String& source, const String& entryPoint, const String& language, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired)
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired)
         : GpuProgram(source, entryPoint, language, gptype, profile, includes, isAdjacencyInfoRequired), 
         mAssemblerProgram(nullptr)
     {
@@ -75,7 +75,7 @@ namespace CamelotFramework
     }
 	//---------------------------------------------------------------------
 	HHighLevelGpuProgram HighLevelGpuProgram::create(const String& source, const String& entryPoint, 
-		const String& language, GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes)
+		const String& language, GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes)
 	{
 		HighLevelGpuProgramPtr programPtr = HighLevelGpuProgramManager::instance().create(source, entryPoint, language, gptype, profile, includes);
 

CamelotCore/Source/CmHighLevelGpuProgramManager.cpp

@@ -78,7 +78,7 @@ namespace CamelotFramework {
 			return sNullLang;
 		}
 		HighLevelGpuProgramPtr create(const String& source, const String& entryPoint, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes)
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes)
 		{
 			return cm_core_ptr<NullProgram, PoolAlloc>();
 		}
@@ -137,7 +137,7 @@ namespace CamelotFramework {
 	}
     //---------------------------------------------------------------------------
     HighLevelGpuProgramPtr HighLevelGpuProgramManager::create(const String& source, const String& entryPoint, const String& language, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes)
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes)
     {
 		HighLevelGpuProgramFactory* factory = getFactory(language);
         HighLevelGpuProgramPtr ret = factory->create(source, entryPoint, gptype, profile, includes);

CamelotCore/Source/CmMaterial.cpp

@@ -58,7 +58,7 @@ namespace CamelotFramework
 			mValidShareableParamBlocks.clear();
 			mValidParams.clear();
 
-			vector<const GpuParamDesc*>::type allParamDescs;
+			Vector<const GpuParamDesc*>::type allParamDescs;
 
 			// Make sure all gpu programs are fully loaded
 			for(UINT32 i = 0; i < mBestTechnique->getNumPasses(); i++)
@@ -109,15 +109,15 @@ namespace CamelotFramework
 			}
 
 			// Fill out various helper structures
-			map<String, const GpuParamDataDesc*>::type validDataParameters = determineValidDataParameters(allParamDescs);
-			set<String>::type validObjectParameters = determineValidObjectParameters(allParamDescs);
+			Map<String, const GpuParamDataDesc*>::type validDataParameters = determineValidDataParameters(allParamDescs);
+			Set<String>::type validObjectParameters = determineValidObjectParameters(allParamDescs);
 
-			set<String>::type validShareableParamBlocks = determineValidShareableParamBlocks(allParamDescs);
-			map<String, String>::type paramToParamBlockMap = determineParameterToBlockMapping(allParamDescs);
-			map<String, GpuParamBlockBufferPtr>::type paramBlockBuffers;
+			Set<String>::type validShareableParamBlocks = determineValidShareableParamBlocks(allParamDescs);
+			Map<String, String>::type paramToParamBlockMap = determineParameterToBlockMapping(allParamDescs);
+			Map<String, GpuParamBlockBufferPtr>::type paramBlockBuffers;
 
 			// Create param blocks
-			const map<String, SHADER_PARAM_BLOCK_DESC>::type& shaderDesc = mShader->getParamBlocks();
+			const Map<String, SHADER_PARAM_BLOCK_DESC>::type& shaderDesc = mShader->getParamBlocks();
 			for(auto iter = validShareableParamBlocks.begin(); iter != validShareableParamBlocks.end(); ++iter)
 			{
 				bool isShared = false;
@@ -154,7 +154,7 @@ namespace CamelotFramework
 			}
 
 			// Create data param mappings
-			const map<String, SHADER_DATA_PARAM_DESC>::type& dataParamDesc = mShader->getDataParams();
+			const Map<String, SHADER_DATA_PARAM_DESC>::type& dataParamDesc = mShader->getDataParams();
 			for(auto iter = dataParamDesc.begin(); iter != dataParamDesc.end(); ++iter)
 			{
 				auto findIter = validDataParameters.find(iter->second.gpuVariableName);
@@ -214,7 +214,7 @@ namespace CamelotFramework
 			}
 
 			// Create object param mappings
-			const map<String, SHADER_OBJECT_PARAM_DESC>::type& objectParamDesc = mShader->getObjectParams();
+			const Map<String, SHADER_OBJECT_PARAM_DESC>::type& objectParamDesc = mShader->getObjectParams();
 			for(auto iter = objectParamDesc.begin(); iter != objectParamDesc.end(); ++iter)
 			{
 				auto findIter = validObjectParameters.find(iter->second.gpuVariableName);
@@ -315,10 +315,10 @@ namespace CamelotFramework
 		}
 	}
 
-	map<String, const GpuParamDataDesc*>::type Material::determineValidDataParameters(const vector<const GpuParamDesc*>::type& paramDescs) const
+	Map<String, const GpuParamDataDesc*>::type Material::determineValidDataParameters(const Vector<const GpuParamDesc*>::type& paramDescs) const
 	{
-		map<String, const GpuParamDataDesc*>::type foundDataParams;
-		map<String, bool>::type validParams;
+		Map<String, const GpuParamDataDesc*>::type foundDataParams;
+		Map<String, bool>::type validParams;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
 		{
@@ -357,9 +357,9 @@ namespace CamelotFramework
 	}
 
 	
-	set<String>::type Material::determineValidObjectParameters(const vector<const GpuParamDesc*>::type& paramDescs) const
+	Set<String>::type Material::determineValidObjectParameters(const Vector<const GpuParamDesc*>::type& paramDescs) const
 	{
-		set<String>::type validParams;
+		Set<String>::type validParams;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
 		{
@@ -390,11 +390,11 @@ namespace CamelotFramework
 		return validParams;
 	}
 
-	set<String>::type Material::determineValidShareableParamBlocks(const vector<const GpuParamDesc*>::type& paramDescs) const
+	Set<String>::type Material::determineValidShareableParamBlocks(const Vector<const GpuParamDesc*>::type& paramDescs) const
 	{
 		// Make sure param blocks with the same name actually are the same
-		map<String, std::pair<String, const GpuParamDesc*>>::type uniqueParamBlocks;
-		map<String, bool>::type validParamBlocks;
+		Map<String, std::pair<String, const GpuParamDesc*>>::type uniqueParamBlocks;
+		Map<String, bool>::type validParamBlocks;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
 		{
@@ -454,7 +454,7 @@ namespace CamelotFramework
 			}
 		}
 
-		set<String>::type validParamBlocksReturn;
+		Set<String>::type validParamBlocksReturn;
 		for(auto iter = validParamBlocks.begin(); iter != validParamBlocks.end(); ++iter)
 		{
 			if(iter->second)
@@ -464,9 +464,9 @@ namespace CamelotFramework
 		return validParamBlocksReturn;
 	}
 
-	map<String, String>::type Material::determineParameterToBlockMapping(const vector<const GpuParamDesc*>::type& paramDescs)
+	Map<String, String>::type Material::determineParameterToBlockMapping(const Vector<const GpuParamDesc*>::type& paramDescs)
 	{
-		map<String, String>::type paramToParamBlock;
+		Map<String, String>::type paramToParamBlock;
 
 		for(auto iter = paramDescs.begin(); iter != paramDescs.end(); ++iter)
 		{

CamelotCore/Source/CmMaterialRTTI.cpp

@@ -42,7 +42,7 @@ namespace CamelotFramework
 		ShaderPtr shader = material->getShader();
 		if(shader != nullptr)
 		{
-			const map<String, String>::type& validParamNames = material->getValidParamNames();
+			const Map<String, String>::type& validParamNames = material->getValidParamNames();
 
 			for(auto iter = validParamNames.begin(); iter != validParamNames.end(); ++iter)
 			{

CamelotCore/Source/CmMesh.cpp

@@ -210,7 +210,7 @@ namespace CamelotFramework
 		if(subMeshIdx < 0 || subMeshIdx >= mSubMeshes.size())
 		{
 			CM_EXCEPT(InvalidParametersException, "Invalid sub-mesh index (" 
-				+ toString(subMeshIdx) + "). Number of sub-meshes available: " + toString(mSubMeshes.size()));
+				+ toString(subMeshIdx) + "). Number of sub-meshes available: " + toString((int)mSubMeshes.size()));
 		}
 
 		// TODO - BIG TODO - Completely ignores subMeshIdx and always renders the entire thing

CamelotCore/Source/CmMeshData.cpp

@@ -175,7 +175,7 @@ namespace CamelotFramework
 
 	// TODO - This doesn't handle the case where multiple elements in same slot have different data types
 	//  - actually it will likely corrupt memory in that case
-	MeshDataPtr MeshData::combine(const vector<MeshDataPtr>::type& meshes)
+	MeshDataPtr MeshData::combine(const Vector<MeshDataPtr>::type& meshes)
 	{
 		UINT32 totalVertexCount = 0;
 		for(auto& meshData : meshes)
@@ -200,7 +200,7 @@ namespace CamelotFramework
 			}
 		}
 
-		vector<VertexElement>::type combinedVertexElements;
+		Vector<VertexElement>::type combinedVertexElements;
 		for(auto& meshData : meshes)
 		{
 			for(auto& newElement : meshData->mVertexElements)

CamelotCore/Source/CmMultiRenderTexture.cpp

@@ -24,7 +24,7 @@ namespace CamelotFramework
 			{
 				if(i >= CM_MAX_MULTIPLE_RENDER_TARGETS)
 				{
-					LOGWRN("Render texture index is larger than the maximum number of supported render targets. Index: " + toString(i) + 
+					LOGWRN("Render texture index is larger than the maximum number of supported render targets. Index: " + toString((int)i) + 
 						". Max. number of render targets: " + toString(CM_MAX_MULTIPLE_RENDER_TARGETS));
 
 					continue;

CamelotCore/Source/CmPixelUtil.cpp

@@ -990,7 +990,7 @@ namespace CamelotFramework {
     {
         // Collect format names sorted by length, it's required by BNF compiler
         // that similar tokens need longer ones comes first.
-        typedef multimap<String::size_type, String>::type FormatNameMap;
+        typedef Multimap<String::size_type, String>::type FormatNameMap;
         FormatNameMap formatNames;
         for (size_t i = 0; i < PF_COUNT; ++i)
         {

CamelotCore/Source/CmRenderSystem.cpp

@@ -334,7 +334,7 @@ namespace CamelotFramework {
 		while(true)
 		{
 			// Wait until we get some ready commands
-			queue<QueuedCommand>::type* commands = nullptr;
+			Queue<QueuedCommand>::type* commands = nullptr;
 			{
 				CM_LOCK_MUTEX_NAMED(mCommandQueueMutex, lock)
 

CamelotCore/Source/CmRenderSystemCapabilities.cpp

@@ -73,7 +73,7 @@ namespace CamelotFramework {
 	{
 	}
 	//---------------------------------------------------------------------
-	vector<CamelotFramework::String>::type RenderSystemCapabilities::msGPUVendorStrings;
+	Vector<CamelotFramework::String>::type RenderSystemCapabilities::msGPUVendorStrings;
 	//---------------------------------------------------------------------
 	GPUVendor RenderSystemCapabilities::vendorFromString(const String& vendorString)
 	{

CamelotCore/Source/CmRenderWindowManager.cpp

@@ -31,7 +31,7 @@ namespace CamelotFramework
 		}
 	}
 
-	vector<RenderWindow*>::type RenderWindowManager::getRenderWindows() const
+	Vector<RenderWindow*>::type RenderWindowManager::getRenderWindows() const
 	{
 		CM_LOCK_MUTEX(mWindowMutex);
 

CamelotCore/Source/CmResources.cpp

@@ -252,7 +252,7 @@ namespace CamelotFramework
 
 	void Resources::unloadAllUnused()
 	{
-		vector<HResource>::type resourcesToUnload;
+		Vector<HResource>::type resourcesToUnload;
 
 		{
 			CM_LOCK_MUTEX(mLoadedResourceMutex);
@@ -321,7 +321,7 @@ namespace CamelotFramework
 
 	void Resources::loadMetaData()
 	{
-		vector<String>::type allFiles = FileSystem::getFiles(mMetaDataFolderPath);
+		Vector<String>::type allFiles = FileSystem::getFiles(mMetaDataFolderPath);
 
 		for(auto iter = allFiles.begin(); iter != allFiles.end(); ++iter)
 		{

CamelotCore/Source/CmSceneManager.cpp

@@ -17,7 +17,7 @@ namespace CamelotFramework
 
 	void SceneManager::update()
 	{
-		stack<HSceneObject>::type todo;
+		Stack<HSceneObject>::type todo;
 		todo.push(mRootNode);
 
 		while(!todo.empty())
@@ -25,7 +25,7 @@ namespace CamelotFramework
 			HSceneObject currentGO = todo.top();
 			todo.pop();
 			                  
-			vector<HComponent>::type components = currentGO->getComponents();
+			Vector<HComponent>::type components = currentGO->getComponents();
 
 			for(auto iter = components.begin(); iter != components.end(); ++iter)
 			{

CamelotCore/Source/CmTextUtility.cpp

@@ -151,14 +151,14 @@ namespace CamelotFramework
 		return word;
 	}
 
-	vector<UINT32>::type TextUtility::TextLine::getNumQuadsPerPage() const
+	Vector<UINT32>::type TextUtility::TextLine::getNumQuadsPerPage() const
 	{
-		vector<UINT32>::type quadsPerPage;
+		Vector<UINT32>::type quadsPerPage;
 		for(auto wordIter = mWords.begin(); wordIter != mWords.end(); ++wordIter)
 		{
 			if(!wordIter->isSpacer())
 			{
-				const vector<CHAR_DESC>::type& chars = wordIter->getChars();
+				const Vector<CHAR_DESC>::type& chars = wordIter->getChars();
 				UINT32 kerning = 0;
 				for(auto charIter = chars.begin(); charIter != chars.end(); ++charIter)
 				{
@@ -186,7 +186,7 @@ namespace CamelotFramework
 			}
 			else
 			{
-				const vector<CHAR_DESC>::type& chars = wordIter->getChars();
+				const Vector<CHAR_DESC>::type& chars = wordIter->getChars();
 				UINT32 kerning = 0;
 				for(auto charIter = chars.begin(); charIter != chars.end(); ++charIter)
 				{

CamelotD3D11RenderSystem/Include/CmD3D11DriverList.h

@@ -16,7 +16,7 @@ namespace CamelotFramework
 		D3D11Driver* item(const String &name) const;
 
 	private:
-		vector<D3D11Driver*>::type mDriverList;
+		Vector<D3D11Driver*>::type mDriverList;
 
 		void enumerate(IDXGIFactory* dxgiFactory);
 	};

CamelotD3D11RenderSystem/Include/CmD3D11HLSLProgram.h

@@ -35,7 +35,7 @@ namespace CamelotFramework
 		friend class D3D11HLSLProgramFactory;
 
 		D3D11HLSLProgram(const String& source, const String& entryPoint, const String& language, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, 
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, 
 			bool isAdjacencyInfoRequired = false);
 
         /**

CamelotD3D11RenderSystem/Include/CmD3D11HLSLProgramFactory.h

@@ -15,7 +15,7 @@ namespace CamelotFramework
 
 		const String& getLanguage(void) const;
 		HighLevelGpuProgramPtr create(const String& source, const String& entryPoint, GpuProgramType gptype, 
-			GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes);
+			GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes);
 		HighLevelGpuProgramPtr create();
 	};
 }

CamelotD3D11RenderSystem/Include/CmD3D11InputLayoutManager.h

@@ -13,7 +13,7 @@ namespace CamelotFramework
 			size_t bufferDeclHash;
 			UINT32 vertexProgramId;
 
-			list<VertexElement>::type* bufferDeclElements;
+			List<VertexElement>::type* bufferDeclElements;
 		};
 
 		class HashFunc 
@@ -55,7 +55,7 @@ namespace CamelotFramework
 		static const int DECLARATION_BUFFER_SIZE = 1024;
 		static const int NUM_ELEMENTS_TO_PRUNE = 64;
 
-		unordered_map<VertexDeclarationKey, InputLayoutEntry*, HashFunc, EqualFunc>::type mInputLayoutMap;
+		UnorderedMap<VertexDeclarationKey, InputLayoutEntry*, HashFunc, EqualFunc>::type mInputLayoutMap;
 
 		bool mWarningShown;
 		UINT32 mLastUsedCounter;

CamelotD3D11RenderSystem/Include/CmD3D11Prerequisites.h

@@ -58,7 +58,7 @@ namespace CamelotFramework
 		TID_D3D11_HLSLProgram = 12000
 	};
 
-	typedef vector<char*>::type HLSLMicroCode;
+	typedef Vector<char*>::type HLSLMicroCode;
 
 	typedef std::shared_ptr<D3D11GpuVertexProgram> D3D11GpuVertexProgramPtr;
 	typedef std::shared_ptr<D3D11GpuFragmentProgram> D3D11GpuFragmentProgramPtr;

CamelotD3D11RenderSystem/Include/CmD3D11VideoModeList.h

@@ -18,7 +18,7 @@ namespace CamelotFramework
 
 	private:
 		D3D11Driver* mDriver;
-		vector<D3D11VideoMode>::type mModeList;
+		Vector<D3D11VideoMode>::type mModeList;
 
 		void enumerate(UINT32 adapterOutput);
 	};

CamelotD3D11RenderSystem/Source/CmD3D11Device.cpp

@@ -124,7 +124,7 @@ namespace CamelotFramework
 
 		D3D11_INFO_QUEUE_FILTER filter;
 		ZeroMemory(&filter, sizeof(D3D11_INFO_QUEUE_FILTER));
-		vector<D3D11_MESSAGE_SEVERITY>::type severityList;
+		Vector<D3D11_MESSAGE_SEVERITY>::type severityList;
 
 		switch(exceptionsErrorLevel)
 		{

CamelotD3D11RenderSystem/Source/CmD3D11HLSLProgram.cpp

@@ -16,7 +16,7 @@ namespace CamelotFramework
 	UINT32 D3D11HLSLProgram::globalProgramId = 0;
 
 	D3D11HLSLProgram::D3D11HLSLProgram(const String& source, const String& entryPoint, const String& language, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired)
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, bool isAdjacencyInfoRequired)
 		: HighLevelGpuProgram(source, entryPoint, language, gptype, profile, includes, isAdjacencyInfoRequired),
 		mColumnMajorMatrices(true), mEnableBackwardsCompatibility(false), mProgramId(0)
 	{

CamelotD3D11RenderSystem/Source/CmD3D11HLSLProgramFactory.cpp

@@ -19,7 +19,7 @@ namespace CamelotFramework
     }
 
 	HighLevelGpuProgramPtr D3D11HLSLProgramFactory::create(const String& source, const String& entryPoint, 
-		GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes)
+		GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes)
     {
 		D3D11HLSLProgram* prog = new (cm_alloc<D3D11HLSLProgram, PoolAlloc>()) D3D11HLSLProgram(source, entryPoint, sLanguageName, gptype, profile, includes);
 

CamelotD3D11RenderSystem/Source/CmD3D11InputLayoutManager.cpp

@@ -67,7 +67,7 @@ namespace CamelotFramework
 	{
 		VertexDeclarationKey pair;
 		pair.bufferDeclHash = vertexBufferDecl->getHash();
-		pair.bufferDeclElements = const_cast<list<VertexElement>::type*>(&vertexBufferDecl->getElements());
+		pair.bufferDeclElements = const_cast<List<VertexElement>::type*>(&vertexBufferDecl->getElements());
 		pair.vertexProgramId = vertexProgram.getProgramId();
 
 		auto iterFind = mInputLayoutMap.find(pair);
@@ -135,7 +135,7 @@ namespace CamelotFramework
 		VertexDeclarationKey pair;
 		pair.bufferDeclHash = vertexBufferDecl->getHash();
 
-		list<VertexElement>::type* bufferDeclElements = cm_new<list<VertexElement>::type, PoolAlloc>(); 
+		List<VertexElement>::type* bufferDeclElements = cm_new<List<VertexElement>::type, PoolAlloc>(); 
 		pair.bufferDeclElements = bufferDeclElements;
 		pair.vertexProgramId = vertexProgram.getProgramId();
 
@@ -155,7 +155,7 @@ namespace CamelotFramework
 			mWarningShown = true;
 		}
 
-		map<UINT32, VertexDeclarationKey>::type leastFrequentlyUsedMap;
+		Map<UINT32, VertexDeclarationKey>::type leastFrequentlyUsedMap;
 
 		for(auto iter = mInputLayoutMap.begin(); iter != mInputLayoutMap.end(); ++iter)
 			leastFrequentlyUsedMap[iter->second->lastUsedIdx] = iter->first;

CamelotD3D9Renderer/Include/CmD3D9Device.h

@@ -114,7 +114,7 @@ namespace CamelotFramework {
 			D3DPRESENT_PARAMETERS	presentParameters;				// Present parameters of the render window.
 			bool					acquired;						// True if resources acquired.			
 		};		
-		typedef map<const D3D9RenderWindow*, RenderWindowResources*>::type RenderWindowToResorucesMap;
+		typedef Map<const D3D9RenderWindow*, RenderWindowResources*>::type RenderWindowToResorucesMap;
 		typedef RenderWindowToResorucesMap::iterator				 RenderWindowToResorucesIterator;
 
 		RenderWindowToResorucesMap mMapRenderWindowToResoruces;		// Map between render window to resources.

CamelotD3D9Renderer/Include/CmD3D9DeviceManager.h

@@ -58,10 +58,10 @@ namespace CamelotFramework {
 		~D3D9DeviceManager	();
 
 	protected:		
-		typedef vector<D3D9Device*>::type		 DeviceList;
+		typedef Vector<D3D9Device*>::type		 DeviceList;
 		typedef DeviceList::iterator			 DeviceIterator;
 		typedef DeviceList::const_iterator		 ConstDeviceIterator;
-		typedef vector<D3D9RenderWindow*>::type  D3D9RenderWindowList;
+		typedef Vector<D3D9RenderWindow*>::type  D3D9RenderWindowList;
 
 	protected:
 		D3D9Device*			selectDevice		(D3D9RenderWindow* renderWindow, D3D9RenderWindowList& renderWindowsGroup);

CamelotD3D9Renderer/Include/CmD3D9DriverList.h

@@ -36,7 +36,7 @@ namespace CamelotFramework
 	class CM_D3D9_EXPORT D3D9DriverList
 	{
 	private:
-		vector<D3D9Driver>::type mDriverList;
+		Vector<D3D9Driver>::type mDriverList;
 		
 	public:
 		D3D9DriverList();

CamelotD3D9Renderer/Include/CmD3D9GpuProgram.h

@@ -119,7 +119,7 @@ namespace CamelotFramework {
         void loadFromMicrocode(IDirect3DDevice9* d3d9Device, ID3DXBuffer* microcode);
 
 	protected:
-		typedef map<IDirect3DDevice9*, IDirect3DVertexShader9*>::type   DeviceToVertexShaderMap;
+		typedef Map<IDirect3DDevice9*, IDirect3DVertexShader9*>::type   DeviceToVertexShaderMap;
 		typedef DeviceToVertexShaderMap::iterator						DeviceToVertexShaderIterator;
 	
 		DeviceToVertexShaderMap		mMapDeviceToVertexShader;	
@@ -153,7 +153,7 @@ namespace CamelotFramework {
         void loadFromMicrocode(IDirect3DDevice9* d3d9Device, ID3DXBuffer* microcode);
 
 	protected:
-		typedef map<IDirect3DDevice9*, IDirect3DPixelShader9*>::type	DeviceToPixelShaderMap;
+		typedef Map<IDirect3DDevice9*, IDirect3DPixelShader9*>::type	DeviceToPixelShaderMap;
 		typedef DeviceToPixelShaderMap::iterator						DeviceToPixelShaderIterator;
 
 		DeviceToPixelShaderMap		mMapDeviceToPixelShader;			

CamelotD3D9Renderer/Include/CmD3D9HLSLProgram.h

@@ -89,7 +89,7 @@ namespace CamelotFramework {
 		friend class D3D9HLSLProgramFactory;
 
 		D3D9HLSLProgram(const String& source, const String& entryPoint, const String& language, 
-			GpuProgramType gptype, GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes, 
+			GpuProgramType gptype, GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes, 
 			bool isAdjacencyInfoRequired = false);
  
 		/**

CamelotD3D9Renderer/Include/CmD3D9HLSLProgramFactory.h

@@ -44,7 +44,7 @@ namespace CamelotFramework
 		/// Get the name of the language this factory creates programs for
 		const String& getLanguage(void) const;
         HighLevelGpuProgramPtr create(const String& source, const String& entryPoint, GpuProgramType gptype, 
-			GpuProgramProfile profile, const vector<HGpuProgInclude>::type* includes);
+			GpuProgramProfile profile, const Vector<HGpuProgInclude>::type* includes);
 		HighLevelGpuProgramPtr create();
     };
 }

CamelotD3D9Renderer/Include/CmD3D9IndexBuffer.h

@@ -99,7 +99,7 @@ namespace CamelotFramework {
 		void destroy_internal();
 
 	protected:		
-		typedef map<IDirect3DDevice9*, BufferResources*>::type	DeviceToBufferResourcesMap;
+		typedef Map<IDirect3DDevice9*, BufferResources*>::type	DeviceToBufferResourcesMap;
 		typedef DeviceToBufferResourcesMap::iterator			DeviceToBufferResourcesIterator;
 
 		DeviceToBufferResourcesMap	mMapDeviceToBufferResources;	// Map between device to buffer resources.