Removed CamelotFramework and BansheeEditor namespaces and made everything BansheeEngine

BansheeEditor/Include/BsCmdEditPlainFieldGO.h

@@ -4,7 +4,7 @@
 #include "BsEditorCommand.h"
 #include "BsUndoRedo.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	// TODO - This is only valid for plain field types. Add something similar for pointers and/or arrays?
 	template<class T>
@@ -20,7 +20,7 @@ namespace BansheeEditor
 				cm_free(mOldData);
 		}
 
-		static void execute(const CM::GameObjectHandleBase& gameObject, const CM::String& fieldName, const T& fieldValue)
+		static void execute(const GameObjectHandleBase& gameObject, const String& fieldName, const T& fieldValue)
 		{
 			// Register command and commit it
 			CmdEditPlainFieldGO* command = new (cm_alloc<CmdEditPlainFieldGO>()) CmdEditPlainFieldGO(gameObject, fieldName, fieldValue);
@@ -34,9 +34,9 @@ namespace BansheeEditor
 				return;
 
 			T fieldValue;
-			CM::RTTIPlainType<T>::fromMemory(fieldValue, (char*)mNewData);
+			RTTIPlainType<T>::fromMemory(fieldValue, (char*)mNewData);
 
-			CM::RTTITypeBase* rtti = mGameObject->getRTTI();
+			RTTITypeBase* rtti = mGameObject->getRTTI();
 			rtti->setPlainValue(mGameObject.get(), mFieldName, fieldValue);
 		}
 
@@ -46,36 +46,36 @@ namespace BansheeEditor
 				return;
 
 			T fieldValue;
-			CM::RTTIPlainType<T>::fromMemory(fieldValue, (char*)mOldData);
+			RTTIPlainType<T>::fromMemory(fieldValue, (char*)mOldData);
 
-			CM::RTTITypeBase* rtti = mGameObject->getRTTI();
+			RTTITypeBase* rtti = mGameObject->getRTTI();
 			rtti->setPlainValue(mGameObject.get(), mFieldName, fieldValue);
 		}
 
 	private:
 		friend class UndoRedo;
 
-		CmdEditPlainFieldGO(const CM::GameObjectHandleBase& gameObject, const CM::String& fieldName, const T& fieldValue)
+		CmdEditPlainFieldGO(const GameObjectHandleBase& gameObject, const String& fieldName, const T& fieldValue)
 			:mGameObject(gameObject), mFieldName(fieldName), mNewData(nullptr), mOldData(nullptr)
 		{
 			// Convert new value to bytes
-			CM::UINT32 newDataNumBytes = CM::RTTIPlainType<T>::getDynamicSize(fieldValue);
-			mNewData = CM::cm_alloc(newDataNumBytes);
+			UINT32 newDataNumBytes = RTTIPlainType<T>::getDynamicSize(fieldValue);
+			mNewData = cm_alloc(newDataNumBytes);
 
-			CM::RTTIPlainType<T>::toMemory(fieldValue, (char*)mNewData);
+			RTTIPlainType<T>::toMemory(fieldValue, (char*)mNewData);
 
 			// Get old value and also convert it to bytes
-			CM::String oldFieldValue;
+			String oldFieldValue;
 			gameObject->getRTTI()->getPlainValue(gameObject.get(), fieldName, oldFieldValue);
 
-			CM::UINT32 oldDataNumBytes = CM::RTTIPlainType<T>::getDynamicSize(oldFieldValue);
+			UINT32 oldDataNumBytes = RTTIPlainType<T>::getDynamicSize(oldFieldValue);
 			mOldData = cm_alloc(oldDataNumBytes);
 
-			CM::RTTIPlainType<T>::toMemory(oldFieldValue, (char*)mOldData);
+			RTTIPlainType<T>::toMemory(oldFieldValue, (char*)mOldData);
 		}
 
-		CM::GameObjectHandleBase mGameObject;
-		CM::String mFieldName;
+		GameObjectHandleBase mGameObject;
+		String mFieldName;
 
 		void* mNewData;
 		void* mOldData;

BansheeEditor/Include/BsCmdReparentSO.h

@@ -4,12 +4,12 @@
 #include "BsEditorCommand.h"
 #include "BsUndoRedo.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class CmdReparentSO : public EditorCommand
 	{
 	public:
-		static void execute(const CM::Vector<CM::HSceneObject>::type& sceneObjects, const CM::HSceneObject& newParent);
+		static void execute(const Vector<HSceneObject>::type& sceneObjects, const HSceneObject& newParent);
 
 		void commit();
 		void revert();
@@ -17,10 +17,10 @@ namespace BansheeEditor
 	private:
 		friend class UndoRedo;
 
-		CmdReparentSO(const CM::Vector<CM::HSceneObject>::type& sceneObjects, const CM::HSceneObject& newParent);
+		CmdReparentSO(const Vector<HSceneObject>::type& sceneObjects, const HSceneObject& newParent);
 
-		CM::Vector<CM::HSceneObject>::type mSceneObjects;
-		CM::Vector<CM::HSceneObject>::type mOldParents;
-		CM::HSceneObject mNewParent;
+		Vector<HSceneObject>::type mSceneObjects;
+		Vector<HSceneObject>::type mOldParents;
+		HSceneObject mNewParent;
 	};
 }

BansheeEditor/Include/BsDbgTestGameObjectRef.h

@@ -3,23 +3,23 @@
 #include "BsPrerequisites.h"
 #include "CmComponent.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class DbgTestGameObjectRef : public CM::Component
+	class DbgTestGameObjectRef : public Component
 	{
 	public:
-		BS::HRenderable mRenderable;
+		HRenderable mRenderable;
 
 		/************************************************************************/
 		/* 							COMPONENT OVERRIDES                    		*/
 		/************************************************************************/
 
 	protected:
-		friend class CM::SceneObject;
+		friend class SceneObject;
 
 		/** Standard constructor.
         */
-		DbgTestGameObjectRef(const CM::HSceneObject& parent);
+		DbgTestGameObjectRef(const HSceneObject& parent);
 
 	public:
 		virtual void update() {}
@@ -29,8 +29,8 @@ namespace BansheeEditor
 		/************************************************************************/
 	public:
 		friend class DbgTestGameObjectRefRTTI;
-		static CM::RTTITypeBase* getRTTIStatic();
-		virtual CM::RTTITypeBase* getRTTI() const;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
 
 	protected:
 		DbgTestGameObjectRef() {} // Serialization only

BansheeEditor/Include/BsDbgTestGameObjectRefRTTI.h

@@ -5,13 +5,13 @@
 #include "BsDbgTestGameObjectRef.h"
 #include "CmGameObjectRTTI.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class DbgTestGameObjectRefRTTI : public CM::RTTIType<DbgTestGameObjectRef, CM::Component, DbgTestGameObjectRefRTTI>
+	class DbgTestGameObjectRefRTTI : public RTTIType<DbgTestGameObjectRef, Component, DbgTestGameObjectRefRTTI>
 	{
 	private:
-		BS::HRenderable& getRenderable(DbgTestGameObjectRef* obj) { return obj->mRenderable; }
-		void setRenderable(DbgTestGameObjectRef* obj, BS::HRenderable& val) 
+		HRenderable& getRenderable(DbgTestGameObjectRef* obj) { return obj->mRenderable; }
+		void setRenderable(DbgTestGameObjectRef* obj, HRenderable& val) 
 		{ 
 			obj->mRenderable = val; 
 		} 
@@ -22,20 +22,20 @@ namespace BansheeEditor
 			addReflectableField("mRenderable", 0, &DbgTestGameObjectRefRTTI::getRenderable, &DbgTestGameObjectRefRTTI::setRenderable);
 		}
 
-		virtual const CM::String& getRTTIName()
+		virtual const String& getRTTIName()
 		{
-			static CM::String name = "DbgTestGameObjectRef";
+			static String name = "DbgTestGameObjectRef";
 			return name;
 		}
 
-		virtual CM::UINT32 getRTTIId()
+		virtual UINT32 getRTTIId()
 		{
 			return 600001; // NOTE: Just a debug value
 		}
 
-		virtual std::shared_ptr<CM::IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
 		{
-			return CM::GameObjectRTTI::createGameObject<DbgTestGameObjectRef>();
+			return GameObjectRTTI::createGameObject<DbgTestGameObjectRef>();
 		}
 	};
 }

BansheeEditor/Include/BsDockManager.h

@@ -4,14 +4,14 @@
 #include "BsGUIElementContainer.h"
 #include "CmRectI.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	enum class DockLocation
 	{
 		Left, Right, Top, Bottom, Center
 	};
 
-	class DockManager : public BS::GUIElementContainer
+	class DockManager : public GUIElementContainer
 	{
 	public:
 		class DockContainer
@@ -21,17 +21,17 @@ namespace BansheeEditor
 			DockContainer(DockContainer* parent);
 			~DockContainer();
 
-			void setArea(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
-			void makeLeaf(BS::GUIWidget* widgetParent, CM::RenderWindow* parentWindow);
+			void setArea(INT32 x, INT32 y, UINT32 width, UINT32 height);
+			void makeLeaf(GUIWidget* widgetParent, RenderWindow* parentWindow);
 			void makeLeaf(EditorWidgetContainer* existingContainer);
-			void splitContainer(BS::GUIWidget* widgetParent, CM::RenderWindow* parentWindow, bool horizontal, bool newChildIsFirst, float splitPosition = 0.5f);
-			void addLeft(BS::GUIWidget* widgetParent, CM::RenderWindow* parentWindow, EditorWidgetBase* widget);
-			void addRight(BS::GUIWidget* widgetParent, CM::RenderWindow* parentWindow, EditorWidgetBase* widget);
-			void addTop(BS::GUIWidget* widgetParent, CM::RenderWindow* parentWindow, EditorWidgetBase* widget);
-			void addBottom(BS::GUIWidget* widgetParent, CM::RenderWindow* parentWindow, EditorWidgetBase* widget);
+			void splitContainer(GUIWidget* widgetParent, RenderWindow* parentWindow, bool horizontal, bool newChildIsFirst, float splitPosition = 0.5f);
+			void addLeft(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget);
+			void addRight(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget);
+			void addTop(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget);
+			void addBottom(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget);
 
 			void addWidget(EditorWidgetBase* widget);
-			void addWidget(const CM::String& name);
+			void addWidget(const String& name);
 
 			DockContainer* find(EditorWidgetContainer* widgetContainer);
 
@@ -42,26 +42,26 @@ namespace BansheeEditor
 			 *
 			 * @return	null if it fails, else the found DockContainer at position.
 			 */
-			DockContainer* findAtPos(const CM::Vector2I& pos);
+			DockContainer* findAtPos(const Vector2I& pos);
 
-			CM::RectI getContentBounds() const;
+			RectI getContentBounds() const;
 
 			bool mIsLeaf;
 			DockContainer* mChildren[2];
 			DockContainer* mParent;
 			EditorWidgetContainer* mWidgets;
 			GUIDockSlider* mSlider;
-			CM::RectI mArea;
+			RectI mArea;
 			float mSplitPosition;
 			bool mIsHorizontal;
 
-			static const CM::UINT32 SLIDER_SIZE;
-			static const CM::UINT32 MIN_CHILD_SIZE;
+			static const UINT32 SLIDER_SIZE;
+			static const UINT32 MIN_CHILD_SIZE;
 
 		private:
 			void updateChildAreas();
 
-			void sliderDragged(const CM::Vector2I& delta);
+			void sliderDragged(const Vector2I& delta);
 			void widgetRemoved();
 		};
 
@@ -74,20 +74,20 @@ namespace BansheeEditor
 			None
 		};
 	public:
-		static DockManager* create(CM::RenderWindow* parentWindow);
+		static DockManager* create(RenderWindow* parentWindow);
 
 		/**
 		 * @brief	Internal method. Called once every frame.
 		 */
 		void update();
 
-		void render(const CM::Viewport* viewport, CM::RenderQueue& renderQueue);
+		void render(const Viewport* viewport, RenderQueue& renderQueue);
 		void insert(EditorWidgetContainer* relativeTo, EditorWidgetBase* widgetToInsert, DockLocation location);
 
 		DockManagerLayoutPtr getLayout() const;
 		void setLayout(const DockManagerLayoutPtr& layout);
 
-		void setArea(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
+		void setArea(INT32 x, INT32 y, UINT32 width, UINT32 height);
 
 	protected:
 		~DockManager();
@@ -95,33 +95,33 @@ namespace BansheeEditor
 		void updateClippedBounds();
 
 	private:
-		DockManager(CM::RenderWindow* parentWindow, const BS::GUILayoutOptions& layoutOptions);
+		DockManager(RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions);
 
-		static const CM::Color TINT_COLOR;
-		static const CM::Color HIGHLIGHT_COLOR;
+		static const Color TINT_COLOR;
+		static const Color HIGHLIGHT_COLOR;
 
-		CM::RenderWindow* mParentWindow;
+		RenderWindow* mParentWindow;
 		DockContainer mRootContainer;
-		CM::RectI mArea;
+		RectI mArea;
 
-		CM::HMesh mDropOverlayMesh;
-		CM::HMaterial mDropOverlayMat;
-		CM::RectI mLastOverlayBounds;
+		HMesh mDropOverlayMesh;
+		HMaterial mDropOverlayMat;
+		RectI mLastOverlayBounds;
 
 		DockContainer* mMouseOverContainer;
 		DockLocation mHighlightedDropLoc;
 		bool mShowOverlay;
-		CM::Vector2* mTopDropPolygon;
-		CM::Vector2* mBotDropPolygon;
-		CM::Vector2* mLeftDropPolygon;
-		CM::Vector2* mRightDropPolygon;
+		Vector2* mTopDropPolygon;
+		Vector2* mBotDropPolygon;
+		Vector2* mLeftDropPolygon;
+		Vector2* mRightDropPolygon;
 		bool mAddedRenderCallback;
 
-		void updateDropOverlay(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
+		void updateDropOverlay(INT32 x, INT32 y, UINT32 width, UINT32 height);
 
-		bool mouseEvent(const BS::GUIMouseEvent& event);
-		bool insidePolygon(CM::Vector2* polyPoints, CM::UINT32 numPoints, CM::Vector2 point) const;
+		bool mouseEvent(const GUIMouseEvent& event);
+		bool insidePolygon(Vector2* polyPoints, UINT32 numPoints, Vector2 point) const;
 
-		void _changeParentWidget(BS::GUIWidget* widget);
+		void _changeParentWidget(GUIWidget* widget);
 	};
 }

BansheeEditor/Include/BsDockManagerLayout.h

@@ -4,9 +4,9 @@
 #include "CmIReflectable.h"
 #include "CmRectI.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class DockManagerLayout : public CM::IReflectable
+	class DockManagerLayout : public IReflectable
 	{
 	public:
 		struct Entry
@@ -15,12 +15,12 @@ namespace BansheeEditor
 			Entry();
 			~Entry();
 
-			static Entry* createLeaf(Entry* parent, CM::UINT32 childIdx, 
-				const CM::Vector<CM::String>::type& widgetNames);
-			static Entry* createContainer(Entry* parent, CM::UINT32 childIdx, float splitPosition, 
+			static Entry* createLeaf(Entry* parent, UINT32 childIdx, 
+				const Vector<String>::type& widgetNames);
+			static Entry* createContainer(Entry* parent, UINT32 childIdx, float splitPosition, 
 				bool horizontalSplit);
 
-			CM::Vector<CM::String>::type widgetNames;
+			Vector<String>::type widgetNames;
 			bool isLeaf;
 			float splitPosition;
 			bool horizontalSplit;
@@ -43,7 +43,7 @@ namespace BansheeEditor
 
 	public:
 		friend class DockManagerLayoutRTTI;
-		static CM::RTTITypeBase* getRTTIStatic();
-		virtual CM::RTTITypeBase* getRTTI() const;	
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
 	};
 }

BansheeEditor/Include/BsDockManagerLayoutRTTI.h

@@ -4,9 +4,9 @@
 #include "BsDockManagerLayout.h"
 #include "CmRTTIType.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class DockManagerLayoutRTTI : public CM::RTTIType<DockManagerLayout, CM::IReflectable, DockManagerLayoutRTTI>
+	class DockManagerLayoutRTTI : public RTTIType<DockManagerLayout, IReflectable, DockManagerLayoutRTTI>
 	{
 	private:
 		DockManagerLayout::Entry& getRootEntry(DockManagerLayout* obj) { return obj->mRootEntry; }
@@ -18,31 +18,31 @@ namespace BansheeEditor
 			addPlainField("mRootEntry", 0, &DockManagerLayoutRTTI::getRootEntry, &DockManagerLayoutRTTI::setRootEntry);
 		}
 
-		virtual const CM::String& getRTTIName()
+		virtual const String& getRTTIName()
 		{
-			static CM::String name = "DockManagerLayout";
+			static String name = "DockManagerLayout";
 			return name;
 		}
 
-		virtual CM::UINT32 getRTTIId()
+		virtual UINT32 getRTTIId()
 		{
 			return TID_DockManagerLayout;
 		}
 
-		virtual std::shared_ptr<CM::IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
 		{
-			return CM::cm_shared_ptr<DockManagerLayout>();
+			return cm_shared_ptr<DockManagerLayout>();
 		}
 	};
 }
 
-namespace CamelotFramework
+namespace BansheeEngine
 {
-	template<> struct CM::RTTIPlainType<BansheeEditor::DockManagerLayout::Entry>
+	template<> struct RTTIPlainType<BansheeEngine::DockManagerLayout::Entry>
 	{	
-		enum { id = BansheeEditor::TID_DockManagerLayoutEntry }; enum { hasDynamicSize = 1 };
+		enum { id = BansheeEngine::TID_DockManagerLayoutEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const BansheeEditor::DockManagerLayout::Entry& data, char* memory)
+		static void toMemory(const BansheeEngine::DockManagerLayout::Entry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			char* memoryStart = memory;
@@ -63,7 +63,7 @@ namespace CamelotFramework
 			memcpy(memoryStart, &size, sizeof(UINT32));
 		}
 
-		static UINT32 fromMemory(BansheeEditor::DockManagerLayout::Entry& data, char* memory)
+		static UINT32 fromMemory(BansheeEngine::DockManagerLayout::Entry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			memcpy(&size, memory, sizeof(UINT32));
@@ -76,8 +76,8 @@ namespace CamelotFramework
 
 			if(!data.isLeaf)
 			{
-				data.children[0] = cm_new<BansheeEditor::DockManagerLayout::Entry>();
-				data.children[1] = cm_new<BansheeEditor::DockManagerLayout::Entry>();
+				data.children[0] = cm_new<BansheeEngine::DockManagerLayout::Entry>();
+				data.children[1] = cm_new<BansheeEngine::DockManagerLayout::Entry>();
 
 				memory = rttiReadElem(*data.children[0], memory);
 				memory = rttiReadElem(*data.children[1], memory);
@@ -89,7 +89,7 @@ namespace CamelotFramework
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const BansheeEditor::DockManagerLayout::Entry& data)	
+		static UINT32 getDynamicSize(const BansheeEngine::DockManagerLayout::Entry& data)	
 		{ 
 			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.isLeaf) + rttiGetElemSize(data.horizontalSplit) + 
 				rttiGetElemSize(data.splitPosition) + rttiGetElemSize(data.widgetNames);

BansheeEditor/Include/BsEditorApplication.h

@@ -3,7 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "CmModule.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	enum class RenderSystemPlugin
 	{
@@ -12,7 +12,7 @@ namespace BansheeEditor
 		OpenGL
 	};
 
-	class BS_ED_EXPORT EditorApplication : public CM::Module<EditorApplication>
+	class BS_ED_EXPORT EditorApplication : public Module<EditorApplication>
 	{
 	public:
 		EditorApplication(RenderSystemPlugin renderSystemPlugin);
@@ -21,18 +21,18 @@ namespace BansheeEditor
 		void runMainLoop();
 
 		bool isProjectLoaded() const;
-		const CM::WString& getActiveProjectPath() const;
+		const WString& getActiveProjectPath() const;
 	private:
-		static const CM::WString WIDGET_LAYOUT_PATH;
+		static const WString WIDGET_LAYOUT_PATH;
 		RenderSystemPlugin mActiveRSPlugin;
 
-		static const CM::String& getLibraryNameForRenderSystem(RenderSystemPlugin plugin);
+		static const String& getLibraryNameForRenderSystem(RenderSystemPlugin plugin);
 
 		void update();
 
 		EditorWidgetLayoutPtr loadWidgetLayout();
 		void saveWidgetLayout(const EditorWidgetLayoutPtr& layout);
 
-		static void closeModalWindow(CM::RenderWindowPtr window, CM::HSceneObject sceneObject);
+		static void closeModalWindow(RenderWindowPtr window, HSceneObject sceneObject);
 	};
 }

BansheeEditor/Include/BsEditorCommand.h

@@ -2,7 +2,7 @@
 
 #include "BsEditorPrerequisites.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class EditorCommand
 	{

BansheeEditor/Include/BsEditorGUI.h

@@ -4,136 +4,136 @@
 #include "BsGUISkin.h"
 #include "CmModule.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class EditorGUI : public CamelotFramework::Module<EditorGUI>
+	class EditorGUI : public BansheeEngine::Module<EditorGUI>
 	{
 	public:
 		EditorGUI();
 
-		const BS::GUISkin& getSkin() const { return mSkin; }
+		const GUISkin& getSkin() const { return mSkin; }
 
 	private:
-		BS::GUISkin mSkin;
+		GUISkin mSkin;
 
-		static const CM::WString DefaultFolder;
+		static const WString DefaultFolder;
 
-		static const CM::WString DefaultFontPath;
-		static const CM::UINT32 DefaultFontSize;
+		static const WString DefaultFontPath;
+		static const UINT32 DefaultFontSize;
 
-		static const CM::WString WindowBackgroundTexture;
+		static const WString WindowBackgroundTexture;
 
-		static const CM::WString WindowFrameNormal;
-		static const CM::WString WindowFrameFocused;
+		static const WString WindowFrameNormal;
+		static const WString WindowFrameFocused;
 
-		static const CM::WString WindowTitleBarBg;
+		static const WString WindowTitleBarBg;
 
-		static const CM::WString WindowCloseButtonNormal;
-		static const CM::WString WindowCloseButtonHover;
+		static const WString WindowCloseButtonNormal;
+		static const WString WindowCloseButtonHover;
 
-		static const CM::WString WindowMinButtonNormal;
-		static const CM::WString WindowMinButtonHover;
+		static const WString WindowMinButtonNormal;
+		static const WString WindowMinButtonHover;
 
-		static const CM::WString WindowMaxButtonNormal;
-		static const CM::WString WindowMaxButtonHover;
+		static const WString WindowMaxButtonNormal;
+		static const WString WindowMaxButtonHover;
 
-		static const CM::WString TabbedBarBtnNormal;
-		static const CM::WString TabbedBarBtnActive;
+		static const WString TabbedBarBtnNormal;
+		static const WString TabbedBarBtnActive;
 
-		static const CM::WString ButtonNormalTex;
-		static const CM::WString ButtonHoverTex;
-		static const CM::WString ButtonActiveTex;
+		static const WString ButtonNormalTex;
+		static const WString ButtonHoverTex;
+		static const WString ButtonActiveTex;
 
-		static const CM::WString ToggleNormalTex;
-		static const CM::WString ToggleHoverTex;
-		static const CM::WString ToggleActiveTex;
-		static const CM::WString ToggleNormalOnTex;
-		static const CM::WString ToggleHoverOnTex;
-		static const CM::WString ToggleActiveOnTex;
+		static const WString ToggleNormalTex;
+		static const WString ToggleHoverTex;
+		static const WString ToggleActiveTex;
+		static const WString ToggleNormalOnTex;
+		static const WString ToggleHoverOnTex;
+		static const WString ToggleActiveOnTex;
 
-		static const CM::WString ObjectDropBtnNormalTex;
-		static const CM::WString ObjectDropBtnNormalOnTex;
-		static const CM::WString ObjectClearBtnNormalTex;
-		static const CM::WString ObjectClearBtnHoverTex;
-		static const CM::WString ObjectClearBtnActiveTex;
+		static const WString ObjectDropBtnNormalTex;
+		static const WString ObjectDropBtnNormalOnTex;
+		static const WString ObjectClearBtnNormalTex;
+		static const WString ObjectClearBtnHoverTex;
+		static const WString ObjectClearBtnActiveTex;
 
-		static const CM::WString FoldoutOpenNormalTex;
-		static const CM::WString FoldoutOpenHoverTex;
-		static const CM::WString FoldoutClosedNormalTex;
-		static const CM::WString FoldoutClosedHoverTex;
-		static const CM::WString FoldoutBackgroundTex;
+		static const WString FoldoutOpenNormalTex;
+		static const WString FoldoutOpenHoverTex;
+		static const WString FoldoutClosedNormalTex;
+		static const WString FoldoutClosedHoverTex;
+		static const WString FoldoutBackgroundTex;
 
-		static const CM::WString InputBoxNormalTex;
-		static const CM::WString InputBoxHoverTex;
-		static const CM::WString InputBoxFocusedTex;
+		static const WString InputBoxNormalTex;
+		static const WString InputBoxHoverTex;
+		static const WString InputBoxFocusedTex;
 
-		static const CM::WString ScrollBarUpNormalTex;
-		static const CM::WString ScrollBarUpHoverTex;
-		static const CM::WString ScrollBarUpActiveTex;
+		static const WString ScrollBarUpNormalTex;
+		static const WString ScrollBarUpHoverTex;
+		static const WString ScrollBarUpActiveTex;
 
-		static const CM::WString ScrollBarDownNormalTex;
-		static const CM::WString ScrollBarDownHoverTex;
-		static const CM::WString ScrollBarDownActiveTex;
+		static const WString ScrollBarDownNormalTex;
+		static const WString ScrollBarDownHoverTex;
+		static const WString ScrollBarDownActiveTex;
 
-		static const CM::WString ScrollBarLeftNormalTex;
-		static const CM::WString ScrollBarLeftHoverTex;
-		static const CM::WString ScrollBarLeftActiveTex;
+		static const WString ScrollBarLeftNormalTex;
+		static const WString ScrollBarLeftHoverTex;
+		static const WString ScrollBarLeftActiveTex;
 
-		static const CM::WString ScrollBarRightNormalTex;
-		static const CM::WString ScrollBarRightHoverTex;
-		static const CM::WString ScrollBarRightActiveTex;
+		static const WString ScrollBarRightNormalTex;
+		static const WString ScrollBarRightHoverTex;
+		static const WString ScrollBarRightActiveTex;
 
-		static const CM::WString ScrollBarHandleHorzNormalTex;
-		static const CM::WString ScrollBarHandleHorzHoverTex;
-		static const CM::WString ScrollBarHandleHorzActiveTex;
+		static const WString ScrollBarHandleHorzNormalTex;
+		static const WString ScrollBarHandleHorzHoverTex;
+		static const WString ScrollBarHandleHorzActiveTex;
 
-		static const CM::WString ScrollBarHandleVertNormalTex;
-		static const CM::WString ScrollBarHandleVertHoverTex;
-		static const CM::WString ScrollBarHandleVertActiveTex;
+		static const WString ScrollBarHandleVertNormalTex;
+		static const WString ScrollBarHandleVertHoverTex;
+		static const WString ScrollBarHandleVertActiveTex;
 
-		static const CM::WString ScrollBarBgTex;
+		static const WString ScrollBarBgTex;
 
-		static const CM::WString DropDownBtnNormalTex;
-		static const CM::WString DropDownBtnHoverTex;
+		static const WString DropDownBtnNormalTex;
+		static const WString DropDownBtnHoverTex;
 
-		static const CM::WString DropDownBoxBgTex;
-		static const CM::WString DropDownBoxEntryNormalTex;
-		static const CM::WString DropDownBoxEntryHoverTex;
+		static const WString DropDownBoxBgTex;
+		static const WString DropDownBoxEntryNormalTex;
+		static const WString DropDownBoxEntryHoverTex;
 
-		static const CM::WString DropDownBoxBtnUpNormalTex;
-		static const CM::WString DropDownBoxBtnUpHoverTex;
+		static const WString DropDownBoxBtnUpNormalTex;
+		static const WString DropDownBoxBtnUpHoverTex;
 
-		static const CM::WString DropDownBoxBtnDownNormalTex;
-		static const CM::WString DropDownBoxBtnDownHoverTex;
+		static const WString DropDownBoxBtnDownNormalTex;
+		static const WString DropDownBoxBtnDownHoverTex;
 
-		static const CM::WString DropDownBoxEntryExpNormalTex;
-		static const CM::WString DropDownBoxEntryExpHoverTex;
+		static const WString DropDownBoxEntryExpNormalTex;
+		static const WString DropDownBoxEntryExpHoverTex;
 
-		static const CM::WString DropDownSeparatorTex;
+		static const WString DropDownSeparatorTex;
 
-		static const CM::WString DropDownBoxBtnUpArrowTex;
-		static const CM::WString DropDownBoxBtnDownArrowTex;
+		static const WString DropDownBoxBtnUpArrowTex;
+		static const WString DropDownBoxBtnDownArrowTex;
 
-		static const CM::WString MenuBarBgTex;
+		static const WString MenuBarBgTex;
 
-		static const CM::WString MenuBarBtnNormalTex;
-		static const CM::WString MenuBarBtnHoverTex;
+		static const WString MenuBarBtnNormalTex;
+		static const WString MenuBarBtnHoverTex;
 
-		static const CM::WString MenuBarBansheeLogoTex;
+		static const WString MenuBarBansheeLogoTex;
 
-		static const CM::WString DockSliderNormalTex;
+		static const WString DockSliderNormalTex;
 
-		static const CM::WString TreeViewExpandButtonOffNormal;
-		static const CM::WString TreeViewExpandButtonOffHover;
-		static const CM::WString TreeViewExpandButtonOnNormal;
-		static const CM::WString TreeViewExpandButtonOnHover;
+		static const WString TreeViewExpandButtonOffNormal;
+		static const WString TreeViewExpandButtonOffHover;
+		static const WString TreeViewExpandButtonOnNormal;
+		static const WString TreeViewExpandButtonOnHover;
 
-		static const CM::WString TreeViewSelectionBackground;
-		static const CM::WString TreeViewEditBox;
+		static const WString TreeViewSelectionBackground;
+		static const WString TreeViewEditBox;
 
-		static const CM::WString TreeViewElementHighlight;
-		static const CM::WString TreeViewElementSepHighlight;
+		static const WString TreeViewElementHighlight;
+		static const WString TreeViewElementSepHighlight;
 
-		static BS::HSpriteTexture getTexture(const CM::WString& name);
+		static HSpriteTexture getTexture(const WString& name);
 	};
 }

BansheeEditor/Include/BsEditorPrerequisites.h

@@ -18,7 +18,7 @@
 #    define BS_ED_EXPORT
 #endif
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	// GUI
 	class EditorWindowBase;

BansheeEditor/Include/BsEditorWidget.h

@@ -4,21 +4,21 @@
 #include "BsEditorWidgetManager.h"
 #include "boost/signal.hpp"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT EditorWidgetBase
 	{
 	public:
-		const CM::String& getName() const { return mName; }
-		const CM::HString& getDisplayName() const { return mDisplayName; }
+		const String& getName() const { return mName; }
+		const HString& getDisplayName() const { return mDisplayName; }
 
-		CM::INT32 getX() const { return mX; }
-		CM::INT32 getY() const { return mY; }
-		CM::UINT32 getWidth() const { return mWidth; }
-		CM::UINT32 getHeight() const { return mHeight; }
+		INT32 getX() const { return mX; }
+		INT32 getY() const { return mY; }
+		UINT32 getWidth() const { return mWidth; }
+		UINT32 getHeight() const { return mHeight; }
 
-		void _setSize(CM::UINT32 width, CM::UINT32 height);
-		void _setPosition(CM::INT32 x, CM::INT32 y);
+		void _setSize(UINT32 width, UINT32 height);
+		void _setPosition(INT32 x, INT32 y);
 		void _changeParent(EditorWidgetContainer* parent);
 		EditorWidgetContainer* _getParent() const { return mParent; }
 
@@ -27,23 +27,23 @@ namespace BansheeEditor
 
 		void close();
 
-		boost::signal<void(CM::UINT32, CM::UINT32)> onResized;
-		boost::signal<void(CM::INT32, CM::INT32)> onMoved;
+		boost::signal<void(UINT32, UINT32)> onResized;
+		boost::signal<void(INT32, INT32)> onMoved;
 		boost::signal<void(EditorWidgetContainer*)> onParentChanged;
 	protected:
 		friend class EditorWidgetManager;
 
-		EditorWidgetBase(const CM::HString& displayName, const CM::String& name, EditorWidgetContainer& parentContainer);
+		EditorWidgetBase(const HString& displayName, const String& name, EditorWidgetContainer& parentContainer);
 		virtual ~EditorWidgetBase();
 
-		CM::String mName;
-		CM::HString mDisplayName;
+		String mName;
+		HString mDisplayName;
 		EditorWidgetContainer* mParent;
-		CM::INT32 mX, mY;
-		CM::UINT32 mWidth, mHeight;
-		BS::GUIArea* mContent;
+		INT32 mX, mY;
+		UINT32 mWidth, mHeight;
+		GUIArea* mContent;
 
-		BS::GUIWidget& getParentWidget() const;
+		GUIWidget& getParentWidget() const;
 
 		static void destroy(EditorWidgetBase* widget);
 	};
@@ -75,7 +75,7 @@ namespace BansheeEditor
 
 		struct ConstructPrivately {};
 
-		EditorWidget(const CM::HString& displayName, EditorWidgetContainer& parentContainer)
+		EditorWidget(const HString& displayName, EditorWidgetContainer& parentContainer)
 			:EditorWidgetBase(displayName, Type::getTypeName(), parentContainer)
 		{
 			RegisterOnStart.makeSureIAmInstantiated();

BansheeEditor/Include/BsEditorWidgetContainer.h

@@ -3,29 +3,29 @@
 #include "BsEditorPrerequisites.h"
 #include <boost/signal.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT EditorWidgetContainer
 	{
 	public:
-		EditorWidgetContainer(BS::GUIWidget* parent, CM::RenderWindow* renderWindow, EditorWindow* parentEditorWindow);
+		EditorWidgetContainer(GUIWidget* parent, RenderWindow* renderWindow, EditorWindow* parentEditorWindow);
 		virtual ~EditorWidgetContainer();
 
 		void add(EditorWidgetBase& widget);
 		void remove(EditorWidgetBase& widget);
-		void insert(CM::UINT32 idx, EditorWidgetBase& widget);
+		void insert(UINT32 idx, EditorWidgetBase& widget);
 		bool contains(EditorWidgetBase& widget);
 
-		void setSize(CM::UINT32 width, CM::UINT32 height);
-		void setPosition(CM::INT32 x, CM::INT32 y);
+		void setSize(UINT32 width, UINT32 height);
+		void setPosition(INT32 x, INT32 y);
 
-		CM::UINT32 getNumWidgets() const { return (CM::UINT32)mWidgets.size(); }
-		EditorWidgetBase* getWidget(CM::UINT32 idx) const;
-		BS::GUIWidget& getParentWidget() const { return *mParent; }
+		UINT32 getNumWidgets() const { return (UINT32)mWidgets.size(); }
+		EditorWidgetBase* getWidget(UINT32 idx) const;
+		GUIWidget& getParentWidget() const { return *mParent; }
 		EditorWindow* getParentWindow() const { return mParentWindow; }
 
-		CM::RectI getContentBounds() const;
-		CM::Vector<CM::RectI>::type getDraggableAreas() const;
+		RectI getContentBounds() const;
+		Vector<RectI>::type getDraggableAreas() const;
 
 		void _notifyWidgetDestroyed(EditorWidgetBase* widget);
 
@@ -33,22 +33,22 @@ namespace BansheeEditor
 	private:
 		EditorWindow* mParentWindow;
 		GUITabbedTitleBar* mTitleBar;
-		BS::GUIArea* mTitleBarArea;
-		BS::GUIWidget* mParent;
-		CM::INT32 mX, mY;
-		CM::UINT32 mWidth, mHeight;
-		CM::UnorderedMap<CM::UINT32, EditorWidgetBase*>::type mWidgets;
-		CM::INT32 mActiveWidget;
+		GUIArea* mTitleBarArea;
+		GUIWidget* mParent;
+		INT32 mX, mY;
+		UINT32 mWidth, mHeight;
+		UnorderedMap<UINT32, EditorWidgetBase*>::type mWidgets;
+		INT32 mActiveWidget;
 
-		static const CM::UINT32 TitleBarHeight;
+		static const UINT32 TitleBarHeight;
 
 		void removeInternal(EditorWidgetBase& widget);
 
-		void setActiveWidget(CM::UINT32 idx);
-		void tabActivated(CM::UINT32 idx);
-		void tabClosed(CM::UINT32 idx);
-		void tabDraggedOff(CM::UINT32 idx);
-		void tabDraggedOn(CM::UINT32 idx);
+		void setActiveWidget(UINT32 idx);
+		void tabActivated(UINT32 idx);
+		void tabClosed(UINT32 idx);
+		void tabDraggedOff(UINT32 idx);
+		void tabDraggedOn(UINT32 idx);
 
 		static void tabDroppedCallback(bool wasDragProcessed);
 	};

BansheeEditor/Include/BsEditorWidgetLayout.h

@@ -3,9 +3,9 @@
 #include "BsEditorPrerequisites.h"
 #include "CmIReflectable.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class EditorWidgetLayout : public CM::IReflectable
+	class EditorWidgetLayout : public IReflectable
 	{
 	public:
 		struct Entry
@@ -14,10 +14,10 @@ namespace BansheeEditor
 			Entry();
 			~Entry();
 
-			CM::Vector<CM::String>::type widgetNames;
+			Vector<String>::type widgetNames;
 			bool isDocked;
-			CM::INT32 x, y;
-			CM::UINT32 width, height;
+			INT32 x, y;
+			UINT32 width, height;
 		};
 
 	private:
@@ -27,11 +27,11 @@ namespace BansheeEditor
 		EditorWidgetLayout(const DockManagerLayoutPtr& dockLayout);
 		EditorWidgetLayout(const PrivatelyConstruct& dummy) { }
 
-		CM::Vector<Entry>::type& getEntries() { return mEntries; }
+		Vector<Entry>::type& getEntries() { return mEntries; }
 		const DockManagerLayoutPtr& getDockLayout() const { return mDockLayout; }
 
 	private:
-		CM::Vector<Entry>::type mEntries;
+		Vector<Entry>::type mEntries;
 		DockManagerLayoutPtr mDockLayout;
 
 		/************************************************************************/
@@ -39,7 +39,7 @@ namespace BansheeEditor
 		/************************************************************************/
 	public:
 		friend class EditorWidgetLayoutRTTI;
-		static CM::RTTITypeBase* getRTTIStatic();
-		virtual CM::RTTITypeBase* getRTTI() const;	
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
 	};
 }

BansheeEditor/Include/BsEditorWidgetLayoutRTTI.h

@@ -5,15 +5,15 @@
 #include "BsDockManagerLayout.h"
 #include "CmRTTIType.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class EditorWidgetLayoutRTTI : public CM::RTTIType<EditorWidgetLayout, CM::IReflectable, EditorWidgetLayoutRTTI>
+	class EditorWidgetLayoutRTTI : public RTTIType<EditorWidgetLayout, IReflectable, EditorWidgetLayoutRTTI>
 	{
 	private:
-		EditorWidgetLayout::Entry& getEntry(EditorWidgetLayout* obj, CM::UINT32 idx) { return obj->mEntries[idx]; }
-		void setEntry(EditorWidgetLayout* obj, CM::UINT32 idx, EditorWidgetLayout::Entry& val) { obj->mEntries[idx] = val; } 
-		CM::UINT32 getEntriesArraySize(EditorWidgetLayout* obj) { return (CM::UINT32)obj->mEntries.size(); }
-		void setEntriesArraySize(EditorWidgetLayout* obj, CM::UINT32 size) { obj->mEntries.resize(size); }
+		EditorWidgetLayout::Entry& getEntry(EditorWidgetLayout* obj, UINT32 idx) { return obj->mEntries[idx]; }
+		void setEntry(EditorWidgetLayout* obj, UINT32 idx, EditorWidgetLayout::Entry& val) { obj->mEntries[idx] = val; } 
+		UINT32 getEntriesArraySize(EditorWidgetLayout* obj) { return (UINT32)obj->mEntries.size(); }
+		void setEntriesArraySize(EditorWidgetLayout* obj, UINT32 size) { obj->mEntries.resize(size); }
 
 		DockManagerLayoutPtr getDockLayout(EditorWidgetLayout* obj) { return obj->mDockLayout; }
 		void setDockLayout(EditorWidgetLayout* obj, DockManagerLayoutPtr val) { obj->mDockLayout = val; }
@@ -27,31 +27,31 @@ namespace BansheeEditor
 			addReflectablePtrField("mDockLayout", 1, &EditorWidgetLayoutRTTI::getDockLayout, &EditorWidgetLayoutRTTI::setDockLayout);
 		}
 
-		virtual const CM::String& getRTTIName()
+		virtual const String& getRTTIName()
 		{
-			static CM::String name = "EditorWidgetLayout";
+			static String name = "EditorWidgetLayout";
 			return name;
 		}
 
-		virtual CM::UINT32 getRTTIId()
+		virtual UINT32 getRTTIId()
 		{
 			return TID_EditorWidgetLayout;
 		}
 
-		virtual std::shared_ptr<CM::IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
 		{
-			return CM::cm_shared_ptr<EditorWidgetLayout>(EditorWidgetLayout::PrivatelyConstruct());
+			return cm_shared_ptr<EditorWidgetLayout>(EditorWidgetLayout::PrivatelyConstruct());
 		}
 	};
 }
 
-namespace CamelotFramework
+namespace BansheeEngine
 {
-	template<> struct CM::RTTIPlainType<BansheeEditor::EditorWidgetLayout::Entry>
+	template<> struct RTTIPlainType<BansheeEngine::EditorWidgetLayout::Entry>
 	{	
-		enum { id = BansheeEditor::TID_EditorWidgetLayoutEntry }; enum { hasDynamicSize = 1 };
+		enum { id = BansheeEngine::TID_EditorWidgetLayoutEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const BansheeEditor::EditorWidgetLayout::Entry& data, char* memory)
+		static void toMemory(const BansheeEngine::EditorWidgetLayout::Entry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			char* memoryStart = memory;
@@ -68,7 +68,7 @@ namespace CamelotFramework
 			memcpy(memoryStart, &size, sizeof(UINT32));
 		}
 
-		static UINT32 fromMemory(BansheeEditor::EditorWidgetLayout::Entry& data, char* memory)
+		static UINT32 fromMemory(BansheeEngine::EditorWidgetLayout::Entry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			memcpy(&size, memory, sizeof(UINT32));
@@ -84,7 +84,7 @@ namespace CamelotFramework
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const BansheeEditor::EditorWidgetLayout::Entry& data)	
+		static UINT32 getDynamicSize(const BansheeEngine::EditorWidgetLayout::Entry& data)	
 		{ 
 			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.widgetNames) + rttiGetElemSize(data.isDocked) + 
 				rttiGetElemSize(data.x) + rttiGetElemSize(data.y) + rttiGetElemSize(data.width) + rttiGetElemSize(data.height);

BansheeEditor/Include/BsEditorWidgetManager.h

@@ -3,7 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "CmModule.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	/**
 	 * @brief	Handles opening and closing of EditorWidgets. Its primary purpose
@@ -11,7 +11,7 @@ namespace BansheeEditor
 	 * 			upon program shutdown/startup, as well as being able to change widget layout on
 	 * 			the fly.
 	 */
-	class BS_ED_EXPORT EditorWidgetManager : public CM::Module<EditorWidgetManager>
+	class BS_ED_EXPORT EditorWidgetManager : public Module<EditorWidgetManager>
 	{
 	public:
 		EditorWidgetManager();
@@ -23,7 +23,7 @@ namespace BansheeEditor
 		 * @param	name				  	Unique name for the widget.
 		 * @param 	createCallback			Callback that returns a new instance of the widget.
 		 */
-		void registerWidget(const CM::String& name, std::function<EditorWidgetBase*(EditorWidgetContainer&)> createCallback);
+		void registerWidget(const String& name, std::function<EditorWidgetBase*(EditorWidgetContainer&)> createCallback);
 
 		/**
 		 * @brief	Creates a widget with the given name. If widget is already created it returns the existing instance.
@@ -33,12 +33,12 @@ namespace BansheeEditor
 		 *
 		 * @return	Always returns the created widget, and throws an exception if it fails.
 		 */
-		EditorWidgetBase* open(const CM::String& name);
+		EditorWidgetBase* open(const String& name);
 
 		/**
 		 * @brief	Creates a new widget an inserts it into the specified container.
 		 */
-		EditorWidgetBase* create(const CM::String& name, EditorWidgetContainer& parentContainer);
+		EditorWidgetBase* create(const String& name, EditorWidgetContainer& parentContainer);
 
 		/**
 		 * @brief	Closes the given widget.
@@ -64,12 +64,12 @@ namespace BansheeEditor
 		 * @note	Useful primarily when widgets are being registered from static methods, because then there is no
 		 * 			EditorWidgetManager instance yet.
 		 */
-		static void preRegisterWidget(const CM::String& name, std::function<EditorWidgetBase*(EditorWidgetContainer&)> createCallback);
+		static void preRegisterWidget(const String& name, std::function<EditorWidgetBase*(EditorWidgetContainer&)> createCallback);
 
 	private:
-		CM::Map<CM::String, EditorWidgetBase*>::type mActiveWidgets;
-		CM::Map<CM::String, std::function<EditorWidgetBase*(EditorWidgetContainer&)>>::type mCreateCallbacks;
+		Map<String, EditorWidgetBase*>::type mActiveWidgets;
+		Map<String, std::function<EditorWidgetBase*(EditorWidgetContainer&)>>::type mCreateCallbacks;
 
-		static CM::Stack<std::pair<CM::String, std::function<EditorWidgetBase*(EditorWidgetContainer&)>>>::type QueuedCreateCallbacks;
+		static Stack<std::pair<String, std::function<EditorWidgetBase*(EditorWidgetContainer&)>>>::type QueuedCreateCallbacks;
 	};
 }

BansheeEditor/Include/BsEditorWindow.h

@@ -3,7 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "BsEditorWindowBase.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class EditorWindow : public EditorWindowBase
 	{

BansheeEditor/Include/BsEditorWindowBase.h

@@ -3,21 +3,21 @@
 #include "BsEditorPrerequisites.h"
 #include <boost/signals/connection.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class EditorWindowBase
 	{
 	public:
 		virtual ~EditorWindowBase();
 
-		virtual void setPosition(CM::INT32 x, CM::INT32 y);
-		virtual void setSize(CM::UINT32 width, CM::UINT32 height);
+		virtual void setPosition(INT32 x, INT32 y);
+		virtual void setSize(UINT32 width, UINT32 height);
 
-		CM::INT32 getLeft() const;
-		CM::INT32 getTop() const;
+		INT32 getLeft() const;
+		INT32 getTop() const;
 
-		CM::UINT32 getWidth() const;
-		CM::UINT32 getHeight() const;
+		UINT32 getWidth() const;
+		UINT32 getHeight() const;
 
 		virtual void close();
 		void hide();
@@ -28,16 +28,16 @@ namespace BansheeEditor
 		virtual void update() { }
 	protected:
 		EditorWindowBase();
-		EditorWindowBase(const CM::RenderWindowPtr& renderWindow);
+		EditorWindowBase(const RenderWindowPtr& renderWindow);
 
-		CM::RenderWindowPtr mRenderWindow;
-		CM::HSceneObject mSceneObject;
-		BS::HGUIWidget mGUI;
-		BS::HCamera mCamera;
-		CM::GameObjectHandle<WindowFrameWidget> mWindowFrame;
+		RenderWindowPtr mRenderWindow;
+		HSceneObject mSceneObject;
+		HGUIWidget mGUI;
+		HCamera mCamera;
+		GameObjectHandle<WindowFrameWidget> mWindowFrame;
 		bool mOwnsRenderWindow;
 
-		void construct(const CM::RenderWindowPtr& renderWindow);
+		void construct(const RenderWindowPtr& renderWindow);
 		virtual void initialize();
 		virtual void resized() { }
 	private:

BansheeEditor/Include/BsEditorWindowManager.h

@@ -4,15 +4,15 @@
 #include "CmModule.h"
 #include <boost/signals.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class EditorWindowManager : public CM::Module<EditorWindowManager>
+	class EditorWindowManager : public Module<EditorWindowManager>
 	{
 	public:
 		EditorWindowManager();
 		~EditorWindowManager();
 
-		MainEditorWindow* createMain(const CM::RenderWindowPtr& parentRenderWindow);
+		MainEditorWindow* createMain(const RenderWindowPtr& parentRenderWindow);
 		EditorWindow* create();
 		void destroy(EditorWindowBase* window);
 
@@ -22,7 +22,7 @@ namespace BansheeEditor
 	protected:
 		MainEditorWindow* mMainWindow;
 
-		CM::Vector<EditorWindowBase*>::type mEditorWindows;
-		CM::Vector<EditorWindowBase*>::type mScheduledForDestruction;
+		Vector<EditorWindowBase*>::type mEditorWindows;
+		Vector<EditorWindowBase*>::type mScheduledForDestruction;
 	};
 }

BansheeEditor/Include/BsGUIColor.h

@@ -5,45 +5,45 @@
 #include "BsImageSprite.h"
 #include "BsGUIContent.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUIColor : public BS::GUIElement
+	class GUIColor : public GUIElement
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIColor* create(const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUIColor* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIColor* create(const String& styleName = StringUtil::BLANK);
+		static GUIColor* create(const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 
-		virtual CM::Vector2I _getOptimalSize() const;
+		virtual Vector2I _getOptimalSize() const;
 
-		void setColor(const CM::Color& color);
-		CM::Color getColor() const { return mColor; }
+		void setColor(const Color& color);
+		Color getColor() const { return mColor; }
 
 	protected:
-		GUIColor(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
+		GUIColor(const String& styleName, const GUILayoutOptions& layoutOptions);
 		virtual ~GUIColor();
 
 		/**
 		 * @copydoc GUIElement::getNumRenderElements()
 		 */
-		virtual CM::UINT32 getNumRenderElements() const;
+		virtual UINT32 getNumRenderElements() const;
 
 		/**
 		 * @copydoc GUIElement::getMaterial()
 		 */
-		virtual const BS::GUIMaterialInfo& getMaterial(CM::UINT32 renderElementIdx) const;
+		virtual const GUIMaterialInfo& getMaterial(UINT32 renderElementIdx) const;
 
 		/**
 		 * @copydoc GUIElement::getNumQuads()
 		 */
-		virtual CM::UINT32 getNumQuads(CM::UINT32 renderElementIdx) const;
+		virtual UINT32 getNumQuads(UINT32 renderElementIdx) const;
 
 		/**
 		 * @copydoc GUIElement::fillBuffer()
 		 */
-		virtual void fillBuffer(CM::UINT8* vertices, CM::UINT8* uv, CM::UINT32* indices, CM::UINT32 startingQuad, 
-			CM::UINT32 maxNumQuads, CM::UINT32 vertexStride, CM::UINT32 indexStride, CM::UINT32 renderElementIdx) const;
+		virtual void fillBuffer(UINT8* vertices, UINT8* uv, UINT32* indices, UINT32 startingQuad, 
+			UINT32 maxNumQuads, UINT32 vertexStride, UINT32 indexStride, UINT32 renderElementIdx) const;
 
 		/**
 		 * @copydoc GUIElement::updateRenderElementsInternal()
@@ -55,17 +55,17 @@ namespace BansheeEditor
 		 */
 		virtual void updateClippedBounds();
 
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
 	private:
 		static const float ALPHA_SPLIT_POSITION;
 
-		BS::ImageSprite* mColorSprite;
-		BS::ImageSprite* mAlphaSprite;
+		ImageSprite* mColorSprite;
+		ImageSprite* mAlphaSprite;
 
-		BS::IMAGE_SPRITE_DESC mColorImageDesc;
-		BS::IMAGE_SPRITE_DESC mAlphaImageDesc;
+		IMAGE_SPRITE_DESC mColorImageDesc;
+		IMAGE_SPRITE_DESC mAlphaImageDesc;
 
-		CM::Color mColor;
+		Color mColor;
 	};
 }

BansheeEditor/Include/BsGUIColorField.h

@@ -3,53 +3,53 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIElementContainer.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class BS_ED_EXPORT GUIColorField : public BS::GUIElementContainer
+	class BS_ED_EXPORT GUIColorField : public GUIElementContainer
 	{
 		struct PrivatelyConstruct {};
 
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIColorField* create(const BS::GUIContent& labelContent, 
-			const BS::GUIOptions& layoutOptions, const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& toggleStyle = CM::StringUtil::BLANK);
+		static GUIColorField* create(const GUIContent& labelContent, 
+			const GUIOptions& layoutOptions, const String& labelStyle = StringUtil::BLANK, const String& toggleStyle = StringUtil::BLANK);
 
-		static GUIColorField* create(const CM::HString& labelText, 
-			const BS::GUIOptions& layoutOptions, const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& toggleStyle = CM::StringUtil::BLANK);
+		static GUIColorField* create(const HString& labelText, 
+			const GUIOptions& layoutOptions, const String& labelStyle = StringUtil::BLANK, const String& toggleStyle = StringUtil::BLANK);
 
-		static GUIColorField* create(const BS::GUIOptions& layoutOptions, const CM::String& labelStyle = CM::StringUtil::BLANK, 
-			const CM::String& toggleStyle = CM::StringUtil::BLANK);
+		static GUIColorField* create(const GUIOptions& layoutOptions, const String& labelStyle = StringUtil::BLANK, 
+			const String& toggleStyle = StringUtil::BLANK);
 
-		static GUIColorField* create(const BS::GUIContent& labelContent, const CM::String& labelStyle = CM::StringUtil::BLANK, 
-			const CM::String& toggleStyle = CM::StringUtil::BLANK);
+		static GUIColorField* create(const GUIContent& labelContent, const String& labelStyle = StringUtil::BLANK, 
+			const String& toggleStyle = StringUtil::BLANK);
 
-		static GUIColorField* create(const CM::HString& labelText, const CM::String& labelStyle = CM::StringUtil::BLANK,
-			const CM::String& toggleStyle = CM::StringUtil::BLANK);
+		static GUIColorField* create(const HString& labelText, const String& labelStyle = StringUtil::BLANK,
+			const String& toggleStyle = StringUtil::BLANK);
 
-		static GUIColorField* create(const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& toggleStyle = CM::StringUtil::BLANK);
+		static GUIColorField* create(const String& labelStyle = StringUtil::BLANK, const String& toggleStyle = StringUtil::BLANK);
 
-		GUIColorField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, 
-			const CM::String& labelStyle, const CM::String& toggleStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
+			const String& labelStyle, const String& toggleStyle, const GUILayoutOptions& layoutOptions);
 
-		GUIColorField(const PrivatelyConstruct& dummy, const CM::String& labelStyle, const CM::String& toggleStyle, 
-			const BS::GUILayoutOptions& layoutOptions);
+		GUIColorField(const PrivatelyConstruct& dummy, const String& labelStyle, const String& toggleStyle, 
+			const GUILayoutOptions& layoutOptions);
 
-		CM::Color getValue() const;
-		void setValue(const CM::Color& value);
+		Color getValue() const;
+		void setValue(const Color& value);
 
-		void setLabelWidth(CM::UINT32 width);
+		void setLabelWidth(UINT32 width);
 
-		void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 
-		CM::Vector2I _getOptimalSize() const;
+		Vector2I _getOptimalSize() const;
 	protected:
 		virtual ~GUIColorField();
 
 	protected:
-		CM::UINT32 mLabelWidth;
-		BS::GUILabel* mLabel;
+		UINT32 mLabelWidth;
+		GUILabel* mLabel;
 		GUIColor* mColor;
 	};
 }

BansheeEditor/Include/BsGUIDockSlider.h

@@ -5,27 +5,27 @@
 #include "BsDockManager.h"
 #include "boost/signal.hpp"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUIDockSlider : public BS::GUIButtonBase
+	class GUIDockSlider : public GUIButtonBase
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIDockSlider* create(bool horizontal, const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUIDockSlider* create(bool horizontal, const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIDockSlider* create(bool horizontal, const String& styleName = StringUtil::BLANK);
+		static GUIDockSlider* create(bool horizontal, const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 
-		boost::signal<void(const CM::Vector2I&)> onDragged;
+		boost::signal<void(const Vector2I&)> onDragged;
 	protected:
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
-		bool _hasCustomCursor(const CM::Vector2I position, BS::CursorType& type) const;
+		bool _hasCustomCursor(const Vector2I position, CursorType& type) const;
 	private:
-		CM::Vector2I mLastDragPosition;
+		Vector2I mLastDragPosition;
 		bool mHorizontal;
 		bool mIsCursorSet;
 		bool mDragInProgress;
 
-		GUIDockSlider(bool horizontal, const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
+		GUIDockSlider(bool horizontal, const String& styleName, const GUILayoutOptions& layoutOptions);
 	};
 }

BansheeEditor/Include/BsGUIDropButton.h

@@ -8,26 +8,26 @@
 #include "BsGUIContent.h"
 #include "boost/signal.hpp"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUIDropButton : public BS::GUIButtonBase
+	class GUIDropButton : public GUIButtonBase
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIDropButton* create(CM::UINT32 dragType, const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUIDropButton* create(CM::UINT32 dragType, const BS::GUIOptions& layoutOptions, 
-			const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIDropButton* create(UINT32 dragType, const String& styleName = StringUtil::BLANK);
+		static GUIDropButton* create(UINT32 dragType, const GUIOptions& layoutOptions, 
+			const String& styleName = StringUtil::BLANK);
 
 		boost::signal<void(void*)> onDataDropped;
 	protected:
 		virtual ~GUIDropButton();
 
 	protected:
-		GUIDropButton(CM::UINT32 dragType, const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
+		GUIDropButton(UINT32 dragType, const String& styleName, const GUILayoutOptions& layoutOptions);
 
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
-		CM::UINT32 mDragType;
+		UINT32 mDragType;
 	};
 }

BansheeEditor/Include/BsGUIFieldBase.h

@@ -3,105 +3,105 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIElementContainer.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class BS_ED_EXPORT GUIFieldBase : public BS::GUIElementContainer
+	class BS_ED_EXPORT GUIFieldBase : public GUIElementContainer
 	{
 	protected:
 		struct PrivatelyConstruct {};
 
 	public:
-		GUIFieldBase(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIFieldBase(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 
-		CM::Vector2I _getOptimalSize() const;
+		Vector2I _getOptimalSize() const;
 	protected:
 		virtual ~GUIFieldBase() { }
 
 	protected:
-		static const CM::UINT32 DEFAULT_LABEL_WIDTH;
+		static const UINT32 DEFAULT_LABEL_WIDTH;
 
-		BS::GUILayout* mLayout;
-		BS::GUILabel* mLabel;
+		GUILayout* mLayout;
+		GUILabel* mLabel;
 	};
 
 	template <class T>
 	class TGUIField : public GUIFieldBase
 	{
 	public:
-		static T* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const GUIContent& labelContent, UINT32 labelWidth, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(layoutOptions), true);
 		}
 
-		static T* create(const BS::GUIContent& labelContent, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const GUIContent& labelContent, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(layoutOptions), true);
 		}
 
-		static T* create(const CM::HString& labelText, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const HString& labelText, UINT32 labelWidth, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
-			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, entryElementStyle, 
+			return cm_new<T>(PrivatelyConstruct(), GUIContent(labelText), labelWidth, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(layoutOptions), true);
 		}
 
-		static T* create(const CM::HString& labelText, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const HString& labelText, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
-			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
+			return cm_new<T>(PrivatelyConstruct(), GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(layoutOptions), true);
 		}
 
-		static T* create(const BS::GUIOptions& layoutOptions, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const GUIOptions& layoutOptions, const String& entryElementStyle = StringUtil::BLANK)
 		{
-			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, entryElementStyle, 
+			return cm_new<T>(PrivatelyConstruct(), GUIContent(), 0, nullptr, entryElementStyle, 
 				GUILayoutOptions::create(layoutOptions), false);
 		}
 
-		static T* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const GUIContent& labelContent, UINT32 labelWidth, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(), true);
 		}
 
-		static T* create(const BS::GUIContent& labelContent, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const GUIContent& labelContent, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
 			return cm_new<T>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(), true);
 		}
 
-		static T* create(const CM::HString& labelText, CM::UINT32 labelWidth, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const HString& labelText, UINT32 labelWidth, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
-			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, entryElementStyle, 
+			return cm_new<T>(PrivatelyConstruct(), GUIContent(labelText), labelWidth, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(), true);
 		}
 
-		static T* create(const CM::HString& labelText, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const HString& labelText, 
+			const String& labelStyle = StringUtil::BLANK, const String& entryElementStyle = StringUtil::BLANK)
 		{
-			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
+			return cm_new<T>(PrivatelyConstruct(), GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, entryElementStyle, 
 				GUILayoutOptions::create(), true);
 		}
 
-		static T* create(const CM::String& entryElementStyle = CM::StringUtil::BLANK)
+		static T* create(const String& entryElementStyle = StringUtil::BLANK)
 		{
-			return cm_new<T>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, entryElementStyle, 
+			return cm_new<T>(PrivatelyConstruct(), GUIContent(), 0, nullptr, entryElementStyle, 
 				GUILayoutOptions::create(), false);
 		}
 
-		TGUIField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel)
+		TGUIField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 			:GUIFieldBase(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel)
 		{ }
 	};

BansheeEditor/Include/BsGUIFloatField.h

@@ -3,15 +3,15 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIFieldBase.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUIFloatField : public TGUIField<GUIFloatField>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUIFloatField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIFloatField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
 		float getValue() const;
 		void setValue(float value);
@@ -24,13 +24,13 @@ namespace BansheeEditor
 	protected:
 		static const float DRAG_SPEED;
 
-		BS::GUIInputBox* mInputBox;
-		CM::INT32 mLastDragPos;
+		GUIInputBox* mInputBox;
+		INT32 mLastDragPos;
 		bool mIsDragging;
 
-		bool _hasCustomCursor(const CM::Vector2I position, BS::CursorType& type) const;
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		bool _hasCustomCursor(const Vector2I position, CursorType& type) const;
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
-		static bool floatFilter(const CM::WString& str);
+		static bool floatFilter(const WString& str);
 	};
 }

BansheeEditor/Include/BsGUIFoldout.h

@@ -3,42 +3,42 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIElementContainer.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class BS_ED_EXPORT GUIFoldout : public BS::GUIElementContainer
+	class BS_ED_EXPORT GUIFoldout : public GUIElementContainer
 	{
 		struct PrivatelyConstruct {};
 
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIFoldout* create(const BS::GUIOptions& layoutOptions, 
-			const CM::String& toggleStyle = CM::StringUtil::BLANK, const CM::String& backgroundStyle = CM::StringUtil::BLANK);
+		static GUIFoldout* create(const GUIOptions& layoutOptions, 
+			const String& toggleStyle = StringUtil::BLANK, const String& backgroundStyle = StringUtil::BLANK);
 
-		static GUIFoldout* create(const CM::String& toggleStyle = CM::StringUtil::BLANK,
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK);
+		static GUIFoldout* create(const String& toggleStyle = StringUtil::BLANK,
+			const String& backgroundStyle = StringUtil::BLANK);
 
-		GUIFoldout(const PrivatelyConstruct& dummy, const CM::String& toggleStyle, 
-			const CM::String& backgroundStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUIFoldout(const PrivatelyConstruct& dummy, const String& toggleStyle, 
+			const String& backgroundStyle, const GUILayoutOptions& layoutOptions);
 
 		bool isExpanded() const { return mIsExpanded; }
 		void setExpanded(bool expanded);
 
-		void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 
-		CM::Vector2I _getOptimalSize() const;
+		Vector2I _getOptimalSize() const;
 
 		boost::signal<void(bool)> onStateChanged;
 	protected:
 		virtual ~GUIFoldout();
 
 	protected:
-		static const CM::String FOLDOUT_BUTTON_STYLE;
-		static const CM::String FOLDOUT_BG_STYLE;
+		static const String FOLDOUT_BUTTON_STYLE;
+		static const String FOLDOUT_BG_STYLE;
 
-		BS::GUIToggle* mToggle;
-		BS::GUITexture* mBackground;
+		GUIToggle* mToggle;
+		GUITexture* mBackground;
 
 		bool mIsExpanded;
 	};

BansheeEditor/Include/BsGUIGameObjectField.h

@@ -3,79 +3,79 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIElementContainer.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class BS_ED_EXPORT GUIGameObjectField : public BS::GUIElementContainer
+	class BS_ED_EXPORT GUIGameObjectField : public GUIElementContainer
 	{
 		struct PrivatelyConstruct {};
 
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIGameObjectField* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const GUIContent& labelContent, UINT32 labelWidth, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const BS::GUIContent& labelContent, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const GUIContent& labelContent, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const CM::HString& labelText, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const HString& labelText, UINT32 labelWidth, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const CM::HString& labelText, const BS::GUIOptions& layoutOptions, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const HString& labelText, const GUIOptions& layoutOptions, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const BS::GUIOptions& layoutOptions, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const GUIOptions& layoutOptions, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const GUIContent& labelContent, UINT32 labelWidth, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const BS::GUIContent& labelContent, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const GUIContent& labelContent, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const CM::HString& labelText, CM::UINT32 labelWidth, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const HString& labelText, UINT32 labelWidth, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const CM::HString& labelText, 
-			const CM::String& labelStyle = CM::StringUtil::BLANK, const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const HString& labelText, 
+			const String& labelStyle = StringUtil::BLANK, const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		static GUIGameObjectField* create(const CM::String& dropButtonStyle = CM::StringUtil::BLANK,
-			const CM::String& clearButtonStyle = CM::StringUtil::BLANK);
+		static GUIGameObjectField* create(const String& dropButtonStyle = StringUtil::BLANK,
+			const String& clearButtonStyle = StringUtil::BLANK);
 
-		GUIGameObjectField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, 
-			CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& dropButtonStyle,
-			const CM::String& clearButtonStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIGameObjectField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
+			UINT32 labelWidth, const String& labelStyle, const String& dropButtonStyle,
+			const String& clearButtonStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		CM::HGameObject getValue() const;
-		void setValue(const CM::HGameObject& value);
+		HGameObject getValue() const;
+		void setValue(const HGameObject& value);
 
-		void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 
-		CM::Vector2I _getOptimalSize() const;
+		Vector2I _getOptimalSize() const;
 	private:
 		virtual ~GUIGameObjectField();
 
 		void dataDropped(void* data);
 
 	private:
-		static const CM::UINT32 DEFAULT_LABEL_WIDTH;
-		static const CM::String DROP_BUTTON_STYLE;
-		static const CM::String CLEAR_BUTTON_STYLE;
+		static const UINT32 DEFAULT_LABEL_WIDTH;
+		static const String DROP_BUTTON_STYLE;
+		static const String CLEAR_BUTTON_STYLE;
 
-		BS::GUILayout* mLayout;
-		BS::GUILabel* mLabel;
+		GUILayout* mLayout;
+		GUILabel* mLabel;
 		GUIDropButton* mDropButton;
-		BS::GUIButton* mClearButton;
+		GUIButton* mClearButton;
 
-		CM::UINT64 mInstanceId;
+		UINT64 mInstanceId;
 	};
 }

BansheeEditor/Include/BsGUIIntField.h

@@ -3,18 +3,18 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIFieldBase.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUIIntField : public TGUIField<GUIIntField>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUIIntField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIIntField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		CM::INT32 getValue() const;
-		void setValue(CM::INT32 value);
+		INT32 getValue() const;
+		void setValue(INT32 value);
 
 	protected:
 		virtual ~GUIIntField();
@@ -22,16 +22,16 @@ namespace BansheeEditor
 		void updateClippedBounds();
 
 	protected:
-		static const CM::INT32 DRAG_SPEED;
+		static const INT32 DRAG_SPEED;
 
-		BS::GUIInputBox* mInputBox;
-		CM::INT32 mLastDragPos;
+		GUIInputBox* mInputBox;
+		INT32 mLastDragPos;
 		bool mIsDragging;
 		bool mIsDragCursorSet;
 
-		bool _hasCustomCursor(const CM::Vector2I position, BS::CursorType& type) const;
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		bool _hasCustomCursor(const Vector2I position, CursorType& type) const;
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
-		static bool intFilter(const CM::WString& str);
+		static bool intFilter(const WString& str);
 	};
 }

BansheeEditor/Include/BsGUIMenuBar.h

@@ -2,49 +2,49 @@
 
 #include "BsEditorPrerequisites.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class GUIMenuBar
 	{
 		struct GUIMenuBarData
 		{
-			CM::WString name;
-			BS::GUIMenu* menu;
-			BS::GUIButton* button;
+			WString name;
+			GUIMenu* menu;
+			GUIButton* button;
 		};
 
 	public:
-		GUIMenuBar(BS::GUIWidget* parent, CM::RenderWindow* parentWindow);
+		GUIMenuBar(GUIWidget* parent, RenderWindow* parentWindow);
 		virtual ~GUIMenuBar();
 
-		void setArea(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
+		void setArea(INT32 x, INT32 y, UINT32 width, UINT32 height);
 
-		const BS::GUIMenuItem* addMenuItem(const CM::WString& path, std::function<void()> callback);
-		const BS::GUIMenuItem* addSeparator(const CM::WString& path);
-		const BS::GUIMenuItem* getMenuItem(const CM::WString& path) const;
-		void removeMenuItem(const CM::WString& path);
+		const GUIMenuItem* addMenuItem(const WString& path, std::function<void()> callback);
+		const GUIMenuItem* addSeparator(const WString& path);
+		const GUIMenuItem* getMenuItem(const WString& path) const;
+		void removeMenuItem(const WString& path);
 	private:
-		static const CM::UINT32 NUM_ELEMENTS_AFTER_CONTENT;
+		static const UINT32 NUM_ELEMENTS_AFTER_CONTENT;
 
-		CM::RenderWindow* mParentWindow;
-		BS::GUIWidget* mParentWidget;
-		BS::GUIArea* mMainArea;
-		BS::GUIArea* mBackgroundArea;
-		BS::GUITexture* mBgTexture;
-		BS::GUITexture* mLogoTexture;
+		RenderWindow* mParentWindow;
+		GUIWidget* mParentWidget;
+		GUIArea* mMainArea;
+		GUIArea* mBackgroundArea;
+		GUITexture* mBgTexture;
+		GUITexture* mLogoTexture;
 
-		BS::GUIButton* mMinBtn;
-		BS::GUIButton* mMaxBtn;
-		BS::GUIButton* mCloseBtn;
+		GUIButton* mMinBtn;
+		GUIButton* mMaxBtn;
+		GUIButton* mCloseBtn;
 
-		CM::Vector<GUIMenuBarData>::type mChildMenus;
+		Vector<GUIMenuBarData>::type mChildMenus;
 
-		BS::GUIButton* mSubMenuButton;
+		GUIButton* mSubMenuButton;
 		bool mSubMenuOpen;
 
-		const GUIMenuBarData* getSubMenu(const CM::WString& name) const;
+		const GUIMenuBarData* getSubMenu(const WString& name) const;
 
-		GUIMenuBarData* addNewButton(const CM::WString& name);
+		GUIMenuBarData* addNewButton(const WString& name);
 
 		/**
 		 * @brief	Attempts to remove the first element from the specified path. First element
@@ -53,12 +53,12 @@ namespace BansheeEditor
 		 *
 		 * @return	False if first element doesn't exist, true otherwise.
 		 */
-		bool stripPath(CM::WString& path, CM::WString& pathRoot) const;
+		bool stripPath(WString& path, WString& pathRoot) const;
 
-		void openSubMenu(const CM::WString& name);
+		void openSubMenu(const WString& name);
 		void closeSubMenu();
 
-		void onSubMenuHover(const CM::WString& name);
+		void onSubMenuHover(const WString& name);
 		void onSubMenuClosed();
 
 		void onMinimizeClicked();

BansheeEditor/Include/BsGUIResourceTreeView.h

@@ -5,44 +5,44 @@
 #include "BsProjectLibrary.h"
 #include <boost/signal.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class GUIResourceTreeView : public GUITreeView
 	{
 		struct ResourceTreeElement : public GUITreeView::TreeElement
 		{
-			CM::WString mFullPath;
-			CM::WString mElementName;
+			WString mFullPath;
+			WString mElementName;
 		};
 
 		struct DraggedResources
 		{
-			CM::Vector<CM::String>::type resourceUUIDs;
+			Vector<String>::type resourceUUIDs;
 		};
 
 		struct InternalDraggedResources
 		{
-			InternalDraggedResources(CM::UINT32 numObjects);
+			InternalDraggedResources(UINT32 numObjects);
 			~InternalDraggedResources();
 
-			CM::UINT32 numObjects;
-			CM::WString* resourcePaths;
+			UINT32 numObjects;
+			WString* resourcePaths;
 		};
 
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
 		static GUIResourceTreeView* create(
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
-			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
-			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
-			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
+			const String& backgroundStyle = StringUtil::BLANK, const String& elementBtnStyle = StringUtil::BLANK, 
+			const String& foldoutBtnStyle = StringUtil::BLANK, const String& selectionBackgroundStyle = StringUtil::BLANK,
+			const String& editBoxStyle = StringUtil::BLANK, const String& dragHighlightStyle = StringUtil::BLANK, 
+			const String& dragSepHighlightStyle = StringUtil::BLANK);
 
-		static GUIResourceTreeView* create(const BS::GUIOptions& options, 
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
-			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
-			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
-			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
+		static GUIResourceTreeView* create(const GUIOptions& options, 
+			const String& backgroundStyle = StringUtil::BLANK, const String& elementBtnStyle = StringUtil::BLANK, 
+			const String& foldoutBtnStyle = StringUtil::BLANK, const String& selectionBackgroundStyle = StringUtil::BLANK,
+			const String& editBoxStyle = StringUtil::BLANK, const String& dragHighlightStyle = StringUtil::BLANK, 
+			const String& dragSepHighlightStyle = StringUtil::BLANK);
 
 
 	protected:
@@ -51,8 +51,8 @@ namespace BansheeEditor
 	protected:
 		InternalDraggedResources* mDraggedResources;
 		ResourceTreeElement mRootElement;
-		CM::RenderWindow* mCurrentWindow;
-		CM::OSDropTarget* mDropTarget;
+		RenderWindow* mCurrentWindow;
+		OSDropTarget* mDropTarget;
 		bool mDropTargetDragActive;
 
 		boost::signals::connection mDropTargetEnterConn;
@@ -60,43 +60,43 @@ namespace BansheeEditor
 		boost::signals::connection mDropTargetLeaveConn;
 		boost::signals::connection mDropTargetDroppedConn;
 
-		GUIResourceTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-			const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
-			const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUIResourceTreeView(const String& backgroundStyle, const String& elementBtnStyle, 
+			const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, 
+			const String& dragHighlightStyle, const String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions);
 
-		virtual void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		virtual void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 
 		virtual TreeElement& getRootElement() { return mRootElement; }
 		virtual const TreeElement& getRootElementConst() const { return mRootElement; }
 		virtual void updateTreeElementHierarchy();
-		virtual void renameTreeElement(TreeElement* element, const CM::WString& name);
+		virtual void renameTreeElement(TreeElement* element, const WString& name);
 		virtual void deleteTreeElement(TreeElement* element);
 		virtual bool acceptDragAndDrop() const;
 		virtual void dragAndDropStart();
 		virtual void dragAndDropEnded(TreeElement* overTreeElement);
 		virtual void dragAndDropFinalize();
-		virtual bool _acceptDragAndDrop(const CM::Vector2I position, CM::UINT32 typeId) const;
+		virtual bool _acceptDragAndDrop(const Vector2I position, UINT32 typeId) const;
 
 		void updateFromProjectLibraryEntry(ResourceTreeElement* treeElement, const ProjectLibrary::LibraryEntry* libraryEntry);
-		ResourceTreeElement* addTreeElement(ResourceTreeElement* parent, const CM::WString& fullPath);
+		ResourceTreeElement* addTreeElement(ResourceTreeElement* parent, const WString& fullPath);
 		void deleteTreeElement(ResourceTreeElement* element);
 		void sortTreeElement(ResourceTreeElement* element);
 
-		ResourceTreeElement* findTreeElement(const CM::WString& fullPath);
+		ResourceTreeElement* findTreeElement(const WString& fullPath);
 
-		void entryAdded(const CM::WString& path);
-		void entryRemoved(const CM::WString& path);
+		void entryAdded(const WString& path);
+		void entryRemoved(const WString& path);
 
-		void setDropTarget(CM::RenderWindow* parentWindow, CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height);
+		void setDropTarget(RenderWindow* parentWindow, INT32 x, INT32 y, UINT32 width, UINT32 height);
 		void clearDropTarget();
 
-		void dropTargetDragMove(CM::INT32 x, CM::INT32 y);
+		void dropTargetDragMove(INT32 x, INT32 y);
 		void dropTargetDragLeave();
-		void dropTargetDragDropped(CM::INT32 x, CM::INT32 y);
+		void dropTargetDragDropped(INT32 x, INT32 y);
 
-		CM::WString findUniquePath(const CM::WString& path);
+		WString findUniquePath(const WString& path);
 
-		void _changeParentWidget(BS::GUIWidget* widget);
+		void _changeParentWidget(GUIWidget* widget);
 	};
 }

BansheeEditor/Include/BsGUISceneTreeView.h

@@ -4,15 +4,15 @@
 #include "BsGUITreeView.h"
 #include <boost/signal.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	struct DraggedSceneObjects
 	{
-		DraggedSceneObjects(CM::UINT32 numObjects);
+		DraggedSceneObjects(UINT32 numObjects);
 		~DraggedSceneObjects();
 
-		CM::UINT32 numObjects;
-		CM::HSceneObject* objects;
+		UINT32 numObjects;
+		HSceneObject* objects;
 	};
 
 	class GUISceneTreeView : public GUITreeView
@@ -23,24 +23,24 @@ namespace BansheeEditor
 				:mId(0)
 			{ }
 
-			CM::HSceneObject mSceneObject;
-			CM::UINT64 mId;
+			HSceneObject mSceneObject;
+			UINT64 mId;
 		};
 
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
 		static GUISceneTreeView* create(
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
-			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
-			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
-			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
+			const String& backgroundStyle = StringUtil::BLANK, const String& elementBtnStyle = StringUtil::BLANK, 
+			const String& foldoutBtnStyle = StringUtil::BLANK, const String& selectionBackgroundStyle = StringUtil::BLANK,
+			const String& editBoxStyle = StringUtil::BLANK, const String& dragHighlightStyle = StringUtil::BLANK, 
+			const String& dragSepHighlightStyle = StringUtil::BLANK);
 
-		static GUISceneTreeView* create(const BS::GUIOptions& options, 
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& elementBtnStyle = CM::StringUtil::BLANK, 
-			const CM::String& foldoutBtnStyle = CM::StringUtil::BLANK, const CM::String& selectionBackgroundStyle = CM::StringUtil::BLANK,
-			const CM::String& editBoxStyle = CM::StringUtil::BLANK, const CM::String& dragHighlightStyle = CM::StringUtil::BLANK, 
-			const CM::String& dragSepHighlightStyle = CM::StringUtil::BLANK);
+		static GUISceneTreeView* create(const GUIOptions& options, 
+			const String& backgroundStyle = StringUtil::BLANK, const String& elementBtnStyle = StringUtil::BLANK, 
+			const String& foldoutBtnStyle = StringUtil::BLANK, const String& selectionBackgroundStyle = StringUtil::BLANK,
+			const String& editBoxStyle = StringUtil::BLANK, const String& dragHighlightStyle = StringUtil::BLANK, 
+			const String& dragSepHighlightStyle = StringUtil::BLANK);
 
 
 	protected:
@@ -49,22 +49,22 @@ namespace BansheeEditor
 	protected:
 		SceneTreeElement mRootElement;
 
-		GUISceneTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-			const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
-			const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUISceneTreeView(const String& backgroundStyle, const String& elementBtnStyle, 
+			const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, 
+			const String& dragHighlightStyle, const String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions);
 
 		void updateTreeElement(SceneTreeElement* element);
 
 		virtual TreeElement& getRootElement() { return mRootElement; }
 		virtual const TreeElement& getRootElementConst() const { return mRootElement; }
 		virtual void updateTreeElementHierarchy();
-		virtual void renameTreeElement(TreeElement* element, const CM::WString& name);
+		virtual void renameTreeElement(TreeElement* element, const WString& name);
 		virtual void deleteTreeElement(TreeElement* element);
 		virtual bool acceptDragAndDrop() const;
 		virtual void dragAndDropStart();
 		virtual void dragAndDropEnded(TreeElement* overTreeElement);
 		virtual void dragAndDropFinalize();
-		virtual bool _acceptDragAndDrop(const CM::Vector2I position, CM::UINT32 typeId) const;
+		virtual bool _acceptDragAndDrop(const Vector2I position, UINT32 typeId) const;
 
 		void deleteTreeElementInternal(TreeElement* element);
 	};

BansheeEditor/Include/BsGUITabButton.h

@@ -6,39 +6,39 @@
 #include "BsImageSprite.h"
 #include "boost/signal.hpp"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUITabButton : public BS::GUIToggle
+	class GUITabButton : public GUIToggle
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const CM::HString& text, 
-			const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const CM::HString& text, 
-			const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUITabButton* create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, const HString& text, 
+			const String& styleName = StringUtil::BLANK);
+		static GUITabButton* create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, const HString& text, 
+			const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 	
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, 
-			const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUITabButton* create(const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, 
-			const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUITabButton* create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, const GUIContent& content, 
+			const String& styleName = StringUtil::BLANK);
+		static GUITabButton* create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, const GUIContent& content, 
+			const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 
-		CM::UINT32 getIndex() const { return mIndex; }
+		UINT32 getIndex() const { return mIndex; }
 		void _setDraggedState(bool active);
 
-		boost::signal<void(CM::UINT32, const CM::Vector2I&)> onDragged;
-		boost::signal<void(CM::UINT32, const CM::Vector2I&)> onDragEnd;
+		boost::signal<void(UINT32, const Vector2I&)> onDragged;
+		boost::signal<void(UINT32, const Vector2I&)> onDragEnd;
 	protected:
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
 	private:
-		CM::UINT32 mIndex;
-		CM::Vector2I mDragStartPosition;
+		UINT32 mIndex;
+		Vector2I mDragStartPosition;
 		bool mDraggedState;
-		BS::GUIButtonState mInactiveState;
+		GUIButtonState mInactiveState;
 
-		static const CM::UINT32 DRAG_MIN_DISTANCE;
+		static const UINT32 DRAG_MIN_DISTANCE;
 
-		GUITabButton(const CM::String& styleName, const BS::GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, const BS::GUIContent& content, const BS::GUILayoutOptions& layoutOptions);
+		GUITabButton(const String& styleName, const GUIToggleGroupPtr& toggleGroup, UINT32 index, const GUIContent& content, const GUILayoutOptions& layoutOptions);
 	};
 }

BansheeEditor/Include/BsGUITabbedTitleBar.h

@@ -5,82 +5,82 @@
 #include "CmRectI.h"
 #include <boost/signal.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUITabbedTitleBar : public BS::GUIElementContainer
+	class GUITabbedTitleBar : public GUIElementContainer
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUITabbedTitleBar* create(CM::RenderWindow* parentWindow,
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& tabBtnStyle = CM::StringUtil::BLANK, 
-			const CM::String& minBtnStyle = CM::StringUtil::BLANK, const CM::String& closeBtnStyle = CM::StringUtil::BLANK);
+		static GUITabbedTitleBar* create(RenderWindow* parentWindow,
+			const String& backgroundStyle = StringUtil::BLANK, const String& tabBtnStyle = StringUtil::BLANK, 
+			const String& minBtnStyle = StringUtil::BLANK, const String& closeBtnStyle = StringUtil::BLANK);
 
-		static GUITabbedTitleBar* create(CM::RenderWindow* parentWindow, const BS::GUILayoutOptions& layoutOptions, 
-			const CM::String& backgroundStyle = CM::StringUtil::BLANK, const CM::String& tabBtnStyle = CM::StringUtil::BLANK, 
-			const CM::String& minBtnStyle = CM::StringUtil::BLANK, const CM::String& closeBtnStyle = CM::StringUtil::BLANK);
+		static GUITabbedTitleBar* create(RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions, 
+			const String& backgroundStyle = StringUtil::BLANK, const String& tabBtnStyle = StringUtil::BLANK, 
+			const String& minBtnStyle = StringUtil::BLANK, const String& closeBtnStyle = StringUtil::BLANK);
 
-		void addTab(const CM::HString& name);
-		CM::UINT32 insertTab(CM::UINT32 position, const CM::HString& name);
-		void removeTab(CM::UINT32 uniqueIdx);
-		void setActive(CM::UINT32 uniqueIdx);
-		CM::UINT32 getTabIdx(CM::UINT32 position) const;
-		CM::UINT32 getNumTabs() const { return (CM::UINT32)mTabButtons.size(); }
+		void addTab(const HString& name);
+		UINT32 insertTab(UINT32 position, const HString& name);
+		void removeTab(UINT32 uniqueIdx);
+		void setActive(UINT32 uniqueIdx);
+		UINT32 getTabIdx(UINT32 position) const;
+		UINT32 getNumTabs() const { return (UINT32)mTabButtons.size(); }
 
-		CM::Vector<CM::RectI>::type calcDraggableAreas(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height) const;
+		Vector<RectI>::type calcDraggableAreas(INT32 x, INT32 y, UINT32 width, UINT32 height) const;
 
-		boost::signal<void(CM::UINT32)> onTabActivated;
-		boost::signal<void(CM::UINT32)> onTabClosed;
-		boost::signal<void(CM::UINT32)> onTabDraggedOff;
-		boost::signal<void(CM::UINT32)> onTabDraggedOn;
+		boost::signal<void(UINT32)> onTabActivated;
+		boost::signal<void(UINT32)> onTabClosed;
+		boost::signal<void(UINT32)> onTabDraggedOff;
+		boost::signal<void(UINT32)> onTabDraggedOn;
 
 	protected:
 		virtual ~GUITabbedTitleBar();
 
 		void updateClippedBounds();
 
-		void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 	protected:
-		static const CM::UINT32 TAB_SPACING;
-		static const CM::UINT32 OPTION_BTN_SPACING;
+		static const UINT32 TAB_SPACING;
+		static const UINT32 OPTION_BTN_SPACING;
 
-		CM::Vector<GUITabButton*>::type mTabButtons;
+		Vector<GUITabButton*>::type mTabButtons;
 
-		CM::UINT32 mUniqueTabIdx;
-		CM::UINT32 mActiveTabIdx;
-		BS::GUITexture* mBackgroundImage;
-		BS::GUIButton* mMinBtn;
-		BS::GUIButton* mCloseBtn;
-		BS::GUIToggleGroupPtr mTabToggleGroup;
-		CM::RenderWindow* mParentWindow;
+		UINT32 mUniqueTabIdx;
+		UINT32 mActiveTabIdx;
+		GUITexture* mBackgroundImage;
+		GUIButton* mMinBtn;
+		GUIButton* mCloseBtn;
+		GUIToggleGroupPtr mTabToggleGroup;
+		RenderWindow* mParentWindow;
 
 		EditorWidgetBase* mTempDraggedWidget;
-		CM::UINT32 mTempDraggedTabIdx;
+		UINT32 mTempDraggedTabIdx;
 
 		bool mDragInProgress;
 		GUITabButton* mDraggedBtn;
-		CM::INT32 mDragBtnOffset;
-		CM::INT32 mInitialDragOffset;
+		INT32 mDragBtnOffset;
+		INT32 mInitialDragOffset;
 
-		CM::String mBackgroundStyle;
-		CM::String mCloseBtnStyle;
-		CM::String mMinimizeBtnStyle;
-		CM::String mTabBtnStyle;
+		String mBackgroundStyle;
+		String mCloseBtnStyle;
+		String mMinimizeBtnStyle;
+		String mTabBtnStyle;
 
-		GUITabbedTitleBar(CM::RenderWindow* parentWindow, const CM::String& backgroundStyle, const CM::String& tabBtnStyle, 
-			const CM::String& minBtnStyle, const CM::String& closeBtnStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUITabbedTitleBar(RenderWindow* parentWindow, const String& backgroundStyle, const String& tabBtnStyle, 
+			const String& minBtnStyle, const String& closeBtnStyle, const GUILayoutOptions& layoutOptions);
 
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 
-		void startDrag(CM::UINT32 seqIdx, const CM::Vector2I& startDragPos);
+		void startDrag(UINT32 seqIdx, const Vector2I& startDragPos);
 		void endDrag();
 
-		void tabToggled(CM::UINT32 tabIdx, bool toggledOn);
+		void tabToggled(UINT32 tabIdx, bool toggledOn);
 		void tabClosed();
-		void tabDragged(CM::UINT32 tabIdx, const CM::Vector2I& dragPos);
-		void tabDragEnd(CM::UINT32 tabIdx, const CM::Vector2I& dragPos);
+		void tabDragged(UINT32 tabIdx, const Vector2I& dragPos);
+		void tabDragEnd(UINT32 tabIdx, const Vector2I& dragPos);
 
-		CM::INT32 uniqueIdxToSeqIdx(CM::UINT32 uniqueIdx) const;
+		INT32 uniqueIdxToSeqIdx(UINT32 uniqueIdx) const;
 	};
 }

BansheeEditor/Include/BsGUITextField.h

@@ -3,22 +3,22 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIFieldBase.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUITextField : public TGUIField<GUITextField>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUITextField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUITextField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		CM::WString getValue() const;
-		void setValue(const CM::WString& value);
+		WString getValue() const;
+		void setValue(const WString& value);
 	protected:
 		virtual ~GUITextField();
 
 	protected:
-		BS::GUIInputBox* mInputBox;
+		GUIInputBox* mInputBox;
 	};
 }

BansheeEditor/Include/BsGUIToggleField.h

@@ -3,15 +3,15 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIFieldBase.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUIToggleField : public TGUIField<GUIToggleField>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUIToggleField(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& toggleStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIToggleField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& toggleStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
 		bool getValue() const;
 		void setValue(bool value);
@@ -20,6 +20,6 @@ namespace BansheeEditor
 		virtual ~GUIToggleField() { }
 
 	protected:
-		BS::GUIToggle* mToggle;
+		GUIToggle* mToggle;
 	};
 }

BansheeEditor/Include/BsGUITreeView.h

@@ -5,9 +5,9 @@
 #include "BsVirtualInput.h"
 #include <boost/signal.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUITreeView : public BS::GUIElementContainer
+	class GUITreeView : public GUIElementContainer
 	{
 	protected:
 		enum class ScrollState
@@ -25,14 +25,14 @@ namespace BansheeEditor
 			virtual ~TreeElement();
 
 			TreeElement* mParent;
-			CM::Vector<TreeElement*>::type mChildren;
+			Vector<TreeElement*>::type mChildren;
 
-			BS::GUIToggle* mFoldoutBtn;
-			BS::GUILabel* mElement;
+			GUIToggle* mFoldoutBtn;
+			GUILabel* mElement;
 
-			CM::String mName;
+			String mName;
 
-			CM::UINT32 mSortedIdx;
+			UINT32 mSortedIdx;
 			bool mIsExpanded;
 			bool mIsSelected;
 			bool mIsVisible;
@@ -42,7 +42,7 @@ namespace BansheeEditor
 
 		struct InteractableElement
 		{
-			InteractableElement(TreeElement* parent, CM::UINT32 index, const CM::RectI& bounds)
+			InteractableElement(TreeElement* parent, UINT32 index, const RectI& bounds)
 				:parent(parent), index(index), bounds(bounds)
 			{ }
 
@@ -50,98 +50,98 @@ namespace BansheeEditor
 			TreeElement* getTreeElement() const;
 
 			TreeElement* parent;
-			CM::UINT32 index;
-			CM::RectI bounds;
+			UINT32 index;
+			RectI bounds;
 		};
 
 		struct SelectedElement
 		{
-			SelectedElement(TreeElement* elem, BS::GUITexture* back)
+			SelectedElement(TreeElement* elem, GUITexture* back)
 				:element(elem), background(back)
 			{ }
 
 			TreeElement* element;
-			BS::GUITexture* background;
+			GUITexture* background;
 		};
 
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
 		void update();
 
 	protected:
 		virtual ~GUITreeView();
 
-		CM::Vector2I _getOptimalSize() const;
+		Vector2I _getOptimalSize() const;
 		void updateClippedBounds();
 
-		virtual void _updateLayoutInternal(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height,
-			CM::RectI clipRect, CM::UINT8 widgetDepth, CM::UINT16 areaDepth);
+		virtual void _updateLayoutInternal(INT32 x, INT32 y, UINT32 width, UINT32 height,
+			RectI clipRect, UINT8 widgetDepth, UINT16 areaDepth);
 	protected:
-		static const CM::UINT32 ELEMENT_EXTRA_SPACING;
-		static const CM::UINT32 INDENT_SIZE;
-		static const CM::UINT32 INITIAL_INDENT_OFFSET;
-		static const CM::UINT32 DRAG_MIN_DISTANCE;
+		static const UINT32 ELEMENT_EXTRA_SPACING;
+		static const UINT32 INDENT_SIZE;
+		static const UINT32 INITIAL_INDENT_OFFSET;
+		static const UINT32 DRAG_MIN_DISTANCE;
 		static const float AUTO_EXPAND_DELAY_SEC;
 		static const float SCROLL_AREA_HEIGHT_PCT;
-		static const CM::UINT32 SCROLL_SPEED_PX_PER_SEC;
+		static const UINT32 SCROLL_SPEED_PX_PER_SEC;
 
-		CM::String mBackgroundStyle;
-		CM::String mElementBtnStyle;
-		CM::String mFoldoutBtnStyle;
-		CM::String mSelectionBackgroundStyle;
-		CM::String mEditBoxStyle;
-		CM::String mDragHighlightStyle;
-		CM::String mDragSepHighlightStyle;
+		String mBackgroundStyle;
+		String mElementBtnStyle;
+		String mFoldoutBtnStyle;
+		String mSelectionBackgroundStyle;
+		String mEditBoxStyle;
+		String mDragHighlightStyle;
+		String mDragSepHighlightStyle;
 
-		BS::GUITexture* mBackgroundImage;
+		GUITexture* mBackgroundImage;
 
-		CM::Vector<InteractableElement>::type mVisibleElements;
+		Vector<InteractableElement>::type mVisibleElements;
 
 		bool mIsElementSelected;
-		CM::Vector<SelectedElement>::type mSelectedElements;
+		Vector<SelectedElement>::type mSelectedElements;
 
 		TreeElement* mEditElement;
 		GUITreeViewEditBox* mNameEditBox;
 
-		CM::Vector2I mDragStartPosition;
-		CM::Vector2I mDragPosition;
+		Vector2I mDragStartPosition;
+		Vector2I mDragPosition;
 		bool mDragInProgress;
-		BS::GUITexture* mDragHighlight;
-		BS::GUITexture* mDragSepHighlight;
+		GUITexture* mDragHighlight;
+		GUITexture* mDragSepHighlight;
 
-		CM::RectI mTopScrollBounds;
-		CM::RectI mBottomScrollBounds;
+		RectI mTopScrollBounds;
+		RectI mBottomScrollBounds;
 		ScrollState mScrollState;
 		float mLastScrollTime;
 
-		CM::Stack<TreeElement*>::type mAutoExpandedElements;
+		Stack<TreeElement*>::type mAutoExpandedElements;
 		TreeElement* mMouseOverDragElement;
 		float mMouseOverDragElementTime;
 
-		static BS::VirtualButton mRenameVB;
-		static BS::VirtualButton mDeleteVB;
+		static VirtualButton mRenameVB;
+		static VirtualButton mDeleteVB;
 
-		GUITreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-			const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
-			const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const BS::GUILayoutOptions& layoutOptions);
+		GUITreeView(const String& backgroundStyle, const String& elementBtnStyle, 
+			const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, 
+			const String& dragHighlightStyle, const String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions);
 
-		const GUITreeView::InteractableElement* findElementUnderCoord(const CM::Vector2I& coord) const;
+		const GUITreeView::InteractableElement* findElementUnderCoord(const Vector2I& coord) const;
 		TreeElement* getTopMostSelectedElement() const;
 		TreeElement* getBottomMostSelectedElement() const;
 
 		void enableEdit(TreeElement* element);
 		void disableEdit(bool acceptChanges);
 
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
-		virtual bool commandEvent(const BS::GUICommandEvent& ev);
-		virtual bool virtualButtonEvent(const BS::GUIVirtualButtonEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
+		virtual bool commandEvent(const GUICommandEvent& ev);
+		virtual bool virtualButtonEvent(const GUIVirtualButtonEvent& ev);
 		void elementToggled(TreeElement* element, bool toggled);
 
 		virtual TreeElement& getRootElement() = 0;
 		virtual const TreeElement& getRootElementConst() const = 0;
 		virtual void updateTreeElementHierarchy() = 0;
-		virtual void renameTreeElement(TreeElement* element, const CM::WString& name) = 0;
+		virtual void renameTreeElement(TreeElement* element, const WString& name) = 0;
 		virtual void deleteTreeElement(TreeElement* element) = 0;
 		virtual bool acceptDragAndDrop() const = 0;
 		virtual void dragAndDropStart() = 0;
@@ -162,7 +162,7 @@ namespace BansheeEditor
 		void temporarilyExpandElement(const GUITreeView::InteractableElement* mouseOverElement);
 		void scrollToElement(TreeElement* element, bool center);
 
-		BS::GUIScrollArea* findParentScrollArea() const;
+		GUIScrollArea* findParentScrollArea() const;
 
 		void onEditAccepted();
 		void onEditCanceled();

BansheeEditor/Include/BsGUITreeViewEditBox.h

@@ -3,22 +3,22 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIInputBox.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUITreeViewEditBox : public BS::GUIInputBox
+	class GUITreeViewEditBox : public GUIInputBox
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUITreeViewEditBox* create(const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUITreeViewEditBox* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUITreeViewEditBox* create(const String& styleName = StringUtil::BLANK);
+		static GUITreeViewEditBox* create(const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 
 		boost::signal<void()> onInputConfirmed;
 		boost::signal<void()> onInputCanceled;
 
 	private:
-		GUITreeViewEditBox(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
+		GUITreeViewEditBox(const String& styleName, const GUILayoutOptions& layoutOptions);
 
-		virtual bool commandEvent(const BS::GUICommandEvent& ev);
+		virtual bool commandEvent(const GUICommandEvent& ev);
 	};
 }

BansheeEditor/Include/BsGUIVector2Field.h

@@ -4,24 +4,24 @@
 #include "BsGUIFieldBase.h"
 #include "CmVector2.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUIVector2Field : public TGUIField<GUIVector2Field>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUIVector2Field(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIVector2Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		CM::Vector2 getValue() const;
-		void setValue(const CM::Vector2& value);
+		Vector2 getValue() const;
+		void setValue(const Vector2& value);
 
 	protected:
 		virtual ~GUIVector2Field() { }
 
 	protected:
-		static const CM::UINT32 ELEMENT_LABEL_WIDTH;
+		static const UINT32 ELEMENT_LABEL_WIDTH;
 
 		GUIFloatField* mFieldX;
 		GUIFloatField* mFieldY;

BansheeEditor/Include/BsGUIVector3Field.h

@@ -4,24 +4,24 @@
 #include "BsGUIFieldBase.h"
 #include "CmVector3.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUIVector3Field : public TGUIField<GUIVector3Field>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUIVector3Field(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIVector3Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		CM::Vector3 getValue() const;
-		void setValue(const CM::Vector3& value);
+		Vector3 getValue() const;
+		void setValue(const Vector3& value);
 
 	protected:
 		virtual ~GUIVector3Field() { }
 
 	protected:
-		static const CM::UINT32 ELEMENT_LABEL_WIDTH;
+		static const UINT32 ELEMENT_LABEL_WIDTH;
 
 		GUIFloatField* mFieldX;
 		GUIFloatField* mFieldY;

BansheeEditor/Include/BsGUIVector4Field.h

@@ -4,24 +4,24 @@
 #include "BsGUIFieldBase.h"
 #include "CmVector4.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class BS_ED_EXPORT GUIVector4Field : public TGUIField<GUIVector4Field>
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		GUIVector4Field(const PrivatelyConstruct& dummy, const BS::GUIContent& labelContent, CM::UINT32 labelWidth,
-			const CM::String& labelStyle, const CM::String& inputBoxStyle, const BS::GUILayoutOptions& layoutOptions, bool withLabel);
+		GUIVector4Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+			const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel);
 
-		CM::Vector4 getValue() const;
-		void setValue(const CM::Vector4& value);
+		Vector4 getValue() const;
+		void setValue(const Vector4& value);
 
 	protected:
 		virtual ~GUIVector4Field() { }
 
 	protected:
-		static const CM::UINT32 ELEMENT_LABEL_WIDTH;
+		static const UINT32 ELEMENT_LABEL_WIDTH;
 
 		GUIFloatField* mFieldX;
 		GUIFloatField* mFieldY;

BansheeEditor/Include/BsGUIWindowDropArea.h

@@ -4,23 +4,23 @@
 #include "BsGUITexture.h"
 #include <boost/signals.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUIWindowDropArea : public BS::GUITexture
+	class GUIWindowDropArea : public GUITexture
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIWindowDropArea* create(const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUIWindowDropArea* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIWindowDropArea* create(const String& styleName = StringUtil::BLANK);
+		static GUIWindowDropArea* create(const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 
 		void setFocused(bool focused);
 
 		boost::signal<void()> onDraggedItemDropped;
 	protected:
 		~GUIWindowDropArea();
-		GUIWindowDropArea(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
+		GUIWindowDropArea(const String& styleName, const GUILayoutOptions& layoutOptions);
 
-		virtual bool mouseEvent(const BS::GUIMouseEvent& ev);
+		virtual bool mouseEvent(const GUIMouseEvent& ev);
 	};
 }

BansheeEditor/Include/BsGUIWindowFrame.h

@@ -4,19 +4,19 @@
 #include "BsGUITexture.h"
 #include "BsImageSprite.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class GUIWindowFrame : public BS::GUITexture
+	class GUIWindowFrame : public GUITexture
 	{
 	public:
-		static const CM::String& getGUITypeName();
+		static const String& getGUITypeName();
 
-		static GUIWindowFrame* create(const CM::String& styleName = CM::StringUtil::BLANK);
-		static GUIWindowFrame* create(const BS::GUIOptions& layoutOptions, const CM::String& styleName = CM::StringUtil::BLANK);
+		static GUIWindowFrame* create(const String& styleName = StringUtil::BLANK);
+		static GUIWindowFrame* create(const GUIOptions& layoutOptions, const String& styleName = StringUtil::BLANK);
 
 		void setFocused(bool focused);
 	protected:
 		~GUIWindowFrame();
-		GUIWindowFrame(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions);
+		GUIWindowFrame(const String& styleName, const GUILayoutOptions& layoutOptions);
 	};
 }

BansheeEditor/Include/BsGUIWindowFrameWidget.h

@@ -4,24 +4,24 @@
 #include "BsGUIWidget.h"
 #include <boost/signal.hpp>
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class WindowFrameWidget : public BS::GUIWidget
+	class WindowFrameWidget : public GUIWidget
 	{
 	public:
-		WindowFrameWidget(const CM::HSceneObject& parent, CM::Viewport* target, CM::RenderWindow* ownerWindow, const BS::GUISkin& skin);
+		WindowFrameWidget(const HSceneObject& parent, Viewport* target, RenderWindow* ownerWindow, const GUISkin& skin);
 		virtual ~WindowFrameWidget();
 
 	protected:
-		static const CM::UINT32 RESIZE_BORDER_WIDTH;
+		static const UINT32 RESIZE_BORDER_WIDTH;
 
-		BS::GUIArea* mWindowFrameArea;
-		CM::RenderWindow* mParentWindow;
+		GUIArea* mWindowFrameArea;
+		RenderWindow* mParentWindow;
 		GUIWindowFrame* mWindowFrame;
 
 		virtual void update();
 
-		virtual bool _mouseEvent(BS::GUIElement* element, const BS::GUIMouseEvent& ev);
+		virtual bool _mouseEvent(GUIElement* element, const GUIMouseEvent& ev);
 		virtual void ownerWindowFocusChanged();
 		virtual void ownerTargetResized();
 

BansheeEditor/Include/BsMainEditorWindow.h

@@ -3,7 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "BsEditorWindowBase.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class MainEditorWindow : public EditorWindowBase
 	{
@@ -14,10 +14,10 @@ namespace BansheeEditor
 
 		DockManager& getDockManager() const { return *mDockManager; }
 
-		static MainEditorWindow* create(const CM::RenderWindowPtr& renderWindow);
+		static MainEditorWindow* create(const RenderWindowPtr& renderWindow);
 	protected:
 		friend class EditorWindowManager;
-		MainEditorWindow(const CM::RenderWindowPtr& renderWindow);
+		MainEditorWindow(const RenderWindowPtr& renderWindow);
 
 	protected:
 		GUIMenuBar* mMenuBar;

BansheeEditor/Include/BsProjectLibrary.h

@@ -3,9 +3,9 @@
 #include "BsEditorPrerequisites.h"
 #include "CmModule.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class ProjectLibrary : public CM::Module<ProjectLibrary>
+	class ProjectLibrary : public Module<ProjectLibrary>
 	{
 	public:
 		struct LibraryEntry;
@@ -21,11 +21,11 @@ namespace BansheeEditor
 		struct LibraryEntry
 		{
 			LibraryEntry();
-			LibraryEntry(const CM::WString& path, const CM::WString& name, DirectoryEntry* parent, LibraryEntryType type);
+			LibraryEntry(const WString& path, const WString& name, DirectoryEntry* parent, LibraryEntryType type);
 
 			LibraryEntryType type;
-			CM::WString path;
-			CM::WString elementName;
+			WString path;
+			WString elementName;
 
 			DirectoryEntry* parent;
 		};
@@ -33,7 +33,7 @@ namespace BansheeEditor
 		struct ResourceEntry : public LibraryEntry
 		{
 			ResourceEntry();
-			ResourceEntry(const CM::WString& path, const CM::WString& name, DirectoryEntry* parent);
+			ResourceEntry(const WString& path, const WString& name, DirectoryEntry* parent);
 
 			ResourceMetaPtr meta;
 			std::time_t lastUpdateTime;
@@ -42,55 +42,55 @@ namespace BansheeEditor
 		struct DirectoryEntry : public LibraryEntry
 		{
 			DirectoryEntry();
-			DirectoryEntry(const CM::WString& path, const CM::WString& name, DirectoryEntry* parent);
+			DirectoryEntry(const WString& path, const WString& name, DirectoryEntry* parent);
 
-			CM::Vector<LibraryEntry*>::type mChildren;
+			Vector<LibraryEntry*>::type mChildren;
 		};
 
 	public:
-		ProjectLibrary(const CM::WString& projectFolder);
+		ProjectLibrary(const WString& projectFolder);
 		~ProjectLibrary();
 
 		void update();
-		void checkForModifications(const CM::WString& fullPath);
+		void checkForModifications(const WString& fullPath);
 
 		const LibraryEntry* getRootEntry() const { return mRootEntry; }
-		LibraryEntry* findEntry(const CM::WString& fullPath) const;
+		LibraryEntry* findEntry(const WString& fullPath) const;
 
-		void moveEntry(const CM::WString& oldPath, const CM::WString& newPath);
-		void deleteEntry(const CM::WString& path);
+		void moveEntry(const WString& oldPath, const WString& newPath);
+		void deleteEntry(const WString& path);
 
-		boost::signal<void(const CM::WString&)> onEntryRemoved;
-		boost::signal<void(const CM::WString&)> onEntryAdded;
+		boost::signal<void(const WString&)> onEntryRemoved;
+		boost::signal<void(const WString&)> onEntryAdded;
 	private:
-		static const CM::WString RESOURCES_DIR;
-		static const CM::WString INTERNAL_RESOURCES_DIR;
-		static const CM::WString LIBRARY_ENTRIES_FILENAME;
-		static const CM::WString RESOURCE_MANIFEST_FILENAME;
+		static const WString RESOURCES_DIR;
+		static const WString INTERNAL_RESOURCES_DIR;
+		static const WString LIBRARY_ENTRIES_FILENAME;
+		static const WString RESOURCE_MANIFEST_FILENAME;
 
-		CM::ResourceManifestPtr mResourceManifest;
+		ResourceManifestPtr mResourceManifest;
 		DirectoryEntry* mRootEntry;
-		CM::FolderMonitor* mMonitor;
-		CM::WString mProjectFolder;
-		CM::WString mResourcesFolder;
+		FolderMonitor* mMonitor;
+		WString mProjectFolder;
+		WString mResourcesFolder;
 
 		void save();
 		void load();
 
-		ResourceEntry* addResourceInternal(DirectoryEntry* parent, const CM::WString& filePath);
-		DirectoryEntry* addDirectoryInternal(DirectoryEntry* parent, const CM::WString& dirPath);
+		ResourceEntry* addResourceInternal(DirectoryEntry* parent, const WString& filePath);
+		DirectoryEntry* addDirectoryInternal(DirectoryEntry* parent, const WString& dirPath);
 
 		void deleteResourceInternal(ResourceEntry* resource);
 		void deleteDirectoryInternal(DirectoryEntry* directory);
 
 		void reimportResourceInternal(ResourceEntry* resource);
 
-		void createInternalParentHierarchy(const CM::WString& fullPath, DirectoryEntry** newHierarchyRoot, DirectoryEntry** newHierarchyLeaf);
+		void createInternalParentHierarchy(const WString& fullPath, DirectoryEntry** newHierarchyRoot, DirectoryEntry** newHierarchyLeaf);
 
 		bool isUpToDate(ResourceEntry* resource) const;
-		CM::WString getMetaPath(const CM::WString& path) const;
-		bool isMeta(const CM::WString& fullPath) const;
+		WString getMetaPath(const WString& path) const;
+		bool isMeta(const WString& fullPath) const;
 
-		void onMonitorFileModified(const CM::WString& path);
+		void onMonitorFileModified(const WString& path);
 	};
 }

BansheeEditor/Include/BsProjectLibraryEntries.h

@@ -4,9 +4,9 @@
 #include "BsProjectLibrary.h"
 #include "CmIReflectable.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class ProjectLibraryEntries : public CM::IReflectable
+	class ProjectLibraryEntries : public IReflectable
 	{
 		struct ConstructPrivately { };
 
@@ -28,7 +28,7 @@ namespace BansheeEditor
 
 	public:
 		friend class ProjectLibraryEntriesRTTI;
-		static CM::RTTITypeBase* getRTTIStatic();
-		virtual CM::RTTITypeBase* getRTTI() const;
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;
 	};
 }

BansheeEditor/Include/BsProjectLibraryEntriesRTTI.h

@@ -4,9 +4,9 @@
 #include "CmRTTIType.h"
 #include "BsProjectLibraryEntries.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class ProjectLibraryEntriesRTTI : public CM::RTTIType<ProjectLibraryEntries, CM::IReflectable, ProjectLibraryEntriesRTTI>
+	class ProjectLibraryEntriesRTTI : public RTTIType<ProjectLibraryEntries, IReflectable, ProjectLibraryEntriesRTTI>
 	{
 	private:
 		ProjectLibrary::DirectoryEntry& getRootElement(ProjectLibraryEntries* obj) { return obj->mRootEntry; }
@@ -18,31 +18,31 @@ namespace BansheeEditor
 			addPlainField("mRootElement", 0, &ProjectLibraryEntriesRTTI::getRootElement, &ProjectLibraryEntriesRTTI::setRootElement);
 		}
 
-		virtual const CM::String& getRTTIName()
+		virtual const String& getRTTIName()
 		{
-			static CM::String name = "ProjectLibraryEntries";
+			static String name = "ProjectLibraryEntries";
 			return name;
 		}
 
-		virtual CM::UINT32 getRTTIId()
+		virtual UINT32 getRTTIId()
 		{
 			return TID_ProjectLibraryEntries;
 		}
 
-		virtual std::shared_ptr<CM::IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
 		{
 			return ProjectLibraryEntries::createEmpty();
 		}
 	};
 }
 
-namespace CamelotFramework
+namespace BansheeEngine
 {
-	template<> struct CM::RTTIPlainType<BansheeEditor::ProjectLibrary::ResourceEntry>
+	template<> struct RTTIPlainType<BansheeEngine::ProjectLibrary::ResourceEntry>
 	{	
-		enum { id = BansheeEditor::TID_ProjectLibraryResEntry }; enum { hasDynamicSize = 1 };
+		enum { id = BansheeEngine::TID_ProjectLibraryResEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const BansheeEditor::ProjectLibrary::ResourceEntry& data, char* memory)
+		static void toMemory(const BansheeEngine::ProjectLibrary::ResourceEntry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			char* memoryStart = memory;
@@ -58,7 +58,7 @@ namespace CamelotFramework
 			memcpy(memoryStart, &size, sizeof(UINT32));
 		}
 
-		static UINT32 fromMemory(BansheeEditor::ProjectLibrary::ResourceEntry& data, char* memory)
+		static UINT32 fromMemory(BansheeEngine::ProjectLibrary::ResourceEntry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			memcpy(&size, memory, sizeof(UINT32));
@@ -66,7 +66,7 @@ namespace CamelotFramework
 
 			UINT32 type;
 			memory = rttiReadElem(type, memory);
-			data.type = (BansheeEditor::ProjectLibrary::LibraryEntryType)type;
+			data.type = (BansheeEngine::ProjectLibrary::LibraryEntryType)type;
 
 			memory = rttiReadElem(data.path, memory);
 			memory = rttiReadElem(data.elementName, memory);
@@ -75,7 +75,7 @@ namespace CamelotFramework
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const BansheeEditor::ProjectLibrary::ResourceEntry& data)	
+		static UINT32 getDynamicSize(const BansheeEngine::ProjectLibrary::ResourceEntry& data)	
 		{ 
 			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + rttiGetElemSize(data.elementName) +
 				rttiGetElemSize(data.lastUpdateTime);
@@ -91,11 +91,11 @@ namespace CamelotFramework
 		}	
 	}; 
 
-	template<> struct CM::RTTIPlainType<BansheeEditor::ProjectLibrary::DirectoryEntry>
+	template<> struct RTTIPlainType<BansheeEngine::ProjectLibrary::DirectoryEntry>
 	{	
-		enum { id = BansheeEditor::TID_ProjectLibraryDirEntry }; enum { hasDynamicSize = 1 };
+		enum { id = BansheeEngine::TID_ProjectLibraryDirEntry }; enum { hasDynamicSize = 1 };
 
-		static void toMemory(const BansheeEditor::ProjectLibrary::DirectoryEntry& data, char* memory)
+		static void toMemory(const BansheeEngine::ProjectLibrary::DirectoryEntry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			char* memoryStart = memory;
@@ -111,14 +111,14 @@ namespace CamelotFramework
 
 			for(auto& child : data.mChildren)
 			{
-				if(child->type == BansheeEditor::ProjectLibrary::LibraryEntryType::File)
+				if(child->type == BansheeEngine::ProjectLibrary::LibraryEntryType::File)
 				{
-					BansheeEditor::ProjectLibrary::ResourceEntry* childResEntry = static_cast<BansheeEditor::ProjectLibrary::ResourceEntry*>(child);
+					BansheeEngine::ProjectLibrary::ResourceEntry* childResEntry = static_cast<BansheeEngine::ProjectLibrary::ResourceEntry*>(child);
 					memory = rttiWriteElem(*childResEntry, memory, size);
 				}
-				else if(child->type == BansheeEditor::ProjectLibrary::LibraryEntryType::Directory)
+				else if(child->type == BansheeEngine::ProjectLibrary::LibraryEntryType::Directory)
 				{
-					BansheeEditor::ProjectLibrary::DirectoryEntry* childDirEntry = static_cast<BansheeEditor::ProjectLibrary::DirectoryEntry*>(child);
+					BansheeEngine::ProjectLibrary::DirectoryEntry* childDirEntry = static_cast<BansheeEngine::ProjectLibrary::DirectoryEntry*>(child);
 					memory = rttiWriteElem(*childDirEntry, memory, size);
 				}
 			}
@@ -126,7 +126,7 @@ namespace CamelotFramework
 			memcpy(memoryStart, &size, sizeof(UINT32));
 		}
 
-		static UINT32 fromMemory(BansheeEditor::ProjectLibrary::DirectoryEntry& data, char* memory)
+		static UINT32 fromMemory(BansheeEngine::ProjectLibrary::DirectoryEntry& data, char* memory)
 		{ 
 			UINT32 size = 0;
 			memcpy(&size, memory, sizeof(UINT32));
@@ -141,20 +141,20 @@ namespace CamelotFramework
 
 			for(UINT32 i = 0; i < numChildren; i++)
 			{
-				BansheeEditor::ProjectLibrary::LibraryEntryType childType = BansheeEditor::ProjectLibrary::LibraryEntryType::File;
+				BansheeEngine::ProjectLibrary::LibraryEntryType childType = BansheeEngine::ProjectLibrary::LibraryEntryType::File;
 				rttiReadElem(childType, memory + sizeof(UINT32)); // Skip ahead to get type
 
-				if(childType == BansheeEditor::ProjectLibrary::LibraryEntryType::File)
+				if(childType == BansheeEngine::ProjectLibrary::LibraryEntryType::File)
 				{
-					BansheeEditor::ProjectLibrary::ResourceEntry* childResEntry = cm_new<BansheeEditor::ProjectLibrary::ResourceEntry>(); // Note: Assumes that ProjectLibrary takes care of the cleanup
+					BansheeEngine::ProjectLibrary::ResourceEntry* childResEntry = cm_new<BansheeEngine::ProjectLibrary::ResourceEntry>(); // Note: Assumes that ProjectLibrary takes care of the cleanup
 					memory = rttiReadElem(*childResEntry, memory);
 
 					childResEntry->parent = &data;
 					data.mChildren.push_back(childResEntry);
 				}
-				else if(childType == BansheeEditor::ProjectLibrary::LibraryEntryType::Directory)
+				else if(childType == BansheeEngine::ProjectLibrary::LibraryEntryType::Directory)
 				{
-					BansheeEditor::ProjectLibrary::DirectoryEntry* childDirEntry = cm_new<BansheeEditor::ProjectLibrary::DirectoryEntry>(); // Note: Assumes that ProjectLibrary takes care of the cleanup
+					BansheeEngine::ProjectLibrary::DirectoryEntry* childDirEntry = cm_new<BansheeEngine::ProjectLibrary::DirectoryEntry>(); // Note: Assumes that ProjectLibrary takes care of the cleanup
 					memory = rttiReadElem(*childDirEntry, memory);
 
 					childDirEntry->parent = &data;
@@ -165,7 +165,7 @@ namespace CamelotFramework
 			return size;
 		}
 
-		static UINT32 getDynamicSize(const BansheeEditor::ProjectLibrary::DirectoryEntry& data)	
+		static UINT32 getDynamicSize(const BansheeEngine::ProjectLibrary::DirectoryEntry& data)	
 		{ 
 			UINT64 dataSize = sizeof(UINT32) + rttiGetElemSize(data.type) + rttiGetElemSize(data.path) + rttiGetElemSize(data.elementName);
 
@@ -173,14 +173,14 @@ namespace CamelotFramework
 
 			for(auto& child : data.mChildren)
 			{
-				if(child->type == BansheeEditor::ProjectLibrary::LibraryEntryType::File)
+				if(child->type == BansheeEngine::ProjectLibrary::LibraryEntryType::File)
 				{
-					BansheeEditor::ProjectLibrary::ResourceEntry* childResEntry = static_cast<BansheeEditor::ProjectLibrary::ResourceEntry*>(child);
+					BansheeEngine::ProjectLibrary::ResourceEntry* childResEntry = static_cast<BansheeEngine::ProjectLibrary::ResourceEntry*>(child);
 					dataSize += rttiGetElemSize(*childResEntry);
 				}
-				else if(child->type == BansheeEditor::ProjectLibrary::LibraryEntryType::Directory)
+				else if(child->type == BansheeEngine::ProjectLibrary::LibraryEntryType::Directory)
 				{
-					BansheeEditor::ProjectLibrary::DirectoryEntry* childDirEntry = static_cast<BansheeEditor::ProjectLibrary::DirectoryEntry*>(child);
+					BansheeEngine::ProjectLibrary::DirectoryEntry* childDirEntry = static_cast<BansheeEngine::ProjectLibrary::DirectoryEntry*>(child);
 					dataSize += rttiGetElemSize(*childDirEntry);
 				}
 			}

BansheeEditor/Include/BsResourceMeta.h

@@ -3,9 +3,9 @@
 #include "BsEditorPrerequisites.h"
 #include "CmIReflectable.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class ResourceMeta : public CM::IReflectable
+	class ResourceMeta : public IReflectable
 	{
 	private:
 		struct ConstructPrivately {};
@@ -13,14 +13,14 @@ namespace BansheeEditor
 	public:
 		explicit ResourceMeta(const ConstructPrivately&);
 
-		static ResourceMetaPtr create(const CM::String& uuid, const CM::ImportOptionsPtr& importOptions);
+		static ResourceMetaPtr create(const String& uuid, const ImportOptionsPtr& importOptions);
 
-		const CM::String& getUUID() const { return mUUID; }
-		const CM::ImportOptionsPtr& getImportOptions() const { return mImportOptions; }
+		const String& getUUID() const { return mUUID; }
+		const ImportOptionsPtr& getImportOptions() const { return mImportOptions; }
 
 	private:
-		CM::String mUUID;
-		CM::ImportOptionsPtr mImportOptions;
+		String mUUID;
+		ImportOptionsPtr mImportOptions;
 
 		/************************************************************************/
 		/* 								RTTI		                     		*/
@@ -29,7 +29,7 @@ namespace BansheeEditor
 
 	public:
 		friend class ResourceMetaRTTI;
-		static CM::RTTITypeBase* getRTTIStatic();
-		virtual CM::RTTITypeBase* getRTTI() const;	
+		static RTTITypeBase* getRTTIStatic();
+		virtual RTTITypeBase* getRTTI() const;	
 	};
 }

BansheeEditor/Include/BsResourceMetaRTTI.h

@@ -5,16 +5,16 @@
 #include "BsResourceMeta.h"
 #include "CmImportOptions.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class ResourceMetaRTTI : public CM::RTTIType<ResourceMeta, CM::IReflectable, ResourceMetaRTTI>
+	class ResourceMetaRTTI : public RTTIType<ResourceMeta, IReflectable, ResourceMetaRTTI>
 	{
 	private:
-		CM::String& getUUID(ResourceMeta* obj) { return obj->mUUID; }
-		void setUUID(ResourceMeta* obj, CM::String& val) { obj->mUUID = val; } 
+		String& getUUID(ResourceMeta* obj) { return obj->mUUID; }
+		void setUUID(ResourceMeta* obj, String& val) { obj->mUUID = val; } 
 
-		CM::ImportOptionsPtr getImportOptions(ResourceMeta* obj) { return obj->mImportOptions; }
-		void setImportOptions(ResourceMeta* obj, CM::ImportOptionsPtr val) { obj->mImportOptions = val; }
+		ImportOptionsPtr getImportOptions(ResourceMeta* obj) { return obj->mImportOptions; }
+		void setImportOptions(ResourceMeta* obj, ImportOptionsPtr val) { obj->mImportOptions = val; }
 
 	public:
 		ResourceMetaRTTI()
@@ -23,18 +23,18 @@ namespace BansheeEditor
 			addReflectablePtrField("mImportOptions", 1, &ResourceMetaRTTI::getImportOptions, &ResourceMetaRTTI::setImportOptions);
 		}
 
-		virtual const CM::String& getRTTIName()
+		virtual const String& getRTTIName()
 		{
-			static CM::String name = "ResourceMeta";
+			static String name = "ResourceMeta";
 			return name;
 		}
 
-		virtual CM::UINT32 getRTTIId()
+		virtual UINT32 getRTTIId()
 		{
 			return TID_ResourceMeta;
 		}
 
-		virtual std::shared_ptr<CM::IReflectable> newRTTIObject()
+		virtual std::shared_ptr<IReflectable> newRTTIObject()
 		{
 			return ResourceMeta::createEmpty();
 		}

BansheeEditor/Include/BsUndoRedo.h

@@ -3,9 +3,9 @@
 #include "BsEditorPrerequisites.h"
 #include "CmModule.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class UndoRedo : public CM::Module<UndoRedo>
+	class UndoRedo : public Module<UndoRedo>
 	{
 	public:
 		UndoRedo();
@@ -17,16 +17,16 @@ namespace BansheeEditor
 		void registerCommand(EditorCommand* command);
 
 	private:
-		static const CM::UINT32 MAX_STACK_ELEMENTS;
+		static const UINT32 MAX_STACK_ELEMENTS;
 
 		EditorCommand** mUndoStack;
 		EditorCommand** mRedoStack;
 
-		CM::UINT32 mUndoStackPtr;
-		CM::UINT32 mUndoNumElements;
+		UINT32 mUndoStackPtr;
+		UINT32 mUndoNumElements;
 
-		CM::UINT32 mRedoStackPtr;
-		CM::UINT32 mRedoNumElements;
+		UINT32 mRedoStackPtr;
+		UINT32 mRedoNumElements;
 
 		void clearUndoStack();
 		void clearRedoStack();

BansheeEditor/Include/CmDebugCamera.h

@@ -4,7 +4,7 @@
 #include "CmComponent.h"
 #include "CmMath.h"
 
-namespace CamelotFramework
+namespace BansheeEngine
 {
 	class DebugCamera : public Component
 	{
@@ -15,7 +15,7 @@ namespace CamelotFramework
 		Degree mYaw;
 		bool mLastButtonState;
 
-		BS::HCamera mCamera;
+		HCamera mCamera;
 
 		static const float START_SPEED;
 		static const float TOP_SPEED;

BansheeEditor/Include/CmTestTextSprite.h

@@ -1,20 +1,20 @@
 #include "BsEditorPrerequisites.h"
 #include "BsGUIWidget.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	class TestTextSprite : public BS::GUIWidget
+	class TestTextSprite : public GUIWidget
 	{
 	protected:
-		friend class CM::SceneObject;
+		friend class SceneObject;
 
-		TestTextSprite(const CM::HSceneObject& parent, CM::Viewport* target);
+		TestTextSprite(const HSceneObject& parent, Viewport* target);
 	public:
 		~TestTextSprite();
 
 		virtual void update();
 
-		void init(const BS::HCamera& camera, const CM::String& text, CM::RenderTexturePtr sceneView);
+		void init(const HCamera& camera, const String& text, RenderTexturePtr sceneView);
 
 	private:
 		GUISceneTreeView* mSceneTreeView;

BansheeEditor/Include/DbgEditorWidget1.h

@@ -3,7 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "BsEditorWidget.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class DbgEditorWidget1 : public EditorWidget<DbgEditorWidget1>
 	{
@@ -14,7 +14,7 @@ namespace BansheeEditor
 		static DbgEditorWidget1* instance();
 		static DbgEditorWidget1* open();
 		static void close();
-		static const CM::String& getTypeName();
+		static const String& getTypeName();
 
 	private:
 		static DbgEditorWidget1* Instance;

BansheeEditor/Include/DbgEditorWidget2.h

@@ -3,7 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "BsEditorWidget.h"
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	class DbgEditorWidget2 : public EditorWidget<DbgEditorWidget2>
 	{
@@ -14,7 +14,7 @@ namespace BansheeEditor
 		static DbgEditorWidget2* instance();
 		static DbgEditorWidget2* open();
 		static void close();
-		static const CM::String& getTypeName();
+		static const String& getTypeName();
 
 	private:
 		static DbgEditorWidget2* Instance;

BansheeEditor/Source/BsCmdReparentSO.cpp

@@ -1,12 +1,9 @@
 #include "BsCmdReparentSO.h"
 #include "CmSceneObject.h"
 
-using namespace BansheeEngine;
-using namespace CamelotFramework;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	CmdReparentSO::CmdReparentSO(const CM::Vector<CM::HSceneObject>::type& sceneObjects, const CM::HSceneObject& newParent)
+	CmdReparentSO::CmdReparentSO(const Vector<HSceneObject>::type& sceneObjects, const HSceneObject& newParent)
 		:mSceneObjects(sceneObjects), mNewParent(newParent)
 	{
 		for(auto& sceneObject : mSceneObjects)
@@ -15,7 +12,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void CmdReparentSO::execute(const CM::Vector<CM::HSceneObject>::type& sceneObjects, const CM::HSceneObject& newParent)
+	void CmdReparentSO::execute(const Vector<HSceneObject>::type& sceneObjects, const HSceneObject& newParent)
 	{
 		// Register command and commit it
 		CmdReparentSO* command = new (cm_alloc<CmdReparentSO>()) CmdReparentSO(sceneObjects, newParent);

BansheeEditor/Source/BsDbgTestGameObjectRef.cpp

@@ -3,10 +3,7 @@
 #include "CmSceneObject.h"
 #include "BsRenderable.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	DbgTestGameObjectRef::DbgTestGameObjectRef(const HSceneObject& parent)
 		:Component(parent)

BansheeEditor/Source/BsDockManager.cpp

@@ -26,17 +26,15 @@
 #include "BsGUISkin.h"
 #include "BsGUIButton.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	const CM::UINT32 DockManager::DockContainer::SLIDER_SIZE = 4;
-	const CM::UINT32 DockManager::DockContainer::MIN_CHILD_SIZE = 20;
+	const UINT32 DockManager::DockContainer::SLIDER_SIZE = 4;
+	const UINT32 DockManager::DockContainer::MIN_CHILD_SIZE = 20;
 
-	const CM::Color DockManager::TINT_COLOR = Color(0.44f, 0.44f, 0.44f, 0.22f);
-	const CM::Color DockManager::HIGHLIGHT_COLOR = Color(0.44f, 0.44f, 0.44f, 0.42f);
+	const Color DockManager::TINT_COLOR = Color(0.44f, 0.44f, 0.44f, 0.22f);
+	const Color DockManager::HIGHLIGHT_COLOR = Color(0.44f, 0.44f, 0.44f, 0.42f);
 
 	DockManager::DockContainer::DockContainer()
 		:mIsLeaf(true), mWidgets(nullptr), mSplitPosition(0.5f),
@@ -75,7 +73,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void DockManager::DockContainer::setArea(CM::INT32 x, CM::INT32 y, UINT32 width, UINT32 height)
+	void DockManager::DockContainer::setArea(INT32 x, INT32 y, UINT32 width, UINT32 height)
 	{
 		if(mIsLeaf)
 		{
@@ -168,7 +166,7 @@ namespace BansheeEditor
 		mWidgets->setSize(mArea.width, mArea.height);
 	}
 
-	void DockManager::DockContainer::addLeft(BS::GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
+	void DockManager::DockContainer::addLeft(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
 	{
 		if(mIsLeaf)
 			splitContainer(widgetParent, parentWindow, false, true);
@@ -176,7 +174,7 @@ namespace BansheeEditor
 		mChildren[0]->addWidget(widget);
 	}
 
-	void DockManager::DockContainer::addRight(BS::GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
+	void DockManager::DockContainer::addRight(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
 	{
 		if(mIsLeaf)
 			splitContainer(widgetParent, parentWindow, false, false);
@@ -184,7 +182,7 @@ namespace BansheeEditor
 		mChildren[1]->addWidget(widget);
 	}
 
-	void DockManager::DockContainer::addTop(BS::GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
+	void DockManager::DockContainer::addTop(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
 	{
 		if(mIsLeaf)
 			splitContainer(widgetParent, parentWindow, true, true);
@@ -192,7 +190,7 @@ namespace BansheeEditor
 		mChildren[0]->addWidget(widget);
 	}
 
-	void DockManager::DockContainer::addBottom(BS::GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
+	void DockManager::DockContainer::addBottom(GUIWidget* widgetParent, RenderWindow* parentWindow, EditorWidgetBase* widget)
 	{
 		if(mIsLeaf)
 			splitContainer(widgetParent, parentWindow, true, false);
@@ -200,7 +198,7 @@ namespace BansheeEditor
 		mChildren[1]->addWidget(widget);
 	}
 
-	void DockManager::DockContainer::splitContainer(BS::GUIWidget* widgetParent, RenderWindow* parentWindow, bool horizontal, bool newChildIsFirst, float splitPosition)
+	void DockManager::DockContainer::splitContainer(GUIWidget* widgetParent, RenderWindow* parentWindow, bool horizontal, bool newChildIsFirst, float splitPosition)
 	{
 		UINT32 idxA = newChildIsFirst ? 0 : 1;
 		UINT32 idxB = (idxA + 1) % 2;
@@ -244,7 +242,7 @@ namespace BansheeEditor
 		mWidgets->add(*widget);
 	}
 
-	void DockManager::DockContainer::addWidget(const CM::String& name)
+	void DockManager::DockContainer::addWidget(const String& name)
 	{
 		if(!mIsLeaf)
 			return;
@@ -252,7 +250,7 @@ namespace BansheeEditor
 		EditorWidgetManager::instance().create(name, *mWidgets);
 	}
 
-	void DockManager::DockContainer::sliderDragged(const CM::Vector2I& delta)
+	void DockManager::DockContainer::sliderDragged(const Vector2I& delta)
 	{
 		if(mIsHorizontal && delta.y != 0)
 		{
@@ -328,7 +326,7 @@ namespace BansheeEditor
 		return nullptr;
 	}
 
-	DockManager::DockContainer* DockManager::DockContainer::findAtPos(const CM::Vector2I& pos)
+	DockManager::DockContainer* DockManager::DockContainer::findAtPos(const Vector2I& pos)
 	{
 		if(mIsLeaf)
 		{
@@ -357,7 +355,7 @@ namespace BansheeEditor
 		return mWidgets->getContentBounds();
 	}
 
-	DockManager::DockManager(CM::RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions)
+	DockManager::DockManager(RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mParentWindow(parentWindow), mMouseOverContainer(nullptr), mHighlightedDropLoc(DockLocation::None),
 		mShowOverlay(false), mAddedRenderCallback(false)
 	{
@@ -391,7 +389,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void DockManager::render(const Viewport* viewport, CM::RenderQueue& renderQueue)
+	void DockManager::render(const Viewport* viewport, RenderQueue& renderQueue)
 	{
 		if(!mShowOverlay)
 			return;
@@ -969,7 +967,7 @@ namespace BansheeEditor
 	}
 
 	// TODO - Move to a separate Polygon class?
-	bool DockManager::insidePolygon(CM::Vector2* polyPoints, CM::UINT32 numPoints, CM::Vector2 point) const
+	bool DockManager::insidePolygon(Vector2* polyPoints, UINT32 numPoints, Vector2 point) const
 	{
 		bool isInside = false;
 		for (UINT32 i = 0, j = numPoints - 1; i < numPoints; j = i++) 

BansheeEditor/Source/BsDockManagerLayout.cpp

@@ -1,10 +1,7 @@
 #include "BsDockManagerLayout.h"
 #include "BsDockManagerLayoutRTTI.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	DockManagerLayout::Entry::Entry()
 		:isLeaf(true), splitPosition(0), horizontalSplit(false),

BansheeEditor/Source/BsEditorApplication.cpp

@@ -36,10 +36,7 @@
 #include "BsGUIButton.h"
 #include "BsGUILayout.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const WString EditorApplication::WIDGET_LAYOUT_PATH = L"Internal\\Layout.asset";
 
@@ -360,7 +357,7 @@ namespace BansheeEditor
 
 	}
 
-	void EditorApplication::closeModalWindow(RenderWindowPtr window, CM::HSceneObject sceneObject)
+	void EditorApplication::closeModalWindow(RenderWindowPtr window, HSceneObject sceneObject)
 	{
 		//sceneObject->destroy();
 		window->destroy();

BansheeEditor/Source/BsEditorCommand.cpp

@@ -1,9 +1,6 @@
 #include "BsEditorCommand.h"
 
-using namespace BansheeEngine;
-using namespace CamelotFramework;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	void EditorCommand::destroy(EditorCommand* command)
 	{

BansheeEditor/Source/BsEditorGUI.cpp

@@ -16,10 +16,7 @@
 #include "CmRTTIType.h"
 #include "CmFileSystem.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const WString EditorGUI::DefaultFontPath = L"arial.ttf";
 	const UINT32 EditorGUI::DefaultFontSize = 10;
@@ -153,7 +150,7 @@ namespace BansheeEditor
 			{
 				FontImportOptions* importOptions = static_cast<FontImportOptions*>(fontImportOptions.get());
 
-				Vector<CamelotFramework::UINT32>::type fontSizes;
+				Vector<BansheeEngine::UINT32>::type fontSizes;
 				fontSizes.push_back(DefaultFontSize);
 				importOptions->setFontSizes(fontSizes);
 				importOptions->setAntialiasing(false);
@@ -817,7 +814,7 @@ namespace BansheeEditor
 
 	}
 
-	HSpriteTexture EditorGUI::getTexture(const CM::WString& name)
+	HSpriteTexture EditorGUI::getTexture(const WString& name)
 	{
 		return SpriteTexture::create(static_resource_cast<Texture>(Importer::instance().import(FileSystem::getWorkingDirectoryPath() + L"\\" + DefaultFolder + name)));
 	}

BansheeEditor/Source/BsEditorWidget.cpp

@@ -9,12 +9,9 @@
 #include "BsEditorWidgetContainer.h"
 #include "BsEditorWidgetManager.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	EditorWidgetBase::EditorWidgetBase(const HString& displayName, const CM::String& name, EditorWidgetContainer& parentContainer)
+	EditorWidgetBase::EditorWidgetBase(const HString& displayName, const String& name, EditorWidgetContainer& parentContainer)
 		:mDisplayName(displayName), mName(name), mParent(nullptr), mContent(nullptr), mX(0), mY(0), mWidth(0), mHeight(0)
 	{
 		parentContainer.add(*this);

BansheeEditor/Source/BsEditorWidgetContainer.cpp

@@ -9,15 +9,13 @@
 #include "BsGUIWidget.h"
 #include "BsGUILayout.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	const CM::UINT32 EditorWidgetContainer::TitleBarHeight = 13;
+	const UINT32 EditorWidgetContainer::TitleBarHeight = 13;
 
-	EditorWidgetContainer::EditorWidgetContainer(BS::GUIWidget* parent, RenderWindow* renderWindow, EditorWindow* parentEditorWindow)
+	EditorWidgetContainer::EditorWidgetContainer(GUIWidget* parent, RenderWindow* renderWindow, EditorWindow* parentEditorWindow)
 		:mParent(parent), mX(0), mY(0), mWidth(0), mHeight(0), mTitleBar(nullptr), mActiveWidget(-1),
 		mTitleBarArea(nullptr), mParentWindow(parentEditorWindow)
 	{
@@ -85,7 +83,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void EditorWidgetContainer::insert(CM::UINT32 idx, EditorWidgetBase& widget)
+	void EditorWidgetContainer::insert(UINT32 idx, EditorWidgetBase& widget)
 	{
 		if(contains(widget))
 			return;
@@ -113,7 +111,7 @@ namespace BansheeEditor
 		return false;
 	}
 
-	EditorWidgetBase* EditorWidgetContainer::getWidget(CM::UINT32 idx) const
+	EditorWidgetBase* EditorWidgetContainer::getWidget(UINT32 idx) const
 	{
 		if(idx >= (UINT32)mWidgets.size())
 			return nullptr;
@@ -195,7 +193,7 @@ namespace BansheeEditor
 			onWidgetClosed();
 	}
 
-	void EditorWidgetContainer::tabDraggedOff(CM::UINT32 uniqueIdx)
+	void EditorWidgetContainer::tabDraggedOff(UINT32 uniqueIdx)
 	{
 		EditorWidgetBase* widget = mWidgets[uniqueIdx];
 		removeInternal(*widget);
@@ -207,7 +205,7 @@ namespace BansheeEditor
 			onWidgetClosed();
 	}
 
-	void EditorWidgetContainer::tabDraggedOn(CM::UINT32 seqIdx)
+	void EditorWidgetContainer::tabDraggedOn(UINT32 seqIdx)
 	{
 #if CM_DEBUG_MODE
 		if(!DragAndDropManager::instance().isDragInProgress())

BansheeEditor/Source/BsEditorWidgetLayout.cpp

@@ -1,10 +1,7 @@
 #include "BsEditorWidgetLayout.h"
 #include "BsEditorWidgetLayoutRTTI.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	EditorWidgetLayout::Entry::Entry()
 		:isDocked(true), x(0), y(0), width(0), height(0)

BansheeEditor/Source/BsEditorWidgetManager.cpp

@@ -8,10 +8,7 @@
 #include "BsDockManager.h"
 #include "CmException.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	Stack<std::pair<String, std::function<EditorWidgetBase*(EditorWidgetContainer&)>>>::type EditorWidgetManager::QueuedCreateCallbacks;
 
@@ -68,7 +65,7 @@ namespace BansheeEditor
 		EditorWidgetBase::destroy(widget);
 	}
 
-	EditorWidgetBase* EditorWidgetManager::create(const CM::String& name, EditorWidgetContainer& parentContainer)
+	EditorWidgetBase* EditorWidgetManager::create(const String& name, EditorWidgetContainer& parentContainer)
 	{
 		auto iterFind = mActiveWidgets.find(name);
 

BansheeEditor/Source/BsEditorWindow.cpp

@@ -3,10 +3,7 @@
 #include "BsEditorWindowManager.h"
 #include "BsDragAndDropManager.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	EditorWindow::EditorWindow()
 		:EditorWindowBase(), mWidgets(cm_new<EditorWidgetContainer>(mGUI.get(), mRenderWindow.get(), this))

BansheeEditor/Source/BsEditorWindowBase.cpp

@@ -9,10 +9,7 @@
 #include "BsGUIWindowFrameWidget.h"
 #include "BsEditorGUI.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	EditorWindowBase::EditorWindowBase()
 		:mOwnsRenderWindow(true)
@@ -30,7 +27,7 @@ namespace BansheeEditor
 		construct(mRenderWindow);
 	}
 
-	EditorWindowBase::EditorWindowBase(const CM::RenderWindowPtr& renderWindow)
+	EditorWindowBase::EditorWindowBase(const RenderWindowPtr& renderWindow)
 		:mOwnsRenderWindow(false)
 	{
 		construct(renderWindow);
@@ -84,12 +81,12 @@ namespace BansheeEditor
 		mResizedConn = mCamera->getViewport()->onResized.connect(std::bind(&EditorWindowBase::resized, this));
 	}
 
-	void EditorWindowBase::setPosition(CM::INT32 x, CM::INT32 y)
+	void EditorWindowBase::setPosition(INT32 x, INT32 y)
 	{
 		gCoreAccessor().moveWindow(mRenderWindow, x, y);
 	}
 
-	void EditorWindowBase::setSize(CM::UINT32 width, CM::UINT32 height)
+	void EditorWindowBase::setSize(UINT32 width, UINT32 height)
 	{
 		gCoreAccessor().resizeWindow(mRenderWindow, width, height);
 	}

BansheeEditor/Source/BsEditorWindowManager.cpp

@@ -2,10 +2,7 @@
 #include "BsEditorWindow.h"
 #include "BsMainEditorWindow.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	EditorWindowManager::EditorWindowManager()
 		:mMainWindow(nullptr)
@@ -22,7 +19,7 @@ namespace BansheeEditor
 			cm_delete(mMainWindow);
 	}
 
-	MainEditorWindow* EditorWindowManager::createMain(const CM::RenderWindowPtr& parentRenderWindow)
+	MainEditorWindow* EditorWindowManager::createMain(const RenderWindowPtr& parentRenderWindow)
 	{
 		if(mMainWindow == nullptr)
 			mMainWindow = new (cm_alloc<MainEditorWindow>()) MainEditorWindow(parentRenderWindow);

BansheeEditor/Source/BsGUIColor.cpp

@@ -9,14 +9,11 @@
 #include "BsBuiltinResources.h"
 #include "CmTexture.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const float GUIColor::ALPHA_SPLIT_POSITION = 0.75f;
 
-	GUIColor::GUIColor(const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+	GUIColor::GUIColor(const String& styleName, const GUILayoutOptions& layoutOptions)
 		:GUIElement(styleName, layoutOptions), mColorSprite(nullptr), mAlphaSprite(nullptr)
 	{
 		mColorSprite = cm_new<ImageSprite, PoolAlloc>();
@@ -38,12 +35,12 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIColor* GUIColor::create(const CM::String& styleName)
+	GUIColor* GUIColor::create(const String& styleName)
 	{
 		return new (cm_alloc<GUIColor, PoolAlloc>()) GUIColor(getStyleName<GUIColor>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIColor* GUIColor::create(const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUIColor* GUIColor::create(const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUIColor, PoolAlloc>()) GUIColor(getStyleName<GUIColor>(styleName), GUILayoutOptions::create(layoutOptions));
 	}

BansheeEditor/Source/BsGUIColorField.cpp

@@ -8,13 +8,10 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		const CM::String& labelStyle, const CM::String& colorStyle, const GUILayoutOptions& layoutOptions)
+		const String& labelStyle, const String& colorStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
 	{
 		mLabel = GUILabel::create(labelContent, labelStyle);
@@ -25,7 +22,7 @@ namespace BansheeEditor
 	}
 
 	GUIColorField::GUIColorField(const PrivatelyConstruct& dummy, 
-		const CM::String& labelStyle, const CM::String& colorStyle, const GUILayoutOptions& layoutOptions)
+		const String& labelStyle, const String& colorStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mLabel(nullptr), mColor(nullptr), mLabelWidth(100)
 	{
 		mColor = GUIColor::create(colorStyle);
@@ -39,41 +36,41 @@ namespace BansheeEditor
 	}
 
 	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const GUIOptions& layoutOptions, 
-		const CM::String& labelStyle, const CM::String& toggleStyle)
+		const String& labelStyle, const String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelContent, labelStyle, toggleStyle, 
 			GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const CM::String& labelStyle, 
-		const CM::String& toggleStyle)
+	GUIColorField* GUIColorField::create(const GUIContent& labelContent, const String& labelStyle, 
+		const String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelContent, labelStyle, toggleStyle, 
 			GUILayoutOptions::create());
 	}
 
 	GUIColorField* GUIColorField::create(const HString& labelContent, const GUIOptions& layoutOptions, 
-		const CM::String& labelStyle, const CM::String& toggleStyle)
+		const String& labelStyle, const String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), GUIContent(labelContent), labelStyle, 
 			toggleStyle, GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIColorField* GUIColorField::create( const HString& labelContent, const CM::String& labelStyle, 
-		const CM::String& toggleStyle)
+	GUIColorField* GUIColorField::create( const HString& labelContent, const String& labelStyle, 
+		const String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), GUIContent(labelContent), labelStyle, toggleStyle, 
 			GUILayoutOptions::create());
 	}
 
-	GUIColorField* GUIColorField::create(const GUIOptions& layoutOptions, const CM::String& labelStyle, 
-		const CM::String& toggleStyle)
+	GUIColorField* GUIColorField::create(const GUIOptions& layoutOptions, const String& labelStyle, 
+		const String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelStyle, toggleStyle, 
 			GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIColorField* GUIColorField::create(const CM::String& labelStyle, const CM::String& toggleStyle)
+	GUIColorField* GUIColorField::create(const String& labelStyle, const String& toggleStyle)
 	{
 		return cm_new<GUIColorField>(PrivatelyConstruct(), labelStyle, toggleStyle, GUILayoutOptions::create());
 	}
@@ -83,7 +80,7 @@ namespace BansheeEditor
 		return mColor->getColor();
 	}
 
-	void GUIColorField::setValue(const CM::Color& color)
+	void GUIColorField::setValue(const Color& color)
 	{
 		mColor->setColor(color);
 	}

BansheeEditor/Source/BsGUIDockSlider.cpp

@@ -7,10 +7,7 @@
 #include "BsCursor.h"
 #include "CmPlatform.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const String& GUIDockSlider::getGUITypeName()
 	{
@@ -18,26 +15,26 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIDockSlider::GUIDockSlider(bool horizontal, const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions)
+	GUIDockSlider::GUIDockSlider(bool horizontal, const String& styleName, const GUILayoutOptions& layoutOptions)
 		:GUIButtonBase(styleName, GUIContent(HString(L"")), layoutOptions),
 		mDragInProgress(false), mHorizontal(horizontal), mIsCursorSet(false)
 	{
 
 	}
 
-	GUIDockSlider* GUIDockSlider::create(bool horizontal, const CM::String& styleName)
+	GUIDockSlider* GUIDockSlider::create(bool horizontal, const String& styleName)
 	{
 		return new (cm_alloc<GUIDockSlider, PoolAlloc>()) GUIDockSlider(horizontal, 
 			getStyleName<GUIDockSlider>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIDockSlider* GUIDockSlider::create(bool horizontal, const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUIDockSlider* GUIDockSlider::create(bool horizontal, const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUIDockSlider, PoolAlloc>()) GUIDockSlider(horizontal, 
 			getStyleName<GUIDockSlider>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
-	bool GUIDockSlider::_hasCustomCursor(const CM::Vector2I position, CursorType& type) const
+	bool GUIDockSlider::_hasCustomCursor(const Vector2I position, CursorType& type) const
 	{
 		if(_isInBounds(position))
 		{

BansheeEditor/Source/BsGUIDropButton.cpp

@@ -10,10 +10,7 @@
 #include "CmTexture.h"
 #include "BsDragAndDropManager.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const String& GUIDropButton::getGUITypeName()
 	{
@@ -21,7 +18,7 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIDropButton::GUIDropButton(CM::UINT32 dragType, const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+	GUIDropButton::GUIDropButton(UINT32 dragType, const String& styleName, const GUILayoutOptions& layoutOptions)
 		:GUIButtonBase(styleName, GUIContent(HString(L"None")), layoutOptions)
 	{
 
@@ -30,13 +27,13 @@ namespace BansheeEditor
 	GUIDropButton::~GUIDropButton()
 	{ }
 
-	GUIDropButton* GUIDropButton::create(CM::UINT32 dragType, const CM::String& styleName)
+	GUIDropButton* GUIDropButton::create(UINT32 dragType, const String& styleName)
 	{
 		return new (cm_alloc<GUIDropButton, PoolAlloc>()) GUIDropButton(dragType, 
 			getStyleName<GUIDropButton>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIDropButton* GUIDropButton::create(CM::UINT32 dragType, const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUIDropButton* GUIDropButton::create(UINT32 dragType, const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUIDropButton, PoolAlloc>()) GUIDropButton(dragType, 
 			getStyleName<GUIDropButton>(styleName), GUILayoutOptions::create(layoutOptions));

BansheeEditor/Source/BsGUIFieldBase.cpp

@@ -4,22 +4,19 @@
 #include "BsGUIWidget.h"
 #include "BsGUISkin.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUIFieldBase::DEFAULT_LABEL_WIDTH = 100;
 
 	GUIFieldBase::GUIFieldBase(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
-		const CM::String& labelStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const String& labelStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:GUIElementContainer(layoutOptions)
 	{
 		mLayout = &addLayoutXInternal(this);
 
 		if(withLabel)
 		{
-			mLabel = BS::GUILabel::create(labelContent, GUIOptions(GUIOption::fixedWidth(labelWidth)), labelStyle);
+			mLabel = GUILabel::create(labelContent, GUIOptions(GUIOption::fixedWidth(labelWidth)), labelStyle);
 			mLayout->addElement(mLabel);
 		}
 	}

BansheeEditor/Source/BsGUIFloatField.cpp

@@ -12,15 +12,12 @@
 #include "CmViewport.h"
 #include <regex>
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const float GUIFloatField::DRAG_SPEED = 0.05f;
 
-	GUIFloatField::GUIFloatField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, CM::UINT32 labelWidth, 
-		const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+	GUIFloatField::GUIFloatField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth, 
+		const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mInputBox(nullptr), mIsDragging(false),
 		mLastDragPos(0)
 	{
@@ -37,7 +34,7 @@ namespace BansheeEditor
 
 	}
 
-	bool GUIFloatField::_hasCustomCursor(const CM::Vector2I position, CursorType& type) const
+	bool GUIFloatField::_hasCustomCursor(const Vector2I position, CursorType& type) const
 	{
 		RectI draggableArea;
 
@@ -139,7 +136,7 @@ namespace BansheeEditor
 		return typeName;
 	}
 
-	bool GUIFloatField::floatFilter(const CM::WString& str)
+	bool GUIFloatField::floatFilter(const WString& str)
 	{
 		return std::regex_match(str, std::wregex(L"-?(\\d+(\\.\\d*)?)?"));
 	}

BansheeEditor/Source/BsGUIFoldout.cpp

@@ -8,16 +8,13 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const String GUIFoldout::FOLDOUT_BUTTON_STYLE = "FoldoutButton";
 	const String GUIFoldout::FOLDOUT_BG_STYLE = "FoldoutBackground";
 
-	GUIFoldout::GUIFoldout(const PrivatelyConstruct& dummy, const CM::String& toggleStyle, 
-		const CM::String& backgroundStyle, const BS::GUILayoutOptions& layoutOptions)
+	GUIFoldout::GUIFoldout(const PrivatelyConstruct& dummy, const String& toggleStyle, 
+		const String& backgroundStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mToggle(nullptr), mBackground(nullptr), mIsExpanded(false)
 	{
 		mToggle = GUIToggle::create(HString(L""), toggleStyle);
@@ -33,7 +30,7 @@ namespace BansheeEditor
 	}
 
 	GUIFoldout* GUIFoldout::create(const GUIOptions& layoutOptions, 
-		const CM::String& toggleStyle, const CM::String& backgroundStyle)
+		const String& toggleStyle, const String& backgroundStyle)
 	{
 		const String* curToggleStyle = &toggleStyle;
 		if(*curToggleStyle == StringUtil::BLANK)
@@ -47,8 +44,8 @@ namespace BansheeEditor
 			GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUIFoldout* GUIFoldout::create(const CM::String& toggleStyle, 
-		const CM::String& backgroundStyle)
+	GUIFoldout* GUIFoldout::create(const String& toggleStyle, 
+		const String& backgroundStyle)
 	{
 		const String* curToggleStyle = &toggleStyle;
 		if(*curToggleStyle == StringUtil::BLANK)

BansheeEditor/Source/BsGUIGameObjectField.cpp

@@ -11,18 +11,16 @@
 #include "BsGUIWidget.h"
 #include "CmGameObjectManager.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUIGameObjectField::DEFAULT_LABEL_WIDTH = 100;
 	const String GUIGameObjectField::DROP_BUTTON_STYLE = "DropButton";
 	const String GUIGameObjectField::CLEAR_BUTTON_STYLE = "ObjectClearButton";
 
-	GUIGameObjectField::GUIGameObjectField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, CM::UINT32 labelWidth,
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+	GUIGameObjectField::GUIGameObjectField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:GUIElementContainer(layoutOptions), mLabel(nullptr), mClearButton(nullptr), mDropButton(nullptr), mInstanceId(0)
 	{
 		mLayout = &addLayoutXInternal(this);
@@ -56,76 +54,76 @@ namespace BansheeEditor
 
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const GUIContent& labelContent, UINT32 labelWidth, const GUIOptions& layoutOptions, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(layoutOptions), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, const BS::GUIOptions& layoutOptions, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const GUIContent& labelContent, const GUIOptions& layoutOptions, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(layoutOptions), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, CM::UINT32 labelWidth, const BS::GUIOptions& layoutOptions, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const HString& labelText, UINT32 labelWidth, const GUIOptions& layoutOptions, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
-		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
+		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), GUIContent(labelText), labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(layoutOptions), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, const BS::GUIOptions& layoutOptions, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const HString& labelText, const GUIOptions& layoutOptions, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
-		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle, 
+		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle, 
 			GUILayoutOptions::create(layoutOptions), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIOptions& layoutOptions, const CM::String& dropButtonStyle,
-		const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const GUIOptions& layoutOptions, const String& dropButtonStyle,
+		const String& clearButtonStyle)
 	{
-		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, dropButtonStyle, clearButtonStyle,
+		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), GUIContent(), 0, nullptr, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(layoutOptions), false);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, CM::UINT32 labelWidth, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const GUIContent& labelContent, UINT32 labelWidth, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const BS::GUIContent& labelContent, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const GUIContent& labelContent, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
 		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), labelContent, DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, CM::UINT32 labelWidth, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const HString& labelText, UINT32 labelWidth, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
-		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
+		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), GUIContent(labelText), labelWidth, labelStyle, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const CM::HString& labelText, 
-		const CM::String& labelStyle, const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const HString& labelText, 
+		const String& labelStyle, const String& dropButtonStyle, const String& clearButtonStyle)
 	{
-		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle, 
+		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), GUIContent(labelText), DEFAULT_LABEL_WIDTH, labelStyle, dropButtonStyle, clearButtonStyle, 
 			GUILayoutOptions::create(), true);
 	}
 
-	GUIGameObjectField* GUIGameObjectField::create(const CM::String& dropButtonStyle, const CM::String& clearButtonStyle)
+	GUIGameObjectField* GUIGameObjectField::create(const String& dropButtonStyle, const String& clearButtonStyle)
 	{
-		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), BS::GUIContent(), 0, nullptr, dropButtonStyle, clearButtonStyle,
+		return cm_new<GUIGameObjectField>(PrivatelyConstruct(), GUIContent(), 0, nullptr, dropButtonStyle, clearButtonStyle,
 			GUILayoutOptions::create(), false);
 	}
 
-	CM::HGameObject GUIGameObjectField::getValue() const
+	HGameObject GUIGameObjectField::getValue() const
 	{
 		HGameObject obj;
 
@@ -135,7 +133,7 @@ namespace BansheeEditor
 		return obj;
 	}
 
-	void GUIGameObjectField::setValue(const CM::HGameObject& value)
+	void GUIGameObjectField::setValue(const HGameObject& value)
 	{
 		if(value)
 		{

BansheeEditor/Source/BsGUIIntField.cpp

@@ -12,15 +12,12 @@
 #include "CmViewport.h"
 #include <regex>
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const INT32 GUIIntField::DRAG_SPEED = 5;
 
 	GUIIntField::GUIIntField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth,
-		const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mInputBox(nullptr), mIsDragging(false),
 		mLastDragPos(0), mIsDragCursorSet(false)
 	{
@@ -37,7 +34,7 @@ namespace BansheeEditor
 
 	}
 
-	bool GUIIntField::_hasCustomCursor(const CM::Vector2I position, CursorType& type) const
+	bool GUIIntField::_hasCustomCursor(const Vector2I position, CursorType& type) const
 	{
 		RectI draggableArea;
 
@@ -134,12 +131,12 @@ namespace BansheeEditor
 		return false;
 	}
 
-	CM::INT32 GUIIntField::getValue() const
+	INT32 GUIIntField::getValue() const
 	{
 		return parseInt(mInputBox->getText());
 	}
 
-	void GUIIntField::setValue(CM::INT32 value)
+	void GUIIntField::setValue(INT32 value)
 	{
 		mInputBox->setText(toWString(value));
 	}
@@ -156,7 +153,7 @@ namespace BansheeEditor
 		return typeName;
 	}
 
-	bool GUIIntField::intFilter(const CM::WString& str)
+	bool GUIIntField::intFilter(const WString& str)
 	{
 		return std::regex_match(str, std::wregex(L"-?(\\d+)?"));
 	}

BansheeEditor/Source/BsGUIMenuBar.cpp

@@ -12,14 +12,11 @@
 #include "CmSceneObject.h"
 #include "CmPlatform.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUIMenuBar::NUM_ELEMENTS_AFTER_CONTENT = 8;
 
-	GUIMenuBar::GUIMenuBar(BS::GUIWidget* parent, RenderWindow* parentWindow)
+	GUIMenuBar::GUIMenuBar(GUIWidget* parent, RenderWindow* parentWindow)
 		:mParentWidget(parent), mParentWindow(parentWindow), mMainArea(nullptr), mBackgroundArea(nullptr), 
 		mBgTexture(nullptr), mLogoTexture(nullptr), mSubMenuOpen(false), mSubMenuButton(nullptr)
 	{
@@ -76,7 +73,7 @@ namespace BansheeEditor
 		GUIArea::destroy(mBackgroundArea);
 	}
 
-	void GUIMenuBar::setArea(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height)
+	void GUIMenuBar::setArea(INT32 x, INT32 y, UINT32 width, UINT32 height)
 	{
 		mMainArea->setPosition(x, y);
 		mBackgroundArea->setPosition(x, y);
@@ -87,7 +84,7 @@ namespace BansheeEditor
 		refreshNonClientAreas();
 	}
 
-	const GUIMenuItem* GUIMenuBar::addMenuItem(const CM::WString& path, std::function<void()> callback)
+	const GUIMenuItem* GUIMenuBar::addMenuItem(const WString& path, std::function<void()> callback)
 	{
 		WString strippedPath = path;
 		WString rootName;
@@ -106,7 +103,7 @@ namespace BansheeEditor
 		return subMenu->menu->addMenuItem(strippedPath, callback);
 	}
 
-	const GUIMenuItem* GUIMenuBar::addSeparator(const CM::WString& path)
+	const GUIMenuItem* GUIMenuBar::addSeparator(const WString& path)
 	{
 		WString strippedPath = path;
 		WString rootName;
@@ -125,7 +122,7 @@ namespace BansheeEditor
 		return subMenu->menu->addSeparator(strippedPath);
 	}
 
-	GUIMenuBar::GUIMenuBarData* GUIMenuBar::addNewButton(const CM::WString& name)
+	GUIMenuBar::GUIMenuBarData* GUIMenuBar::addNewButton(const WString& name)
 	{
 		mChildMenus.push_back(GUIMenuBarData());
 
@@ -143,7 +140,7 @@ namespace BansheeEditor
 		return &newSubMenu;
 	}
 
-	const GUIMenuItem* GUIMenuBar::getMenuItem(const CM::WString& path) const
+	const GUIMenuItem* GUIMenuBar::getMenuItem(const WString& path) const
 	{
 		WString strippedPath = path;
 		WString rootName;
@@ -158,7 +155,7 @@ namespace BansheeEditor
 		return subMenu->menu->getMenuItem(strippedPath);
 	}
 
-	void GUIMenuBar::removeMenuItem(const CM::WString& path)
+	void GUIMenuBar::removeMenuItem(const WString& path)
 	{
 		WString strippedPath = path;
 		WString rootName;
@@ -205,7 +202,7 @@ namespace BansheeEditor
 		subMenu->menu->removeMenuItem(item);
 	}
 
-	const GUIMenuBar::GUIMenuBarData* GUIMenuBar::getSubMenu(const CM::WString& name) const
+	const GUIMenuBar::GUIMenuBarData* GUIMenuBar::getSubMenu(const WString& name) const
 	{
 		for(auto& subMenu : mChildMenus)
 		{
@@ -216,7 +213,7 @@ namespace BansheeEditor
 		return nullptr;
 	}
 
-	bool GUIMenuBar::stripPath(CM::WString& path, CM::WString& pathRoot) const
+	bool GUIMenuBar::stripPath(WString& path, WString& pathRoot) const
 	{
 		Vector<WString>::type pathElements = StringUtil::split(path, L"/");
 		if(pathElements.size() == 0)
@@ -231,7 +228,7 @@ namespace BansheeEditor
 		return true;
 	}
 
-	void GUIMenuBar::openSubMenu(const CM::WString& name)
+	void GUIMenuBar::openSubMenu(const WString& name)
 	{
 		const GUIMenuBarData* subMenu = getSubMenu(name);
 		if(subMenu == nullptr)
@@ -272,7 +269,7 @@ namespace BansheeEditor
 		}		
 	}
 
-	void GUIMenuBar::onSubMenuHover(const CM::WString& name)
+	void GUIMenuBar::onSubMenuHover(const WString& name)
 	{
 		if(mSubMenuOpen)
 		{
@@ -313,7 +310,7 @@ namespace BansheeEditor
 		// so force the update right away so we get correct element bounds
 		mMainArea->_update();
 
-		CM::Vector<CM::RectI>::type nonClientAreas;
+		Vector<RectI>::type nonClientAreas;
 		nonClientAreas.push_back(mLogoTexture->getBounds());
 
 		if(mChildMenus.size() > 0)

BansheeEditor/Source/BsGUIResourceTreeView.cpp

@@ -12,11 +12,9 @@
 #include "CmPlatform.h"
 #include "CmPath.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	GUIResourceTreeView::InternalDraggedResources::InternalDraggedResources(UINT32 numObjects)
 		:numObjects(numObjects)
@@ -30,9 +28,9 @@ namespace BansheeEditor
 		resourcePaths = nullptr;
 	}
 
-	GUIResourceTreeView::GUIResourceTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
-		const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
+	GUIResourceTreeView::GUIResourceTreeView(const String& backgroundStyle, const String& elementBtnStyle, 
+		const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, 
+		const String& dragHighlightStyle, const String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
 		:GUITreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle,
 		dragSepHighlightStyle, layoutOptions), mDraggedResources(nullptr), mCurrentWindow(nullptr), mDropTarget(nullptr), mDropTargetDragActive(false)
 	{
@@ -53,17 +51,17 @@ namespace BansheeEditor
 		clearDropTarget();
 	}
 
-	GUIResourceTreeView* GUIResourceTreeView::create(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, 
-		const CM::String& dragSepHighlightStyle)
+	GUIResourceTreeView* GUIResourceTreeView::create(const String& backgroundStyle, const String& elementBtnStyle, 
+		const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, const String& dragHighlightStyle, 
+		const String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUIResourceTreeView, PoolAlloc>()) GUIResourceTreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, 
 			selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create());
 	}
 
-	GUIResourceTreeView* GUIResourceTreeView::create(const GUIOptions& options, const CM::String& backgroundStyle,
-		const CM::String& elementBtnStyle, const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, 
-		const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle)
+	GUIResourceTreeView* GUIResourceTreeView::create(const GUIOptions& options, const String& backgroundStyle,
+		const String& elementBtnStyle, const String& foldoutBtnStyle, const String& selectionBackgroundStyle, 
+		const String& editBoxStyle, const String& dragHighlightStyle, const String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUIResourceTreeView, PoolAlloc>()) GUIResourceTreeView(backgroundStyle, elementBtnStyle, 
 			foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(options));
@@ -84,7 +82,7 @@ namespace BansheeEditor
 		// Do nothing, updates are handled via callbacks
 	}
 
-	void GUIResourceTreeView::renameTreeElement(GUITreeView::TreeElement* element, const CM::WString& name)
+	void GUIResourceTreeView::renameTreeElement(GUITreeView::TreeElement* element, const WString& name)
 	{
 		ResourceTreeElement* resourceTreeElement = static_cast<ResourceTreeElement*>(element);
 		
@@ -138,7 +136,7 @@ namespace BansheeEditor
 		}
 	}
 
-	GUIResourceTreeView::ResourceTreeElement* GUIResourceTreeView::addTreeElement(ResourceTreeElement* parent, const CM::WString& fullPath)
+	GUIResourceTreeView::ResourceTreeElement* GUIResourceTreeView::addTreeElement(ResourceTreeElement* parent, const WString& fullPath)
 	{
 		ResourceTreeElement* newChild = cm_new<ResourceTreeElement>();
 		newChild->mParent = parent;
@@ -194,7 +192,7 @@ namespace BansheeEditor
 		}
 	}
 
-	GUIResourceTreeView::ResourceTreeElement* GUIResourceTreeView::findTreeElement(const CM::WString& fullPath)
+	GUIResourceTreeView::ResourceTreeElement* GUIResourceTreeView::findTreeElement(const WString& fullPath)
 	{
 		Vector<WString>::type pathElems = Path::split(fullPath);
 		Vector<WString>::type rootElems = Path::split(mRootElement.mFullPath);
@@ -265,7 +263,7 @@ namespace BansheeEditor
 			deleteTreeElement(treeElement);
 	}
 
-	void GUIResourceTreeView::setDropTarget(CM::RenderWindow* parentWindow, CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height)
+	void GUIResourceTreeView::setDropTarget(RenderWindow* parentWindow, INT32 x, INT32 y, UINT32 width, UINT32 height)
 	{
 		if(mDropTarget != nullptr)
 		{
@@ -296,7 +294,7 @@ namespace BansheeEditor
 		setDropTarget(nullptr, 0, 0, 0, 0);
 	}
 
-	void GUIResourceTreeView::dropTargetDragMove(CM::INT32 x, CM::INT32 y)
+	void GUIResourceTreeView::dropTargetDragMove(INT32 x, INT32 y)
 	{
 		mDragPosition = Vector2I(x, y);
 		mDragInProgress = true;
@@ -324,7 +322,7 @@ namespace BansheeEditor
 		markContentAsDirty();
 	}
 
-	void GUIResourceTreeView::dropTargetDragDropped(CM::INT32 x, CM::INT32 y)
+	void GUIResourceTreeView::dropTargetDragDropped(INT32 x, INT32 y)
 	{
 		const GUITreeView::InteractableElement* element = findElementUnderCoord(Vector2I(x, y));
 
@@ -358,7 +356,7 @@ namespace BansheeEditor
 		markContentAsDirty();
 	}
 
-	CM::WString GUIResourceTreeView::findUniquePath(const CM::WString& path)
+	WString GUIResourceTreeView::findUniquePath(const WString& path)
 	{
 		if(FileSystem::exists(path))
 		{
@@ -463,7 +461,7 @@ namespace BansheeEditor
 			clearDropTarget();
 	}
 
-	bool GUIResourceTreeView::_acceptDragAndDrop(const CM::Vector2I position, CM::UINT32 typeId) const
+	bool GUIResourceTreeView::_acceptDragAndDrop(const Vector2I position, UINT32 typeId) const
 	{
 		return typeId == (UINT32)DragAndDropType::Resources;
 	}

BansheeEditor/Source/BsGUISceneTreeView.cpp

@@ -6,10 +6,7 @@
 #include "BsDragAndDropManager.h"
 #include "BsCmdReparentSO.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	DraggedSceneObjects::DraggedSceneObjects(UINT32 numObjects)
 		:numObjects(numObjects)
@@ -23,9 +20,9 @@ namespace BansheeEditor
 		objects = nullptr;
 	}
 
-	GUISceneTreeView::GUISceneTreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
-		const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
+	GUISceneTreeView::GUISceneTreeView(const String& backgroundStyle, const String& elementBtnStyle, 
+		const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, 
+		const String& dragHighlightStyle, const String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
 		:GUITreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle,
 		dragSepHighlightStyle, layoutOptions)
 	{
@@ -37,17 +34,17 @@ namespace BansheeEditor
 		
 	}
 
-	GUISceneTreeView* GUISceneTreeView::create(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, 
-		const CM::String& dragSepHighlightStyle)
+	GUISceneTreeView* GUISceneTreeView::create(const String& backgroundStyle, const String& elementBtnStyle, 
+		const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, const String& dragHighlightStyle, 
+		const String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUISceneTreeView, PoolAlloc>()) GUISceneTreeView(backgroundStyle, elementBtnStyle, foldoutBtnStyle, 
 			selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create());
 	}
 
-	GUISceneTreeView* GUISceneTreeView::create(const GUIOptions& options, const CM::String& backgroundStyle,
-		const CM::String& elementBtnStyle, const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, 
-		const CM::String& editBoxStyle, const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle)
+	GUISceneTreeView* GUISceneTreeView::create(const GUIOptions& options, const String& backgroundStyle,
+		const String& elementBtnStyle, const String& foldoutBtnStyle, const String& selectionBackgroundStyle, 
+		const String& editBoxStyle, const String& dragHighlightStyle, const String& dragSepHighlightStyle)
 	{
 		return new (cm_alloc<GUISceneTreeView, PoolAlloc>()) GUISceneTreeView(backgroundStyle, elementBtnStyle, 
 			foldoutBtnStyle, selectionBackgroundStyle, editBoxStyle, dragHighlightStyle, dragSepHighlightStyle, GUILayoutOptions::create(options));
@@ -178,7 +175,7 @@ namespace BansheeEditor
 
 	void GUISceneTreeView::updateTreeElementHierarchy()
 	{
-		HSceneObject root = CM::gSceneManager().getRootNode();
+		HSceneObject root = gSceneManager().getRootNode();
 		mRootElement.mSceneObject = root;
 		mRootElement.mId = root->getInstanceId();
 		mRootElement.mSortedIdx = 0;
@@ -187,7 +184,7 @@ namespace BansheeEditor
 		updateTreeElement(&mRootElement);
 	}
 
-	void GUISceneTreeView::renameTreeElement(GUITreeView::TreeElement* element, const CM::WString& name)
+	void GUISceneTreeView::renameTreeElement(GUITreeView::TreeElement* element, const WString& name)
 	{
 		SceneTreeElement* sceneTreeElement = static_cast<SceneTreeElement*>(element);
 		CmdEditPlainFieldGO<String>::execute(sceneTreeElement->mSceneObject, "mName", toString(name));
@@ -258,7 +255,7 @@ namespace BansheeEditor
 		cm_delete(draggedSceneObjects);
 	}
 
-	bool GUISceneTreeView::_acceptDragAndDrop(const CM::Vector2I position, CM::UINT32 typeId) const
+	bool GUISceneTreeView::_acceptDragAndDrop(const Vector2I position, UINT32 typeId) const
 	{
 		return typeId == (UINT32)DragAndDropType::SceneObject;
 	}

BansheeEditor/Source/BsGUITabButton.cpp

@@ -5,12 +5,9 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUITabbedTitleBar.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	const CM::UINT32 GUITabButton::DRAG_MIN_DISTANCE = 3;
+	const UINT32 GUITabButton::DRAG_MIN_DISTANCE = 3;
 
 	const String& GUITabButton::getGUITypeName()
 	{
@@ -18,36 +15,36 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUITabButton::GUITabButton(const CM::String& styleName, const GUIToggleGroupPtr& toggleGroup, 
-		CM::UINT32 index, const GUIContent& content, const GUILayoutOptions& layoutOptions)
+	GUITabButton::GUITabButton(const String& styleName, const GUIToggleGroupPtr& toggleGroup, 
+		UINT32 index, const GUIContent& content, const GUILayoutOptions& layoutOptions)
 		:GUIToggle(styleName, content, toggleGroup, layoutOptions), mIndex(index), mDraggedState(false)
 	{
 
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
-		const HString& text, const CM::String& styleName)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, 
+		const HString& text, const String& styleName)
 	{
 		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
 			getStyleName<GUITabButton>(styleName), toggleGroup, index, GUIContent(text), GUILayoutOptions::create());
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
-		const HString& text, const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, 
+		const HString& text, const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
 			getStyleName<GUITabButton>(styleName), toggleGroup, index, GUIContent(text), GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
-		const GUIContent& content, const CM::String& styleName)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, 
+		const GUIContent& content, const String& styleName)
 	{
 		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
 			getStyleName<GUITabButton>(styleName), toggleGroup, index, content, GUILayoutOptions::create());
 	}
 
-	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, CM::UINT32 index, 
-		const GUIContent& content, const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUITabButton* GUITabButton::create(const GUIToggleGroupPtr& toggleGroup, UINT32 index, 
+		const GUIContent& content, const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUITabButton, PoolAlloc>()) GUITabButton(
 			getStyleName<GUITabButton>(styleName), toggleGroup, index, content, GUILayoutOptions::create(layoutOptions));

BansheeEditor/Source/BsGUITabbedTitleBar.cpp

@@ -14,33 +14,31 @@
 #include "CmMath.h"
 #include "CmPlatform.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUITabbedTitleBar::TAB_SPACING = 20;
 	const UINT32 GUITabbedTitleBar::OPTION_BTN_SPACING = 3;
 
-	GUITabbedTitleBar::GUITabbedTitleBar(RenderWindow* parentWindow, const CM::String& backgroundStyle, const CM::String& tabBtnStyle, 
-		const CM::String& minBtnStyle, const CM::String& closeBtnStyle, const GUILayoutOptions& layoutOptions)
+	GUITabbedTitleBar::GUITabbedTitleBar(RenderWindow* parentWindow, const String& backgroundStyle, const String& tabBtnStyle, 
+		const String& minBtnStyle, const String& closeBtnStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mParentWindow(parentWindow), mMinBtn(nullptr), 
 		mCloseBtn(nullptr), mBackgroundImage(nullptr), mUniqueTabIdx(0), mActiveTabIdx(0),
 		mDragInProgress(false), mDraggedBtn(nullptr), mDragBtnOffset(0), mInitialDragOffset(0), mBackgroundStyle(backgroundStyle),
 		mTabBtnStyle(tabBtnStyle), mMinimizeBtnStyle(minBtnStyle), mCloseBtnStyle(closeBtnStyle), mTempDraggedWidget(nullptr),
 		mTempDraggedTabIdx(0)
 	{
-		if(mBackgroundStyle == CM::StringUtil::BLANK)
+		if(mBackgroundStyle == StringUtil::BLANK)
 			mBackgroundStyle = "TitleBarBackground";
 
-		if(mMinimizeBtnStyle == CM::StringUtil::BLANK)
+		if(mMinimizeBtnStyle == StringUtil::BLANK)
 			mMinimizeBtnStyle = "WinMinimizeBtn";
 
-		if(mCloseBtnStyle == CM::StringUtil::BLANK)
+		if(mCloseBtnStyle == StringUtil::BLANK)
 			mCloseBtnStyle = "WinCloseBtn";
 
-		if(mTabBtnStyle == CM::StringUtil::BLANK)
+		if(mTabBtnStyle == StringUtil::BLANK)
 			mTabBtnStyle = "TabbedBarBtn";
 
 		mBackgroundImage = GUITexture::create(mBackgroundStyle);
@@ -62,26 +60,26 @@ namespace BansheeEditor
 
 	}
 
-	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, const CM::String& backgroundStyle, 
-		const CM::String& tabBtnStyle, const CM::String& minBtnStyle, const CM::String& closeBtnStyle)
+	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, const String& backgroundStyle, 
+		const String& tabBtnStyle, const String& minBtnStyle, const String& closeBtnStyle)
 	{
 		return new (cm_alloc<GUITabbedTitleBar, PoolAlloc>()) GUITabbedTitleBar(parentWindow, backgroundStyle, tabBtnStyle, 
 			minBtnStyle, closeBtnStyle, GUILayoutOptions::create());
 	}
 
 	GUITabbedTitleBar* GUITabbedTitleBar::create(RenderWindow* parentWindow, const GUILayoutOptions& layoutOptions, 
-		const CM::String& backgroundStyle, const CM::String& tabBtnStyle, const CM::String& minBtnStyle, const CM::String& closeBtnStyle)
+		const String& backgroundStyle, const String& tabBtnStyle, const String& minBtnStyle, const String& closeBtnStyle)
 	{
 		return new (cm_alloc<GUITabbedTitleBar, PoolAlloc>()) GUITabbedTitleBar(parentWindow, backgroundStyle, tabBtnStyle, 
 			minBtnStyle, closeBtnStyle, layoutOptions);
 	}
 
-	void GUITabbedTitleBar::addTab(const CM::HString& name)
+	void GUITabbedTitleBar::addTab(const HString& name)
 	{
 		insertTab((UINT32)mTabButtons.size(), name);
 	}
 
-	UINT32 GUITabbedTitleBar::insertTab(UINT32 position, const CM::HString& name)
+	UINT32 GUITabbedTitleBar::insertTab(UINT32 position, const HString& name)
 	{
 		GUITabButton* newTabToggle = GUITabButton::create(mTabToggleGroup, mUniqueTabIdx, name, mTabBtnStyle);
 		_registerChildElement(newTabToggle);
@@ -117,7 +115,7 @@ namespace BansheeEditor
 		mTabButtons[uniqueIdxToSeqIdx(uniqueIdx)]->toggleOn();
 	}
 
-	CM::UINT32 GUITabbedTitleBar::getTabIdx(CM::UINT32 position) const
+	UINT32 GUITabbedTitleBar::getTabIdx(UINT32 position) const
 	{
 		return mTabButtons[position]->getIndex();
 	}
@@ -321,9 +319,9 @@ namespace BansheeEditor
 		}
 	}
 
-	Vector<RectI>::type GUITabbedTitleBar::calcDraggableAreas(CM::INT32 x, CM::INT32 y, CM::UINT32 width, CM::UINT32 height) const
+	Vector<RectI>::type GUITabbedTitleBar::calcDraggableAreas(INT32 x, INT32 y, UINT32 width, UINT32 height) const
 	{
-		CM::Vector<CM::RectI>::type draggableAreas;
+		Vector<RectI>::type draggableAreas;
 
 		UINT32 curX = x + 1;
 		UINT32 curY = y;
@@ -349,7 +347,7 @@ namespace BansheeEditor
 		return draggableAreas;
 	}
 
-	void GUITabbedTitleBar::tabToggled(CM::UINT32 tabIdx, bool toggledOn)
+	void GUITabbedTitleBar::tabToggled(UINT32 tabIdx, bool toggledOn)
 	{
 		if(!toggledOn)
 			return;
@@ -371,7 +369,7 @@ namespace BansheeEditor
 			mActiveTabIdx = mTabButtons[0]->getIndex();
 	}
 
-	void GUITabbedTitleBar::startDrag(CM::UINT32 seqIdx, const Vector2I& startDragPos)
+	void GUITabbedTitleBar::startDrag(UINT32 seqIdx, const Vector2I& startDragPos)
 	{
 		if(!mDragInProgress)
 		{
@@ -397,7 +395,7 @@ namespace BansheeEditor
 		mDraggedBtn = nullptr;
 	}
 
-	void GUITabbedTitleBar::tabDragged(CM::UINT32 tabIdx, const Vector2I& dragPos)
+	void GUITabbedTitleBar::tabDragged(UINT32 tabIdx, const Vector2I& dragPos)
 	{
 		INT32 idx = uniqueIdxToSeqIdx(tabIdx);
 		if(idx != -1)
@@ -453,7 +451,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void GUITabbedTitleBar::tabDragEnd(CM::UINT32 tabIdx, const Vector2I& dragPos)
+	void GUITabbedTitleBar::tabDragEnd(UINT32 tabIdx, const Vector2I& dragPos)
 	{
 		endDrag();
 
@@ -463,7 +461,7 @@ namespace BansheeEditor
 		markContentAsDirty();
 	}
 
-	CM::INT32 GUITabbedTitleBar::uniqueIdxToSeqIdx(CM::UINT32 uniqueIdx) const
+	INT32 GUITabbedTitleBar::uniqueIdxToSeqIdx(UINT32 uniqueIdx) const
 	{
 		UINT32 idx = 0;
 		for(auto& tab : mTabButtons)

BansheeEditor/Source/BsGUITextField.cpp

@@ -8,13 +8,10 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	GUITextField::GUITextField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, CM::UINT32 labelWidth, 
-		const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+	GUITextField::GUITextField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, UINT32 labelWidth, 
+		const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mInputBox(nullptr)
 	{
 		mInputBox = GUIInputBox::create(false, inputBoxStyle);

BansheeEditor/Source/BsGUIToggleField.cpp

@@ -8,13 +8,10 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	GUIToggleField::GUIToggleField(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		UINT32 labelWidth, const CM::String& labelStyle, const CM::String& toggleStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		UINT32 labelWidth, const String& labelStyle, const String& toggleStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mToggle(nullptr)
 	{
 		mToggle = GUIToggle::create(HString(L""), toggleStyle);

BansheeEditor/Source/BsGUITreeView.cpp

@@ -16,11 +16,9 @@
 #include "BsDragAndDropManager.h"
 #include "CmTime.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUITreeView::ELEMENT_EXTRA_SPACING = 3;
 	const UINT32 GUITreeView::INDENT_SIZE = 10;
@@ -82,34 +80,34 @@ namespace BansheeEditor
 		return nullptr;
 	}
 
-	GUITreeView::GUITreeView(const CM::String& backgroundStyle, const CM::String& elementBtnStyle, 
-		const CM::String& foldoutBtnStyle, const CM::String& selectionBackgroundStyle, const CM::String& editBoxStyle, 
-		const CM::String& dragHighlightStyle, const CM::String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
+	GUITreeView::GUITreeView(const String& backgroundStyle, const String& elementBtnStyle, 
+		const String& foldoutBtnStyle, const String& selectionBackgroundStyle, const String& editBoxStyle, 
+		const String& dragHighlightStyle, const String& dragSepHighlightStyle, const GUILayoutOptions& layoutOptions)
 		:GUIElementContainer(layoutOptions), mBackgroundStyle(backgroundStyle),
 		mElementBtnStyle(elementBtnStyle), mFoldoutBtnStyle(foldoutBtnStyle), mEditBoxStyle(editBoxStyle), mEditElement(nullptr), mIsElementSelected(false),
 		mNameEditBox(nullptr), mSelectionBackgroundStyle(selectionBackgroundStyle), mDragInProgress(nullptr), mDragHighlightStyle(dragHighlightStyle),
 		mDragSepHighlightStyle(dragSepHighlightStyle), mDragHighlight(nullptr), mDragSepHighlight(nullptr), mMouseOverDragElement(nullptr), mMouseOverDragElementTime(0.0f),
 		mScrollState(ScrollState::None), mLastScrollTime(0.0f)
 	{
-		if(mBackgroundStyle == CM::StringUtil::BLANK)
+		if(mBackgroundStyle == StringUtil::BLANK)
 			mBackgroundStyle = "TreeViewBackground";
 
-		if(mElementBtnStyle == CM::StringUtil::BLANK)
+		if(mElementBtnStyle == StringUtil::BLANK)
 			mElementBtnStyle = "TreeViewElementBtn";
 
-		if(mFoldoutBtnStyle == CM::StringUtil::BLANK)
+		if(mFoldoutBtnStyle == StringUtil::BLANK)
 			mFoldoutBtnStyle = "TreeViewFoldoutBtn";
 
-		if(mSelectionBackgroundStyle == CM::StringUtil::BLANK)
+		if(mSelectionBackgroundStyle == StringUtil::BLANK)
 			mSelectionBackgroundStyle = "TreeViewSelectionBackground";
 
-		if(mEditBoxStyle == CM::StringUtil::BLANK)
+		if(mEditBoxStyle == StringUtil::BLANK)
 			mEditBoxStyle = "TreeViewEditBox";
 
-		if(mDragHighlightStyle == CM::StringUtil::BLANK)
+		if(mDragHighlightStyle == StringUtil::BLANK)
 			mDragHighlightStyle = "TreeViewElementHighlight";
 
-		if(mDragSepHighlightStyle == CM::StringUtil::BLANK)
+		if(mDragSepHighlightStyle == StringUtil::BLANK)
 			mDragSepHighlightStyle = "TreeViewElementSepHighlight";
 
 		mBackgroundImage = GUITexture::create(mBackgroundStyle);
@@ -431,7 +429,7 @@ namespace BansheeEditor
 		return false;
 	}
 
-	bool GUITreeView::virtualButtonEvent(const BS::GUIVirtualButtonEvent& ev)
+	bool GUITreeView::virtualButtonEvent(const GUIVirtualButtonEvent& ev)
 	{
 		if(ev.getButton() == mRenameVB)
 		{
@@ -1012,7 +1010,7 @@ namespace BansheeEditor
 		mBottomScrollBounds.height = scrollHeight;
 	}
 
-	const GUITreeView::InteractableElement* GUITreeView::findElementUnderCoord(const CM::Vector2I& coord) const
+	const GUITreeView::InteractableElement* GUITreeView::findElementUnderCoord(const Vector2I& coord) const
 	{
 		for(auto& element : mVisibleElements)
 		{

BansheeEditor/Source/BsGUITreeViewEditBox.cpp

@@ -3,34 +3,31 @@
 #include "BsGUIWidget.h"
 #include "BsGUISkin.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	const CM::String& GUITreeViewEditBox::getGUITypeName()
+	const String& GUITreeViewEditBox::getGUITypeName()
 	{
 		static String name = "TreeViewEditBox";
 		return name;
 	}
 
-	GUITreeViewEditBox* GUITreeViewEditBox::create(const CM::String& styleName)
+	GUITreeViewEditBox* GUITreeViewEditBox::create(const String& styleName)
 	{
 		return new (cm_alloc<GUITreeViewEditBox, PoolAlloc>()) GUITreeViewEditBox(getStyleName<GUITreeViewEditBox>(styleName), GUILayoutOptions::create());
 	}
 
-	GUITreeViewEditBox* GUITreeViewEditBox::create(const BS::GUIOptions& layoutOptions, const CM::String& styleName)
+	GUITreeViewEditBox* GUITreeViewEditBox::create(const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUITreeViewEditBox, PoolAlloc>()) GUITreeViewEditBox(getStyleName<GUITreeViewEditBox>(styleName), GUILayoutOptions::create(layoutOptions));
 	}
 
-	GUITreeViewEditBox::GUITreeViewEditBox(const CM::String& styleName, const BS::GUILayoutOptions& layoutOptions)
+	GUITreeViewEditBox::GUITreeViewEditBox(const String& styleName, const GUILayoutOptions& layoutOptions)
 		:GUIInputBox(styleName, layoutOptions, false)
 	{
 
 	}
 
-	bool GUITreeViewEditBox::commandEvent(const BS::GUICommandEvent& ev)
+	bool GUITreeViewEditBox::commandEvent(const GUICommandEvent& ev)
 	{
 		bool processed = GUIInputBox::commandEvent(ev);
 

BansheeEditor/Source/BsGUIVector2Field.cpp

@@ -8,15 +8,12 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUIVector2Field::ELEMENT_LABEL_WIDTH = 10;
 
 	GUIVector2Field::GUIVector2Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		UINT32 labelWidth, const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mFieldX(nullptr), mFieldY(nullptr)
 	{
 		mFieldX = GUIFloatField::create(HString(L"X"), ELEMENT_LABEL_WIDTH, labelStyle, inputBoxStyle);

BansheeEditor/Source/BsGUIVector3Field.cpp

@@ -8,15 +8,12 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUIVector3Field::ELEMENT_LABEL_WIDTH = 10;
 
 	GUIVector3Field::GUIVector3Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		UINT32 labelWidth, const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mFieldX(nullptr), mFieldY(nullptr)
 	{
 		mFieldX = GUIFloatField::create(HString(L"X"), ELEMENT_LABEL_WIDTH, labelStyle, inputBoxStyle);

BansheeEditor/Source/BsGUIVector4Field.cpp

@@ -8,15 +8,12 @@
 #include "BsGUIMouseEvent.h"
 #include "BsGUIWidget.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 GUIVector4Field::ELEMENT_LABEL_WIDTH = 10;
 
 	GUIVector4Field::GUIVector4Field(const PrivatelyConstruct& dummy, const GUIContent& labelContent, 
-		CM::UINT32 labelWidth, const CM::String& labelStyle, const CM::String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
+		UINT32 labelWidth, const String& labelStyle, const String& inputBoxStyle, const GUILayoutOptions& layoutOptions, bool withLabel)
 		:TGUIField(dummy, labelContent, labelWidth, labelStyle, layoutOptions, withLabel), mFieldX(nullptr), mFieldY(nullptr)
 	{
 		mFieldX = GUIFloatField::create(HString(L"X"), ELEMENT_LABEL_WIDTH, labelStyle, inputBoxStyle);

BansheeEditor/Source/BsGUIWindowDropArea.cpp

@@ -7,10 +7,7 @@
 #include "BsGUILayoutOptions.h"
 #include "BsGUIMouseEvent.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const String& GUIWindowDropArea::getGUITypeName()
 	{
@@ -18,20 +15,20 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIWindowDropArea::GUIWindowDropArea(const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+	GUIWindowDropArea::GUIWindowDropArea(const String& styleName, const GUILayoutOptions& layoutOptions)
 		:GUITexture(styleName, HSpriteTexture(), GUIImageScaleMode::ScaleToFit, layoutOptions)
 	{ }
 
 	GUIWindowDropArea::~GUIWindowDropArea()
 	{ }
 
-	GUIWindowDropArea* GUIWindowDropArea::create(const CM::String& styleName)
+	GUIWindowDropArea* GUIWindowDropArea::create(const String& styleName)
 	{
 		return new (cm_alloc<GUIWindowDropArea, PoolAlloc>()) 
 			GUIWindowDropArea(getStyleName<GUIWindowDropArea>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIWindowDropArea* GUIWindowDropArea::create(const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUIWindowDropArea* GUIWindowDropArea::create(const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUIWindowDropArea, PoolAlloc>()) 
 			GUIWindowDropArea(getStyleName<GUIWindowDropArea>(styleName), GUILayoutOptions::create(layoutOptions));

BansheeEditor/Source/BsGUIWindowFrame.cpp

@@ -10,10 +10,7 @@
 #include "CmTexture.h"
 #include "CmRenderWindow.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const String& GUIWindowFrame::getGUITypeName()
 	{
@@ -21,7 +18,7 @@ namespace BansheeEditor
 		return name;
 	}
 
-	GUIWindowFrame::GUIWindowFrame(const CM::String& styleName, const GUILayoutOptions& layoutOptions)
+	GUIWindowFrame::GUIWindowFrame(const String& styleName, const GUILayoutOptions& layoutOptions)
 		:GUITexture(styleName, HSpriteTexture(), GUIImageScaleMode::StretchToFit, layoutOptions)
 	{
 
@@ -30,12 +27,12 @@ namespace BansheeEditor
 	GUIWindowFrame::~GUIWindowFrame()
 	{ }
 
-	GUIWindowFrame* GUIWindowFrame::create(const CM::String& styleName)
+	GUIWindowFrame* GUIWindowFrame::create(const String& styleName)
 	{
 		return new (cm_alloc<GUIWindowFrame, PoolAlloc>()) GUIWindowFrame(getStyleName<GUIWindowFrame>(styleName), GUILayoutOptions::create());
 	}
 
-	GUIWindowFrame* GUIWindowFrame::create(const GUIOptions& layoutOptions, const CM::String& styleName)
+	GUIWindowFrame* GUIWindowFrame::create(const GUIOptions& layoutOptions, const String& styleName)
 	{
 		return new (cm_alloc<GUIWindowFrame, PoolAlloc>()) GUIWindowFrame(getStyleName<GUIWindowFrame>(styleName), GUILayoutOptions::create(layoutOptions));
 	}

BansheeEditor/Source/BsGUIWindowFrameWidget.cpp

@@ -9,14 +9,11 @@
 #include "CmMath.h"
 #include "CmPlatform.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const UINT32 WindowFrameWidget::RESIZE_BORDER_WIDTH = 3;
 
-	WindowFrameWidget::WindowFrameWidget(const HSceneObject& parent, CM::Viewport* target, CM::RenderWindow* parentWindow, const GUISkin& skin)
+	WindowFrameWidget::WindowFrameWidget(const HSceneObject& parent, Viewport* target, RenderWindow* parentWindow, const GUISkin& skin)
 		:GUIWidget(parent, target), mWindowFrameArea(nullptr), mParentWindow(parentWindow)
 	{
 		setSkin(skin);
@@ -70,7 +67,7 @@ namespace BansheeEditor
 		UINT32 width = mWindowFrameArea->width();
 		UINT32 height = mWindowFrameArea->height();
 
-		CM::Vector<NonClientResizeArea>::type nonClientAreas(8);
+		Vector<NonClientResizeArea>::type nonClientAreas(8);
 
 		nonClientAreas[0].type = NonClientAreaBorderType::TopLeft;
 		nonClientAreas[0].area = RectI(x, y, 

BansheeEditor/Source/BsMainEditorWindow.cpp

@@ -19,17 +19,14 @@
 #include "BsProfilerOverlay.h"
 #include "CmPlatform.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	MainEditorWindow* MainEditorWindow::create(const CM::RenderWindowPtr& renderWindow)
+	MainEditorWindow* MainEditorWindow::create(const RenderWindowPtr& renderWindow)
 	{
 		return EditorWindowManager::instance().createMain(renderWindow);
 	}
 
-	MainEditorWindow::MainEditorWindow(const CM::RenderWindowPtr& renderWindow)
+	MainEditorWindow::MainEditorWindow(const RenderWindowPtr& renderWindow)
 		:EditorWindowBase(renderWindow), mDockManager(nullptr), 
 		mMenuBar(cm_new<GUIMenuBar>(mGUI.get(), mRenderWindow.get()))
 	{

BansheeEditor/Source/BsProjectLibrary.cpp

@@ -14,11 +14,9 @@
 #include "CmDebug.h"
 #include "BsProjectLibraryEntries.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
 using namespace std::placeholders;
 
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	const WString ProjectLibrary::RESOURCES_DIR = L"Resources";
 	const WString ProjectLibrary::INTERNAL_RESOURCES_DIR = L"Internal\\Resources";
@@ -29,7 +27,7 @@ namespace BansheeEditor
 		:parent(nullptr), type(LibraryEntryType::Directory)
 	{ }
 
-	ProjectLibrary::LibraryEntry::LibraryEntry(const CM::WString& path, const CM::WString& name, DirectoryEntry* parent, LibraryEntryType type)
+	ProjectLibrary::LibraryEntry::LibraryEntry(const WString& path, const WString& name, DirectoryEntry* parent, LibraryEntryType type)
 		:path(path), parent(parent), type(type), elementName(name)
 	{ }
 
@@ -37,14 +35,14 @@ namespace BansheeEditor
 		:lastUpdateTime(0)
 	{ }
 
-	ProjectLibrary::ResourceEntry::ResourceEntry(const CM::WString& path, const CM::WString& name, DirectoryEntry* parent)
+	ProjectLibrary::ResourceEntry::ResourceEntry(const WString& path, const WString& name, DirectoryEntry* parent)
 		:LibraryEntry(path, name, parent, LibraryEntryType::File), lastUpdateTime(0)
 	{ }
 
 	ProjectLibrary::DirectoryEntry::DirectoryEntry()
 	{ }
 
-	ProjectLibrary::DirectoryEntry::DirectoryEntry(const CM::WString& path, const CM::WString& name, DirectoryEntry* parent)
+	ProjectLibrary::DirectoryEntry::DirectoryEntry(const WString& path, const WString& name, DirectoryEntry* parent)
 		:LibraryEntry(path, name, parent, LibraryEntryType::Directory)
 	{ }
 
@@ -88,7 +86,7 @@ namespace BansheeEditor
 		mMonitor->update();
 	}
 
-	void ProjectLibrary::checkForModifications(const CM::WString& fullPath)
+	void ProjectLibrary::checkForModifications(const WString& fullPath)
 	{
 		if(!Path::includes(fullPath, mResourcesFolder))
 			return; // Folder not part of our resources path, so no modifications
@@ -260,7 +258,7 @@ namespace BansheeEditor
 		}
 	}
 
-	ProjectLibrary::ResourceEntry* ProjectLibrary::addResourceInternal(DirectoryEntry* parent, const CM::WString& filePath)
+	ProjectLibrary::ResourceEntry* ProjectLibrary::addResourceInternal(DirectoryEntry* parent, const WString& filePath)
 	{
 		ResourceEntry* newResource = cm_new<ResourceEntry>(filePath, Path::getFilename(filePath), parent);
 		parent->mChildren.push_back(newResource);
@@ -273,7 +271,7 @@ namespace BansheeEditor
 		return newResource;
 	}
 
-	ProjectLibrary::DirectoryEntry* ProjectLibrary::addDirectoryInternal(DirectoryEntry* parent, const CM::WString& dirPath)
+	ProjectLibrary::DirectoryEntry* ProjectLibrary::addDirectoryInternal(DirectoryEntry* parent, const WString& dirPath)
 	{
 		DirectoryEntry* newEntry = cm_new<DirectoryEntry>(dirPath, Path::getFilename(dirPath), parent);
 		parent->mChildren.push_back(newEntry);
@@ -315,7 +313,7 @@ namespace BansheeEditor
 		if(directory == mRootEntry)
 			mRootEntry = nullptr;
 
-		CM::Vector<LibraryEntry*>::type childrenToDestroy = directory->mChildren;
+		Vector<LibraryEntry*>::type childrenToDestroy = directory->mChildren;
 		for(auto& child : childrenToDestroy)
 		{
 			if(child->type == LibraryEntryType::Directory)
@@ -419,7 +417,7 @@ namespace BansheeEditor
 		return lastModifiedTime <= resource->lastUpdateTime;
 	}
 
-	ProjectLibrary::LibraryEntry* ProjectLibrary::findEntry(const CM::WString& fullPath) const
+	ProjectLibrary::LibraryEntry* ProjectLibrary::findEntry(const WString& fullPath) const
 	{
 		Vector<WString>::type pathElems = Path::split(fullPath);
 		Vector<WString>::type rootElems = Path::split(mRootEntry->path);
@@ -467,7 +465,7 @@ namespace BansheeEditor
 		return nullptr;
 	}
 
-	void ProjectLibrary::moveEntry(const CM::WString& oldPath, const CM::WString& newPath)
+	void ProjectLibrary::moveEntry(const WString& oldPath, const WString& newPath)
 	{
 		if(FileSystem::isFile(oldPath) || FileSystem::isDirectory(oldPath))
 			FileSystem::move(oldPath, newPath);
@@ -557,7 +555,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void ProjectLibrary::deleteEntry(const CM::WString& path)
+	void ProjectLibrary::deleteEntry(const WString& path)
 	{
 		if(FileSystem::exists(path))
 			FileSystem::remove(path);
@@ -578,7 +576,7 @@ namespace BansheeEditor
 		}
 	}
 
-	void ProjectLibrary::createInternalParentHierarchy(const CM::WString& fullPath, DirectoryEntry** newHierarchyRoot, DirectoryEntry** newHierarchyLeaf)
+	void ProjectLibrary::createInternalParentHierarchy(const WString& fullPath, DirectoryEntry** newHierarchyRoot, DirectoryEntry** newHierarchyLeaf)
 	{
 		WString parentPath = fullPath;
 
@@ -622,7 +620,7 @@ namespace BansheeEditor
 			*newHierarchyLeaf = newEntryParent;
 	}
 
-	WString ProjectLibrary::getMetaPath(const CM::WString& path) const
+	WString ProjectLibrary::getMetaPath(const WString& path) const
 	{
 		WString metaPath = path + L".meta";
 

BansheeEditor/Source/BsProjectLibraryEntries.cpp

@@ -1,10 +1,7 @@
 #include "BsProjectLibraryEntries.h"
 #include "BsProjectLibraryEntriesRTTI.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	ProjectLibraryEntries::ProjectLibraryEntries(const ProjectLibrary::DirectoryEntry& rootEntry)
 		:mRootEntry(rootEntry)

BansheeEditor/Source/BsResourceMeta.cpp

@@ -1,10 +1,7 @@
 #include "BsResourceMeta.h"
 #include "BsResourceMetaRTTI.h"
 
-using namespace BansheeEngine;
-using namespace CamelotFramework;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	ResourceMeta::ResourceMeta(const ConstructPrivately& dummy)
 	{

BansheeEditor/Source/BsUndoRedo.cpp

@@ -1,12 +1,9 @@
 #include "BsUndoRedo.h"
 #include "BsEditorCommand.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	const CM::UINT32 UndoRedo::MAX_STACK_ELEMENTS = 1000;
+	const UINT32 UndoRedo::MAX_STACK_ELEMENTS = 1000;
 
 	UndoRedo::UndoRedo()
 		:mUndoStackPtr(0), mUndoNumElements(0),

BansheeEditor/Source/CmDebugCamera.cpp

@@ -7,9 +7,7 @@
 #include "BsCamera.h"
 #include "CmPlatform.h"
 
-using namespace BansheeEngine;
-
-namespace CamelotFramework
+namespace BansheeEngine
 {
 	const float DebugCamera::START_SPEED = 40.0f;
 	const float DebugCamera::TOP_SPEED = 130.0f;

BansheeEditor/Source/CmTestTextSprite.cpp

@@ -30,12 +30,9 @@
 #include "BsGUIIntField.h"
 #include "BsGUIFloatField.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
-	TestTextSprite::TestTextSprite(const HSceneObject& parent, CM::Viewport* target)
+	TestTextSprite::TestTextSprite(const HSceneObject& parent, Viewport* target)
 		:GUIWidget(parent, target)
 	{
 	}
@@ -44,9 +41,9 @@ namespace BansheeEditor
 	{
 	}
 
-	void TestTextSprite::init(const HCamera& camera, const String& text, CM::RenderTexturePtr sceneView)
+	void TestTextSprite::init(const HCamera& camera, const String& text, RenderTexturePtr sceneView)
 	{
-		setSkin(BansheeEditor::EditorGUI::instance().getSkin());
+		setSkin(BansheeEngine::EditorGUI::instance().getSkin());
 		setDepth(128);
 
 		SceneObject::create("FILLER_A");

BansheeEditor/Source/DbgEditorWidget1.cpp

@@ -8,10 +8,7 @@
 #include "BsGUILayout.h"
 #include "BsEditorWidgetManager.h"
 
-using namespace CamelotFramework;
-using namespace BansheeEngine;
-
-namespace BansheeEditor
+namespace BansheeEngine
 {
 	DbgEditorWidget1* DbgEditorWidget1::Instance = nullptr;