Renaming core thread managers by removing the Core suffix since they're now in the ::ct namespace

Source/BansheeCore/Include/BsBlendState.h

@@ -224,7 +224,7 @@ namespace bs
 		static const SPtr<BlendStateCore>& getDefault();
 
 	protected:
-		friend class RenderStateCoreManager;
+		friend class RenderStateManager;
 
 		BlendStateCore(const BLEND_STATE_DESC& desc, UINT32 id);
 

Source/BansheeCore/Include/BsCorePrerequisites.h

@@ -441,6 +441,9 @@ namespace bs
 		class OcclusionQuery;
 		class TextureView;
 		class RenderableElement;
+		class RenderWindowManager;
+		class RenderStateManager;
+		class HardwareBufferManager;
 	}
 }
 

Source/BansheeCore/Include/BsDepthStencilState.h

@@ -215,7 +215,7 @@ namespace bs
 		static const SPtr<DepthStencilStateCore>& getDefault();
 
 	protected:
-		friend class RenderStateCoreManager;
+		friend class RenderStateManager;
 
 		DepthStencilStateCore(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id);
 

Source/BansheeCore/Include/BsGpuBuffer.h

@@ -148,7 +148,7 @@ namespace bs
 		/** Returns properties describing the buffer. */
 		const GpuBufferProperties& getProperties() const { return mProperties; }
 
-		/** @copydoc HardwareBufferCoreManager::createGpuBuffer */
+		/** @copydoc HardwareBufferManager::createGpuBuffer */
 		static SPtr<GpuBufferCore> create(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:

Source/BansheeCore/Include/BsGpuParamBlockBuffer.h

@@ -130,7 +130,7 @@ namespace bs
 		/**	Returns the size of the buffer in bytes. */
 		UINT32 getSize() const { return mSize; }
 
-		/** @copydoc HardwareBufferCoreManager::createGpuParamBlockBuffer */
+		/** @copydoc HardwareBufferManager::createGpuParamBlockBuffer */
 		static SPtr<GpuParamBlockBufferCore> create(UINT32 size, GpuParamBlockUsage usage = GPBU_DYNAMIC,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 

Source/BansheeCore/Include/BsGpuParams.h

@@ -342,7 +342,7 @@ namespace bs
 
 	protected:
 		friend class GpuParams;
-		friend class HardwareBufferCoreManager;
+		friend class HardwareBufferManager;
 
 		GpuParamsCore(const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask);
 

Source/BansheeCore/Include/BsGpuPipelineParamInfo.h

@@ -131,7 +131,7 @@ namespace bs
 													 GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:
-		friend class RenderStateCoreManager;
+		friend class RenderStateManager;
 
 		GpuPipelineParamInfoCore(const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask);
 	};

Source/BansheeCore/Include/BsGpuPipelineState.h

@@ -231,7 +231,7 @@ namespace bs
 		/** @copydoc CoreObjectCore::initialize() */
 		void initialize() override;
 
-		/** @copydoc RenderStateCoreManager::createGraphicsPipelineState */
+		/** @copydoc RenderStateManager::createGraphicsPipelineState */
 		static SPtr<GraphicsPipelineStateCore> create(const PIPELINE_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
@@ -249,7 +249,7 @@ namespace bs
 		/** @copydoc CoreObjectCore::initialize() */
 		void initialize() override;
 
-		/** @copydoc RenderStateCoreManager::createComputePipelineState */
+		/** @copydoc RenderStateManager::createComputePipelineState */
 		static SPtr<ComputePipelineStateCore> create(const SPtr<GpuProgramCore>& program,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 

Source/BansheeCore/Include/BsGpuProgramManager.h

@@ -47,7 +47,7 @@ namespace bs
 		/** @copydoc GpuProgramCore::create */
 		virtual SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 
-		/** @copydoc GpuProgramManager::createEmpty */
+		/** @copydoc bs::GpuProgramManager::createEmpty */
 		virtual SPtr<GpuProgramCore> create(GpuProgramType type, GpuDeviceFlags deviceMask = GDF_DEFAULT) = 0;
 	};
 
@@ -57,11 +57,11 @@ namespace bs
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT GpuProgramCoreManager : public Module<GpuProgramCoreManager>
+	class BS_CORE_EXPORT GpuProgramManager : public Module<GpuProgramManager>
 	{
 	public:
-		GpuProgramCoreManager();
-		virtual ~GpuProgramCoreManager();
+		GpuProgramManager();
+		virtual ~GpuProgramManager();
 
 		/**
 		 * Registers a new factory that is able to create GPU programs for a certain language. If any other factory for the

Source/BansheeCore/Include/BsHardwareBufferManager.h

@@ -81,25 +81,25 @@ namespace bs
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT HardwareBufferCoreManager : public Module<HardwareBufferCoreManager>
+	class BS_CORE_EXPORT HardwareBufferManager : public Module<HardwareBufferManager>
 	{
     public:
-		virtual ~HardwareBufferCoreManager() { }
+		virtual ~HardwareBufferManager() { }
 
 		/** 
-		 * @copydoc HardwareBufferManager::createVertexBuffer 
+		 * @copydoc bs::HardwareBufferManager::createVertexBuffer 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<VertexBufferCore> createVertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc HardwareBufferManager::createIndexBuffer 
+		 * @copydoc bs::HardwareBufferManager::createIndexBuffer 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<IndexBufferCore> createIndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc HardwareBufferManager::createVertexDeclaration 
+		 * @copydoc bs::HardwareBufferManager::createVertexDeclaration 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<VertexDeclarationCore> createVertexDeclaration(const SPtr<VertexDataDesc>& desc,
@@ -115,14 +115,14 @@ namespace bs
 			GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc HardwareBufferManager::createGpuParamBlockBuffer 
+		 * @copydoc bs::HardwareBufferManager::createGpuParamBlockBuffer 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBuffer(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/** 
-		 * @copydoc HardwareBufferManager::createGpuBuffer
+		 * @copydoc bs::HardwareBufferManager::createGpuBuffer
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<GpuBufferCore> createGpuBuffer(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);

Source/BansheeCore/Include/BsIndexBuffer.h

@@ -93,7 +93,7 @@ namespace bs
 		/**	Returns information about the index buffer. */
 		const IndexBufferProperties& getProperties() const { return mProperties; }
 
-		/** @copydoc HardwareBufferCoreManager::createIndexBuffer */
+		/** @copydoc HardwareBufferManager::createIndexBuffer */
 		static SPtr<IndexBufferCore> create(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:

Source/BansheeCore/Include/BsRasterizerState.h

@@ -196,7 +196,7 @@ namespace bs
 		static const SPtr<RasterizerStateCore>& getDefault();
 
 	protected:
-		friend class RenderStateCoreManager;
+		friend class RenderStateManager;
 
 		RasterizerStateCore(const RASTERIZER_STATE_DESC& desc, UINT32 id);
 

Source/BansheeCore/Include/BsRenderStateManager.h

@@ -96,7 +96,7 @@ namespace bs
 	namespace ct
 	{
 	/**	Handles creation of various render states. */
-	class BS_CORE_EXPORT RenderStateCoreManager : public Module<RenderStateCoreManager>
+	class BS_CORE_EXPORT RenderStateManager : public Module<RenderStateManager>
 	{
 	private:
 		/**	Contains data about a cached blend state. */
@@ -145,33 +145,33 @@ namespace bs
 		};
 
 	public:
-		RenderStateCoreManager();
+		RenderStateManager();
 
 		/** 
-		 * @copydoc RenderStateManager::createSamplerState 
+		 * @copydoc bs::RenderStateManager::createSamplerState 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<SamplerStateCore> createSamplerState(const SAMPLER_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
-		/** @copydoc RenderStateManager::createDepthStencilState */
+		/** @copydoc bs::RenderStateManager::createDepthStencilState */
 		SPtr<DepthStencilStateCore> createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const;
 
-		/** @copydoc RenderStateManager::createRasterizerState */
+		/** @copydoc bs::RenderStateManager::createRasterizerState */
 		SPtr<RasterizerStateCore> createRasterizerState(const RASTERIZER_STATE_DESC& desc) const;
 
-		/** @copydoc RenderStateManager::createBlendState */
+		/** @copydoc bs::RenderStateManager::createBlendState */
 		SPtr<BlendStateCore> createBlendState(const BLEND_STATE_DESC& desc) const;
 
 		/** 
-		 * @copydoc RenderStateManager::createGraphicsPipelineState 
+		 * @copydoc bs::RenderStateManager::createGraphicsPipelineState 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<GraphicsPipelineStateCore> createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const;
 
 		/** 
-		 * @copydoc RenderStateManager::createComputePipelineState 
+		 * @copydoc bs::RenderStateManager::createComputePipelineState 
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<ComputePipelineStateCore> createComputePipelineState(const SPtr<GpuProgramCore>& program,

Source/BansheeCore/Include/BsRenderTexture.h

@@ -129,7 +129,7 @@ namespace bs
 		/** @copydoc CoreObjectCore::initialize */
 		void initialize() override;
 
-		/** @copydoc TextureCoreManager::createRenderTexture(const RENDER_TEXTURE_DESC&, UINT32) */
+		/** @copydoc TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC&, UINT32) */
 		static SPtr<RenderTextureCore> create(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx = 0);
 
 		/**

Source/BansheeCore/Include/BsRenderWindow.h

@@ -321,9 +321,9 @@ namespace bs
 		virtual void _notifyRestored();
 
 	protected:
-		friend class RenderWindow;
+		friend class bs::RenderWindow;
+		friend class bs::RenderWindowManager;
 		friend class RenderWindowManager;
-		friend class RenderWindowCoreManager;
 
 		/**
 		 * Returns window properties that are always kept in sync between core and sim threads.

Source/BansheeCore/Include/BsRenderWindowManager.h

@@ -93,10 +93,10 @@ namespace bs
 	 *
 	 * @note	Core thread only.
 	 */
-	class BS_CORE_EXPORT RenderWindowCoreManager : public Module<RenderWindowCoreManager>
+	class BS_CORE_EXPORT RenderWindowManager : public Module<RenderWindowManager>
 	{
 	public:
-		RenderWindowCoreManager();
+		RenderWindowManager();
 
 		/** Creates a new render window using the specified options. */
 		SPtr<RenderWindowCore> create(RENDER_WINDOW_DESC& desc);
@@ -111,9 +111,9 @@ namespace bs
 		Vector<RenderWindowCore*> getRenderWindows() const;
 
 	protected:
-		friend class ct::RenderWindowCore;
-		friend class RenderWindow;
-		friend class RenderWindowManager;
+		friend class RenderWindowCore;
+		friend class bs::RenderWindow;
+		friend class bs::RenderWindowManager;
 
 		/** @copydoc create */
 		virtual SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) = 0;

Source/BansheeCore/Include/BsSamplerState.h

@@ -193,14 +193,14 @@ namespace bs
 		/**	Returns information about the sampler state. */
 		const SamplerProperties& getProperties() const;
 
-		/**	@copydoc RenderStateCoreManager::createSamplerState */
+		/**	@copydoc RenderStateManager::createSamplerState */
 		static SPtr<SamplerStateCore> create(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**	Returns the default sampler state. */
 		static const SPtr<SamplerStateCore>& getDefault();
 
 	protected:
-		friend class RenderStateCoreManager;
+		friend class RenderStateManager;
 
 		SamplerStateCore(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask);
 

Source/BansheeCore/Include/BsTextureManager.h

@@ -86,10 +86,10 @@ namespace bs
 	 *
 	 * @note	Core thread only.
      */
-    class BS_CORE_EXPORT TextureCoreManager : public Module<TextureCoreManager>
+    class BS_CORE_EXPORT TextureManager : public Module<TextureManager>
     {
     public:
-		virtual ~TextureCoreManager() { }
+		virtual ~TextureManager() { }
 
 		/** @copydoc Module::onStartUp */
 		void onStartUp() override;
@@ -98,13 +98,13 @@ namespace bs
 		void onShutDown() override;
 
 		/**
-		 * @copydoc	TextureManager::createTexture(const TEXTURE_DESC&)
+		 * @copydoc	bs::TextureManager::createTexture(const TEXTURE_DESC&)
 		 * @param[in]	deviceMask		Mask that determines on which GPU devices should the object be created on.
 		 */
 		SPtr<TextureCore> createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 		/**
-		 * @copydoc TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC&) 
+		 * @copydoc bs::TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC&) 
 		 * @param[in]	deviceIdx		Index of the GPU device to create the object on.
 		 */
 		SPtr<RenderTextureCore> createRenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx = 0);

Source/BansheeCore/Include/BsVertexBuffer.h

@@ -90,7 +90,7 @@ namespace bs
 		/**	Returns information about the vertex buffer. */
 		const VertexBufferProperties& getProperties() const { return mProperties; }
 
-		/** @copydoc HardwareBufferCoreManager::createVertexBuffer */
+		/** @copydoc HardwareBufferManager::createVertexBuffer */
 		static SPtr<VertexBufferCore> create(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
 	protected:

Source/BansheeCore/Include/BsVertexDeclaration.h

@@ -245,11 +245,11 @@ namespace bs
 		 */
 		Vector<VertexElement> getMissingElements(const SPtr<VertexDeclarationCore>& shaderDecl);
 
-		/** @copydoc HardwareBufferCoreManager::createVertexDeclaration */
+		/** @copydoc HardwareBufferManager::createVertexDeclaration */
 		static SPtr<VertexDeclarationCore> create(const SPtr<VertexDataDesc>& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT);
 
     protected:
-		friend class HardwareBufferCoreManager;
+		friend class HardwareBufferManager;
 
 		VertexDeclarationCore(const List<VertexElement>& elements, GpuDeviceFlags deviceMask);
 

Source/BansheeCore/Source/BsBlendState.cpp

@@ -112,7 +112,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> BlendState::createCore() const
 	{
-		SPtr<ct::BlendStateCore> core = ct::RenderStateCoreManager::instance()._createBlendState(mProperties.mData);
+		SPtr<ct::BlendStateCore> core = ct::RenderStateManager::instance()._createBlendState(mProperties.mData);
 		mId = core->getId(); // Accessing core from sim thread is okay here since core ID is immutable
 
 		return core;
@@ -199,12 +199,12 @@ namespace bs
 
 	SPtr<BlendStateCore> BlendStateCore::create(const BLEND_STATE_DESC& desc)
 	{
-		return RenderStateCoreManager::instance().createBlendState(desc);
+		return RenderStateManager::instance().createBlendState(desc);
 	}
 
 	const SPtr<BlendStateCore>& BlendStateCore::getDefault()
 	{
-		return RenderStateCoreManager::instance().getDefaultBlendState();
+		return RenderStateManager::instance().getDefaultBlendState();
 	}
 	}
 }

Source/BansheeCore/Source/BsCoreApplication.cpp

@@ -96,7 +96,7 @@ namespace bs
 		unloadPlugin(mRendererPlugin);
 
 		RenderAPIManager::shutDown();
-		ct::GpuProgramCoreManager::shutDown();
+		ct::GpuProgramManager::shutDown();
 		GpuProgramManager::shutDown();
 
 		CoreObjectManager::shutDown(); // Must shut down before DynLibManager to ensure all objects are destroyed before unloading their libraries
@@ -143,7 +143,7 @@ namespace bs
 		ResourceListenerManager::startUp();
 		GpuProgramManager::startUp();
 		RenderStateManager::startUp();
-		ct::GpuProgramCoreManager::startUp();
+		ct::GpuProgramManager::startUp();
 		RenderAPIManager::startUp();
 
 		mPrimaryWindow = RenderAPIManager::instance().initialize(mStartUpDesc.renderAPI, mStartUpDesc.primaryWindowDesc);
@@ -269,7 +269,7 @@ namespace bs
 
 			gCoreThread().queueCommand(std::bind(&CoreApplication::frameRenderingFinishedCallback, this), CTQF_InternalQueue);
 
-			gCoreThread().queueCommand(std::bind(&ct::RenderWindowCoreManager::_update, ct::RenderWindowCoreManager::instancePtr()), CTQF_InternalQueue);
+			gCoreThread().queueCommand(std::bind(&ct::RenderWindowManager::_update, ct::RenderWindowManager::instancePtr()), CTQF_InternalQueue);
 			gCoreThread().queueCommand(std::bind(&ct::QueryManager::_update, ct::QueryManager::instancePtr()), CTQF_InternalQueue);
 			gCoreThread().queueCommand(std::bind(&CoreApplication::endCoreProfiling, this), CTQF_InternalQueue);
 

Source/BansheeCore/Source/BsDepthStencilState.cpp

@@ -51,7 +51,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> DepthStencilState::createCore() const
 	{
-		SPtr<ct::DepthStencilStateCore> core = ct::RenderStateCoreManager::instance()._createDepthStencilState(mProperties.mData);
+		SPtr<ct::DepthStencilStateCore> core = ct::RenderStateManager::instance()._createDepthStencilState(mProperties.mData);
 		mId = core->getId(); // Accessing core from sim thread is okay here since core ID is immutable
 
 		return core;
@@ -138,12 +138,12 @@ namespace bs
 
 	SPtr<DepthStencilStateCore> DepthStencilStateCore::create(const DEPTH_STENCIL_STATE_DESC& desc)
 	{
-		return RenderStateCoreManager::instance().createDepthStencilState(desc);
+		return RenderStateManager::instance().createDepthStencilState(desc);
 	}
 
 	const SPtr<DepthStencilStateCore>& DepthStencilStateCore::getDefault()
 	{
-		return RenderStateCoreManager::instance().getDefaultDepthStencilState();
+		return RenderStateManager::instance().getDefaultDepthStencilState();
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuBuffer.cpp

@@ -38,7 +38,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> GpuBuffer::createCore() const
 	{
-		return ct::HardwareBufferCoreManager::instance().createGpuBufferInternal(mProperties.mDesc);
+		return ct::HardwareBufferManager::instance().createGpuBufferInternal(mProperties.mDesc);
 	}
 
 	UINT32 GpuBuffer::getFormatSize(GpuBufferFormat format)
@@ -111,7 +111,7 @@ namespace bs
 
 	SPtr<GpuBufferCore> GpuBufferCore::create(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createGpuBuffer(desc, deviceMask);
+		return HardwareBufferManager::instance().createGpuBuffer(desc, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuParamBlockBuffer.cpp

@@ -72,7 +72,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> GpuParamBlockBuffer::createCore() const
 	{
-		return ct::HardwareBufferCoreManager::instance().createGpuParamBlockBufferInternal(mSize, mUsage);
+		return ct::HardwareBufferManager::instance().createGpuParamBlockBufferInternal(mSize, mUsage);
 	}
 
 	CoreSyncData GpuParamBlockBuffer::syncToCore(FrameAlloc* allocator)
@@ -168,7 +168,7 @@ namespace bs
 	SPtr<GpuParamBlockBufferCore> GpuParamBlockBufferCore::create(UINT32 size, GpuParamBlockUsage usage, 
 		GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createGpuParamBlockBuffer(size, usage, deviceMask);
+		return HardwareBufferManager::instance().createGpuParamBlockBuffer(size, usage, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuParams.cpp

@@ -566,7 +566,7 @@ namespace bs
 	{
 		SPtr<GpuPipelineParamInfo> paramInfo = std::static_pointer_cast<GpuPipelineParamInfo>(mParamInfo);
 
-		return ct::HardwareBufferCoreManager::instance().createGpuParams(paramInfo->getCore());
+		return ct::HardwareBufferManager::instance().createGpuParams(paramInfo->getCore());
 	}
 
 	void GpuParams::_markCoreDirty()
@@ -787,17 +787,17 @@ namespace bs
 
 	SPtr<GpuParamsCore> GpuParamsCore::create(const SPtr<GraphicsPipelineStateCore>& pipelineState, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createGpuParams(pipelineState->getParamInfo(), deviceMask);
+		return HardwareBufferManager::instance().createGpuParams(pipelineState->getParamInfo(), deviceMask);
 	}
 
 	SPtr<GpuParamsCore> GpuParamsCore::create(const SPtr<ComputePipelineStateCore>& pipelineState, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createGpuParams(pipelineState->getParamInfo(), deviceMask);
+		return HardwareBufferManager::instance().createGpuParams(pipelineState->getParamInfo(), deviceMask);
 	}
 
 	SPtr<GpuParamsCore> GpuParamsCore::create(const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createGpuParams(paramInfo, deviceMask);
+		return HardwareBufferManager::instance().createGpuParams(paramInfo, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuPipelineParamInfo.cpp

@@ -245,7 +245,7 @@ namespace bs
 		desc.domainParams = mParamDescs[GPT_DOMAIN_PROGRAM];
 		desc.computeParams = mParamDescs[GPT_COMPUTE_PROGRAM];
 
-		return ct::RenderStateCoreManager::instance()._createPipelineParamInfo(desc);
+		return ct::RenderStateManager::instance()._createPipelineParamInfo(desc);
 	}
 
 	namespace ct
@@ -257,7 +257,7 @@ namespace bs
 	SPtr<GpuPipelineParamInfoCore> GpuPipelineParamInfoCore::create(const GPU_PIPELINE_PARAMS_DESC& desc, 
 		GpuDeviceFlags deviceMask)
 	{
-		return RenderStateCoreManager::instance().createPipelineParamInfo(desc, deviceMask);
+		return RenderStateManager::instance().createPipelineParamInfo(desc, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuPipelineState.cpp

@@ -83,7 +83,7 @@ namespace bs
 		ct::PIPELINE_STATE_DESC desc;
 		convertPassDesc(mData, desc);
 
-		return ct::RenderStateCoreManager::instance()._createGraphicsPipelineState(desc);
+		return ct::RenderStateManager::instance()._createGraphicsPipelineState(desc);
 	}
 
 	SPtr<GraphicsPipelineState> GraphicsPipelineState::create(const PIPELINE_STATE_DESC& desc)
@@ -120,7 +120,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> ComputePipelineState::createCore() const
 	{
-		return ct::RenderStateCoreManager::instance()._createComputePipelineState(mProgram->getCore());
+		return ct::RenderStateManager::instance()._createComputePipelineState(mProgram->getCore());
 	}
 
 	SPtr<ComputePipelineState> ComputePipelineState::create(const SPtr<GpuProgram>& program)
@@ -159,7 +159,7 @@ namespace bs
 
 	SPtr<GraphicsPipelineStateCore> GraphicsPipelineStateCore::create(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return RenderStateCoreManager::instance().createGraphicsPipelineState(desc, deviceMask);
+		return RenderStateManager::instance().createGraphicsPipelineState(desc, deviceMask);
 	}
 
 	ComputePipelineStateCore::ComputePipelineStateCore(const SPtr<GpuProgramCore>& program, GpuDeviceFlags deviceMask)
@@ -179,7 +179,7 @@ namespace bs
 	SPtr<ComputePipelineStateCore> ComputePipelineStateCore::create(const SPtr<GpuProgramCore>& program, 
 		GpuDeviceFlags deviceMask)
 	{
-		return RenderStateCoreManager::instance().createComputePipelineState(program, deviceMask);
+		return RenderStateManager::instance().createComputePipelineState(program, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuProgram.cpp

@@ -50,7 +50,7 @@ namespace bs
 		desc.type = mProperties.getType();
 		desc.requiresAdjacency = mNeedsAdjacencyInfo;
 
-		return ct::GpuProgramCoreManager::instance().createInternal(desc);
+		return ct::GpuProgramManager::instance().createInternal(desc);
 	}
 
 	SPtr<GpuProgram> GpuProgram::create(const GPU_PROGRAM_DESC& desc)
@@ -95,7 +95,7 @@ namespace bs
 
 	SPtr<GpuProgramCore> GpuProgramCore::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return GpuProgramCoreManager::instance().create(desc, deviceMask);
+		return GpuProgramManager::instance().create(desc, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsGpuProgramManager.cpp

@@ -80,23 +80,23 @@ namespace bs
 		}
 	};
 
-	GpuProgramCoreManager::GpuProgramCoreManager()
+	GpuProgramManager::GpuProgramManager()
 	{
 		mNullFactory = bs_new<NullProgramFactory>();
 		addFactory(mNullFactory);
 	}
 
-	GpuProgramCoreManager::~GpuProgramCoreManager()
+	GpuProgramManager::~GpuProgramManager()
 	{
 		bs_delete((NullProgramFactory*)mNullFactory);
 	}
 
-	void GpuProgramCoreManager::addFactory(GpuProgramFactory* factory)
+	void GpuProgramManager::addFactory(GpuProgramFactory* factory)
 	{
 		mFactories[factory->getLanguage()] = factory;
 	}
 
-	void GpuProgramCoreManager::removeFactory(GpuProgramFactory* factory)
+	void GpuProgramManager::removeFactory(GpuProgramFactory* factory)
     {
         FactoryMap::iterator it = mFactories.find(factory->getLanguage());
         if (it != mFactories.end() && it->second == factory)
@@ -105,7 +105,7 @@ namespace bs
         }
     }
 
-	GpuProgramFactory* GpuProgramCoreManager::getFactory(const String& language)
+	GpuProgramFactory* GpuProgramManager::getFactory(const String& language)
 	{
 		FactoryMap::iterator i = mFactories.find(language);
 
@@ -115,14 +115,14 @@ namespace bs
 		return i->second;
 	}
 
-	bool GpuProgramCoreManager::isLanguageSupported(const String& lang)
+	bool GpuProgramManager::isLanguageSupported(const String& lang)
 	{
 		FactoryMap::iterator i = mFactories.find(lang);
 
 		return i != mFactories.end();
 	}
 
-	SPtr<GpuProgramCore> GpuProgramCoreManager::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GpuProgramCore> GpuProgramManager::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
     {
 		SPtr<GpuProgramCore> ret = createInternal(desc, deviceMask);
 		ret->initialize();
@@ -130,7 +130,7 @@ namespace bs
         return ret;
     }
 
-	SPtr<GpuProgramCore> GpuProgramCoreManager::createInternal(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<GpuProgramCore> GpuProgramManager::createInternal(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		GpuProgramFactory* factory = getFactory(desc.language);
 		SPtr<GpuProgramCore> ret = factory->create(desc, deviceMask);

Source/BansheeCore/Source/BsHardwareBufferManager.cpp

@@ -76,12 +76,12 @@ namespace bs
 	namespace ct
 	{
 
-	HardwareBufferCoreManager::VertexDeclarationKey::VertexDeclarationKey(const List<VertexElement>& elements)
+	HardwareBufferManager::VertexDeclarationKey::VertexDeclarationKey(const List<VertexElement>& elements)
 		:elements(elements)
 	{ }
 
 
-	size_t HardwareBufferCoreManager::VertexDeclarationKey::HashFunction::operator()(const VertexDeclarationKey& v) const
+	size_t HardwareBufferManager::VertexDeclarationKey::HashFunction::operator()(const VertexDeclarationKey& v) const
 	{
 		size_t hash = 0;
 		for(auto& entry : v.elements)
@@ -90,7 +90,7 @@ namespace bs
 		return hash;
 	}
 
-	bool HardwareBufferCoreManager::VertexDeclarationKey::EqualFunction::operator()(const VertexDeclarationKey& lhs, 
+	bool HardwareBufferManager::VertexDeclarationKey::EqualFunction::operator()(const VertexDeclarationKey& lhs, 
 		const VertexDeclarationKey& rhs) const
 	{
 		if (lhs.elements.size() != rhs.elements.size())
@@ -111,7 +111,7 @@ namespace bs
 		return true;
 	}
 
-	SPtr<IndexBufferCore> HardwareBufferCoreManager::createIndexBuffer(const INDEX_BUFFER_DESC& desc, 
+	SPtr<IndexBufferCore> HardwareBufferManager::createIndexBuffer(const INDEX_BUFFER_DESC& desc, 
 		GpuDeviceFlags deviceMask)
 	{
 		SPtr<IndexBufferCore> ibuf = createIndexBufferInternal(desc, deviceMask);
@@ -120,7 +120,7 @@ namespace bs
 
 	}
 
-	SPtr<VertexBufferCore> HardwareBufferCoreManager::createVertexBuffer(const VERTEX_BUFFER_DESC& desc, 
+	SPtr<VertexBufferCore> HardwareBufferManager::createVertexBuffer(const VERTEX_BUFFER_DESC& desc, 
 		GpuDeviceFlags deviceMask)
 	{
 		SPtr<VertexBufferCore> vbuf = createVertexBufferInternal(desc, deviceMask);
@@ -128,7 +128,7 @@ namespace bs
 		return vbuf;
 	}
 
-	SPtr<VertexDeclarationCore> HardwareBufferCoreManager::createVertexDeclaration(const SPtr<VertexDataDesc>& desc, 
+	SPtr<VertexDeclarationCore> HardwareBufferManager::createVertexDeclaration(const SPtr<VertexDataDesc>& desc, 
 		GpuDeviceFlags deviceMask)
 	{
 		List<VertexElement> elements = desc->createElements();
@@ -136,7 +136,7 @@ namespace bs
 		return createVertexDeclaration(elements, deviceMask);
 	}
 
-	SPtr<GpuParamsCore> HardwareBufferCoreManager::createGpuParams(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
+	SPtr<GpuParamsCore> HardwareBufferManager::createGpuParams(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
 																   GpuDeviceFlags deviceMask)
     {
 		SPtr<GpuParamsCore> params = createGpuParamsInternal(paramInfo, deviceMask);
@@ -145,7 +145,7 @@ namespace bs
 		return params;
     }
 
-	SPtr<VertexDeclarationCore> HardwareBufferCoreManager::createVertexDeclaration(const List<VertexElement>& elements,
+	SPtr<VertexDeclarationCore> HardwareBufferManager::createVertexDeclaration(const List<VertexElement>& elements,
 		GpuDeviceFlags deviceMask)
 	{
 		VertexDeclarationKey key(elements);
@@ -161,7 +161,7 @@ namespace bs
 		return declPtr;
 	}
 
-	SPtr<GpuParamBlockBufferCore> HardwareBufferCoreManager::createGpuParamBlockBuffer(UINT32 size, 
+	SPtr<GpuParamBlockBufferCore> HardwareBufferManager::createGpuParamBlockBuffer(UINT32 size, 
 		GpuParamBlockUsage usage, GpuDeviceFlags deviceMask)
 	{
 		SPtr<GpuParamBlockBufferCore> paramBlockPtr = createGpuParamBlockBufferInternal(size, usage, deviceMask);
@@ -170,7 +170,7 @@ namespace bs
 		return paramBlockPtr;
 	}
 
-	SPtr<GpuBufferCore> HardwareBufferCoreManager::createGpuBuffer(const GPU_BUFFER_DESC& desc,
+	SPtr<GpuBufferCore> HardwareBufferManager::createGpuBuffer(const GPU_BUFFER_DESC& desc,
 		GpuDeviceFlags deviceMask)
 	{
 		SPtr<GpuBufferCore> gbuf = createGpuBufferInternal(desc, deviceMask);
@@ -179,7 +179,7 @@ namespace bs
 		return gbuf;
 	}
 
-	SPtr<VertexDeclarationCore> HardwareBufferCoreManager::createVertexDeclarationInternal(
+	SPtr<VertexDeclarationCore> HardwareBufferManager::createVertexDeclarationInternal(
 		const List<VertexElement>& elements, GpuDeviceFlags deviceMask)
 	{
 		VertexDeclarationCore* decl = new (bs_alloc<VertexDeclarationCore>()) VertexDeclarationCore(elements, deviceMask);
@@ -190,7 +190,7 @@ namespace bs
 		return ret;
 	}
 
-	SPtr<GpuParamsCore> HardwareBufferCoreManager::createGpuParamsInternal(
+	SPtr<GpuParamsCore> HardwareBufferManager::createGpuParamsInternal(
 		const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask)
     {
 		GpuParamsCore* params = new (bs_alloc<GpuParamsCore>()) GpuParamsCore(paramInfo, deviceMask);

Source/BansheeCore/Source/BsIndexBuffer.cpp

@@ -40,7 +40,7 @@ namespace bs
 		desc.numIndices = mProperties.mNumIndices;
 		desc.usage = mUsage;
 
-		return ct::HardwareBufferCoreManager::instance().createIndexBufferInternal(desc);
+		return ct::HardwareBufferManager::instance().createIndexBufferInternal(desc);
 	}
 
 	SPtr<IndexBuffer> IndexBuffer::create(const INDEX_BUFFER_DESC& desc)
@@ -56,7 +56,7 @@ namespace bs
 
 	SPtr<IndexBufferCore> IndexBufferCore::create(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createIndexBuffer(desc, deviceMask);
+		return HardwareBufferManager::instance().createIndexBuffer(desc, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsRasterizerState.cpp

@@ -43,7 +43,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> RasterizerState::createCore() const
 	{
-		SPtr<ct::RasterizerStateCore> core = ct::RenderStateCoreManager::instance()._createRasterizerState(mProperties.mData);
+		SPtr<ct::RasterizerStateCore> core = ct::RenderStateManager::instance()._createRasterizerState(mProperties.mData);
 		mId = core->getId(); // Accessing core from sim thread is okay here since core ID is immutable
 
 		return core;
@@ -125,12 +125,12 @@ namespace bs
 
 	SPtr<RasterizerStateCore> RasterizerStateCore::create(const RASTERIZER_STATE_DESC& desc)
 	{
-		return RenderStateCoreManager::instance().createRasterizerState(desc);
+		return RenderStateManager::instance().createRasterizerState(desc);
 	}
 
 	const SPtr<RasterizerStateCore>& RasterizerStateCore::getDefault()
 	{
-		return RenderStateCoreManager::instance().getDefaultRasterizerState();
+		return RenderStateManager::instance().getDefaultRasterizerState();
 	}
 	}
 }

Source/BansheeCore/Source/BsRenderStateManager.cpp

@@ -140,13 +140,13 @@ namespace bs
 
 	namespace ct
 	{
-	RenderStateCoreManager::RenderStateCoreManager()
+	RenderStateManager::RenderStateManager()
 		:mNextBlendStateId(0), mNextRasterizerStateId(0), mNextDepthStencilStateId(0)
 	{
 		
 	}
 
-	SPtr<SamplerStateCore> RenderStateCoreManager::createSamplerState(const SAMPLER_STATE_DESC& desc, 
+	SPtr<SamplerStateCore> RenderStateManager::createSamplerState(const SAMPLER_STATE_DESC& desc, 
 		GpuDeviceFlags deviceMask) const
 	{
 		SPtr<SamplerStateCore> state = findCachedState(desc);
@@ -161,7 +161,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateCoreManager::createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
+	SPtr<DepthStencilStateCore> RenderStateManager::createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
 		SPtr<DepthStencilStateCore> state = findCachedState(desc, id);
@@ -179,7 +179,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateCoreManager::createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
+	SPtr<RasterizerStateCore> RenderStateManager::createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
 		SPtr<RasterizerStateCore> state = findCachedState(desc, id);
@@ -197,7 +197,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<BlendStateCore> RenderStateCoreManager::createBlendState(const BLEND_STATE_DESC& desc) const
+	SPtr<BlendStateCore> RenderStateManager::createBlendState(const BLEND_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
 		SPtr<BlendStateCore> state = findCachedState(desc, id);
@@ -215,7 +215,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<GraphicsPipelineStateCore> RenderStateCoreManager::createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
+	SPtr<GraphicsPipelineStateCore> RenderStateManager::createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, 
 		GpuDeviceFlags deviceMask) const
 	{
 		SPtr<GraphicsPipelineStateCore> state = _createGraphicsPipelineState(desc, deviceMask);
@@ -224,7 +224,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<ComputePipelineStateCore> RenderStateCoreManager::createComputePipelineState(const SPtr<GpuProgramCore>& program,
+	SPtr<ComputePipelineStateCore> RenderStateManager::createComputePipelineState(const SPtr<GpuProgramCore>& program,
 																					  GpuDeviceFlags deviceMask) const
 	{
 		SPtr<ComputePipelineStateCore> state = _createComputePipelineState(program, deviceMask);
@@ -233,7 +233,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<GpuPipelineParamInfoCore> RenderStateCoreManager::createPipelineParamInfo(
+	SPtr<GpuPipelineParamInfoCore> RenderStateManager::createPipelineParamInfo(
 		const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
 		SPtr<GpuPipelineParamInfoCore> paramInfo = _createPipelineParamInfo(desc, deviceMask);
@@ -242,7 +242,7 @@ namespace bs
 		return paramInfo;
 	}
 
-	SPtr<SamplerStateCore> RenderStateCoreManager::_createSamplerState(const SAMPLER_STATE_DESC& desc, 
+	SPtr<SamplerStateCore> RenderStateManager::_createSamplerState(const SAMPLER_STATE_DESC& desc, 
 		GpuDeviceFlags deviceMask) const
 	{
 		SPtr<SamplerStateCore> state = findCachedState(desc);
@@ -256,7 +256,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateCoreManager::_createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
+	SPtr<DepthStencilStateCore> RenderStateManager::_createDepthStencilState(const DEPTH_STENCIL_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
 		SPtr<DepthStencilStateCore> state = findCachedState(desc, id);
@@ -273,7 +273,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateCoreManager::_createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
+	SPtr<RasterizerStateCore> RenderStateManager::_createRasterizerState(const RASTERIZER_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
 		SPtr<RasterizerStateCore> state = findCachedState(desc, id);
@@ -290,7 +290,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<BlendStateCore> RenderStateCoreManager::_createBlendState(const BLEND_STATE_DESC& desc) const
+	SPtr<BlendStateCore> RenderStateManager::_createBlendState(const BLEND_STATE_DESC& desc) const
 	{
 		UINT32 id = 0;
 		SPtr<BlendStateCore> state = findCachedState(desc, id);
@@ -307,7 +307,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<GraphicsPipelineStateCore> RenderStateCoreManager::_createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc,
+	SPtr<GraphicsPipelineStateCore> RenderStateManager::_createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc,
 		GpuDeviceFlags deviceMask) const
 	{
 		SPtr<GraphicsPipelineStateCore> pipelineState =
@@ -319,7 +319,7 @@ namespace bs
 		return pipelineState;
 	}
 
-	SPtr<ComputePipelineStateCore> RenderStateCoreManager::_createComputePipelineState(const SPtr<GpuProgramCore>& program,
+	SPtr<ComputePipelineStateCore> RenderStateManager::_createComputePipelineState(const SPtr<GpuProgramCore>& program,
 																					   GpuDeviceFlags deviceMask) const
 	{
 		SPtr<ComputePipelineStateCore> pipelineState =
@@ -331,7 +331,7 @@ namespace bs
 		return pipelineState;
 	}
 
-	SPtr<GpuPipelineParamInfoCore> RenderStateCoreManager::_createPipelineParamInfo(
+	SPtr<GpuPipelineParamInfoCore> RenderStateManager::_createPipelineParamInfo(
 		const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
 		SPtr<GpuPipelineParamInfoCore> paramInfo =
@@ -343,7 +343,7 @@ namespace bs
 		return paramInfo;
 	}
 
-	void RenderStateCoreManager::onShutDown()
+	void RenderStateManager::onShutDown()
 	{
 		mDefaultBlendState = nullptr;
 		mDefaultDepthStencilState = nullptr;
@@ -351,7 +351,7 @@ namespace bs
 		mDefaultSamplerState = nullptr;
 	}
 
-	const SPtr<SamplerStateCore>& RenderStateCoreManager::getDefaultSamplerState() const
+	const SPtr<SamplerStateCore>& RenderStateManager::getDefaultSamplerState() const
 	{
 		if (mDefaultSamplerState == nullptr)
 			mDefaultSamplerState = createSamplerState(SAMPLER_STATE_DESC());
@@ -359,7 +359,7 @@ namespace bs
 		return mDefaultSamplerState;
 	}
 
-	const SPtr<BlendStateCore>& RenderStateCoreManager::getDefaultBlendState() const
+	const SPtr<BlendStateCore>& RenderStateManager::getDefaultBlendState() const
 	{
 		if (mDefaultBlendState == nullptr)
 			mDefaultBlendState = createBlendState(BLEND_STATE_DESC());
@@ -367,7 +367,7 @@ namespace bs
 		return mDefaultBlendState;
 	}
 
-	const SPtr<RasterizerStateCore>& RenderStateCoreManager::getDefaultRasterizerState() const
+	const SPtr<RasterizerStateCore>& RenderStateManager::getDefaultRasterizerState() const
 	{
 		if (mDefaultRasterizerState == nullptr)
 			mDefaultRasterizerState = createRasterizerState(RASTERIZER_STATE_DESC());
@@ -375,7 +375,7 @@ namespace bs
 		return mDefaultRasterizerState;
 	}
 
-	const SPtr<DepthStencilStateCore>& RenderStateCoreManager::getDefaultDepthStencilState() const
+	const SPtr<DepthStencilStateCore>& RenderStateManager::getDefaultDepthStencilState() const
 	{
 		if (mDefaultDepthStencilState == nullptr)
 			mDefaultDepthStencilState = createDepthStencilState(DEPTH_STENCIL_STATE_DESC());
@@ -383,42 +383,42 @@ namespace bs
 		return mDefaultDepthStencilState;
 	}
 
-	void RenderStateCoreManager::notifySamplerStateCreated(const SAMPLER_STATE_DESC& desc, const SPtr<SamplerStateCore>& state) const
+	void RenderStateManager::notifySamplerStateCreated(const SAMPLER_STATE_DESC& desc, const SPtr<SamplerStateCore>& state) const
 	{
 		Lock lock(mMutex);
 
 		mCachedSamplerStates[desc] = state;
 	}
 
-	void RenderStateCoreManager::notifyBlendStateCreated(const BLEND_STATE_DESC& desc, const CachedBlendState& state) const
+	void RenderStateManager::notifyBlendStateCreated(const BLEND_STATE_DESC& desc, const CachedBlendState& state) const
 	{
 		Lock lock(mMutex);
 
 		mCachedBlendStates[desc] = state;
 	}
 
-	void RenderStateCoreManager::notifyRasterizerStateCreated(const RASTERIZER_STATE_DESC& desc, const CachedRasterizerState& state) const
+	void RenderStateManager::notifyRasterizerStateCreated(const RASTERIZER_STATE_DESC& desc, const CachedRasterizerState& state) const
 	{
 		Lock lock(mMutex);
 
 		mCachedRasterizerStates[desc] = state;
 	}
 
-	void RenderStateCoreManager::notifyDepthStencilStateCreated(const DEPTH_STENCIL_STATE_DESC& desc, const CachedDepthStencilState& state) const
+	void RenderStateManager::notifyDepthStencilStateCreated(const DEPTH_STENCIL_STATE_DESC& desc, const CachedDepthStencilState& state) const
 	{
 		Lock lock(mMutex);
 
 		mCachedDepthStencilStates[desc] = state;
 	}
 
-	void RenderStateCoreManager::notifySamplerStateDestroyed(const SAMPLER_STATE_DESC& desc) const
+	void RenderStateManager::notifySamplerStateDestroyed(const SAMPLER_STATE_DESC& desc) const
 	{
 		Lock lock(mMutex);
 
 		mCachedSamplerStates.erase(desc);
 	}
 
-	SPtr<SamplerStateCore> RenderStateCoreManager::findCachedState(const SAMPLER_STATE_DESC& desc) const
+	SPtr<SamplerStateCore> RenderStateManager::findCachedState(const SAMPLER_STATE_DESC& desc) const
 	{
 		Lock lock(mMutex);
 
@@ -429,7 +429,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<BlendStateCore> RenderStateCoreManager::findCachedState(const BLEND_STATE_DESC& desc, UINT32& id) const
+	SPtr<BlendStateCore> RenderStateManager::findCachedState(const BLEND_STATE_DESC& desc, UINT32& id) const
 	{
 		Lock lock(mMutex);
 
@@ -450,7 +450,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateCoreManager::findCachedState(const RASTERIZER_STATE_DESC& desc, UINT32& id) const
+	SPtr<RasterizerStateCore> RenderStateManager::findCachedState(const RASTERIZER_STATE_DESC& desc, UINT32& id) const
 	{
 		Lock lock(mMutex);
 
@@ -471,7 +471,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateCoreManager::findCachedState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32& id) const
+	SPtr<DepthStencilStateCore> RenderStateManager::findCachedState(const DEPTH_STENCIL_STATE_DESC& desc, UINT32& id) const
 	{
 		Lock lock(mMutex);
 
@@ -492,7 +492,7 @@ namespace bs
 		return nullptr;
 	}
 
-	SPtr<SamplerStateCore> RenderStateCoreManager::createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const
+	SPtr<SamplerStateCore> RenderStateManager::createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
 		SPtr<SamplerStateCore> state = 
 			bs_shared_ptr<SamplerStateCore>(new (bs_alloc<SamplerStateCore>()) SamplerStateCore(desc, deviceMask));
@@ -501,7 +501,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<DepthStencilStateCore> RenderStateCoreManager::createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const
+	SPtr<DepthStencilStateCore> RenderStateManager::createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const
 	{
 		SPtr<DepthStencilStateCore> state = bs_shared_ptr<DepthStencilStateCore>(new (bs_alloc<DepthStencilStateCore>()) DepthStencilStateCore(desc, id));
 		state->_setThisPtr(state);
@@ -509,7 +509,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<RasterizerStateCore> RenderStateCoreManager::createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const
+	SPtr<RasterizerStateCore> RenderStateManager::createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const
 	{
 		SPtr<RasterizerStateCore> state = bs_shared_ptr<RasterizerStateCore>(new (bs_alloc<RasterizerStateCore>()) RasterizerStateCore(desc, id));
 		state->_setThisPtr(state);
@@ -517,7 +517,7 @@ namespace bs
 		return state;
 	}
 
-	SPtr<BlendStateCore> RenderStateCoreManager::createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const
+	SPtr<BlendStateCore> RenderStateManager::createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const
 	{
 		SPtr<BlendStateCore> state = bs_shared_ptr<BlendStateCore>(new (bs_alloc<BlendStateCore>()) BlendStateCore(desc, id));
 		state->_setThisPtr(state);

Source/BansheeCore/Source/BsRenderTexture.cpp

@@ -112,7 +112,7 @@ namespace bs
 		coreDesc.depthStencilSurface.numFaces = mDesc.depthStencilSurface.numFaces;
 		coreDesc.depthStencilSurface.mipLevel = mDesc.depthStencilSurface.mipLevel;
 
-		return ct::TextureCoreManager::instance().createRenderTextureInternal(coreDesc);
+		return ct::TextureManager::instance().createRenderTextureInternal(coreDesc);
 	}
 
 	CoreSyncData RenderTexture::syncToCore(FrameAlloc* allocator)
@@ -183,7 +183,7 @@ namespace bs
 
 	SPtr<RenderTextureCore> RenderTextureCore::create(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
 	{
-		return TextureCoreManager::instance().createRenderTexture(desc, deviceIdx);
+		return TextureManager::instance().createRenderTexture(desc, deviceIdx);
 	}
 
 	void RenderTextureCore::syncToCore(const CoreSyncData& data)

Source/BansheeCore/Source/BsRenderWindow.cpp

@@ -56,7 +56,7 @@ namespace bs
 			getCore()->getSyncedProperties().mHeight = height;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		onResized();
 
 		gCoreThread().queueCommand(std::bind(resizeFunc, getCore(), width, height));
@@ -79,7 +79,7 @@ namespace bs
 			getCore()->getSyncedProperties().mTop = top;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		gCoreThread().queueCommand(std::bind(moveFunc, getCore(), left, top));
 	}
 
@@ -97,7 +97,7 @@ namespace bs
 			getCore()->getSyncedProperties().mHidden = true;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		gCoreThread().queueCommand(std::bind(hideFunc, getCore()));
 	}
 
@@ -115,7 +115,7 @@ namespace bs
 			getCore()->getSyncedProperties().mHidden = false;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		gCoreThread().queueCommand(std::bind(showFunc, getCore()));
 	}
 
@@ -133,7 +133,7 @@ namespace bs
 			getCore()->getSyncedProperties().mIsMaximized = false;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		gCoreThread().queueCommand(std::bind(minimizeFunc, getCore()));
 	}
 
@@ -151,7 +151,7 @@ namespace bs
 			getCore()->getSyncedProperties().mIsMaximized = true;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		gCoreThread().queueCommand(std::bind(maximizeFunc, getCore()));
 	}
 
@@ -169,7 +169,7 @@ namespace bs
 			getCore()->getSyncedProperties().mIsMaximized = false;
 		}
 
-		ct::RenderWindowCoreManager::instance().notifySyncDataDirty(getCore().get());
+		ct::RenderWindowManager::instance().notifySyncDataDirty(getCore().get());
 		gCoreThread().queueCommand(std::bind(restoreFunc, getCore()));
 	}
 
@@ -214,7 +214,7 @@ namespace bs
 	SPtr<ct::CoreObjectCore> RenderWindow::createCore() const
 	{
 		RENDER_WINDOW_DESC desc = mDesc;
-		return ct::RenderWindowCoreManager::instance().createInternal(desc, mWindowId);
+		return ct::RenderWindowManager::instance().createInternal(desc, mWindowId);
 	}
 
 	SPtr<RenderWindow> RenderWindow::create(RENDER_WINDOW_DESC& desc, SPtr<RenderWindow> parentWindow)
@@ -244,7 +244,7 @@ namespace bs
 	{
 		Platform::resetNonClientAreas(*this);
 
-		RenderWindowCoreManager::instance().windowDestroyed(this);
+		RenderWindowManager::instance().windowDestroyed(this);
 	}
 
 	void RenderWindowCore::setHidden(bool hidden)
@@ -259,7 +259,7 @@ namespace bs
 			getSyncedProperties().mHidden = hidden;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
 	void RenderWindowCore::setActive(bool state)
@@ -274,7 +274,7 @@ namespace bs
 			getSyncedProperties().mActive = state;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
 	void RenderWindowCore::_windowMovedOrResized()
@@ -290,8 +290,8 @@ namespace bs
 			getSyncedProperties().mHeight = props.mHeight;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
-		RenderWindowManager::instance().notifyMovedOrResized(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifyMovedOrResized(this);
 	}
 
 	void RenderWindowCore::_windowFocusReceived()
@@ -305,8 +305,8 @@ namespace bs
 			getSyncedProperties().mHasFocus = true;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
-		RenderWindowManager::instance().notifyFocusReceived(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifyFocusReceived(this);
 	}
 
 	void RenderWindowCore::_windowFocusLost()
@@ -320,8 +320,8 @@ namespace bs
 			getSyncedProperties().mHasFocus = false;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
-		RenderWindowManager::instance().notifyFocusLost(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifyFocusLost(this);
 	}
 
 	void RenderWindowCore::_notifyMaximized()
@@ -336,7 +336,7 @@ namespace bs
 			getSyncedProperties().mIsMaximized = true;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
 	void RenderWindowCore::_notifyMinimized()
@@ -351,7 +351,7 @@ namespace bs
 			getSyncedProperties().mIsMaximized = false;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
 	void RenderWindowCore::_notifyRestored()
@@ -366,7 +366,7 @@ namespace bs
 			getSyncedProperties().mIsMaximized = false;
 		}
 
-		RenderWindowManager::instance().notifySyncDataDirty(this);
+		bs::RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
 	const RenderWindowProperties& RenderWindowCore::getProperties() const

Source/BansheeCore/Source/BsRenderWindowManager.cpp

@@ -20,7 +20,7 @@ namespace bs
 
 	SPtr<RenderWindow> RenderWindowManager::create(RENDER_WINDOW_DESC& desc, SPtr<RenderWindow> parentWindow)
 	{
-		UINT32 id = ct::RenderWindowCoreManager::instance().mNextWindowId.fetch_add(1, std::memory_order_relaxed);
+		UINT32 id = ct::RenderWindowManager::instance().mNextWindowId.fetch_add(1, std::memory_order_relaxed);
 
 		SPtr<RenderWindow> renderWindow = createImpl(desc, id, parentWindow);
 		renderWindow->_setThisPtr(renderWindow);
@@ -207,12 +207,12 @@ namespace bs
 	namespace ct
 	{
 
-	RenderWindowCoreManager::RenderWindowCoreManager()
+	RenderWindowManager::RenderWindowManager()
 	{
 		mNextWindowId = 0;
 	}
 
-	SPtr<RenderWindowCore> RenderWindowCoreManager::create(RENDER_WINDOW_DESC& desc)
+	SPtr<RenderWindowCore> RenderWindowManager::create(RENDER_WINDOW_DESC& desc)
 	{
 		UINT32 id = mNextWindowId.fetch_add(1, std::memory_order_relaxed);
 
@@ -222,7 +222,7 @@ namespace bs
 		return renderWindow;
 	}
 
-	void RenderWindowCoreManager::_update()
+	void RenderWindowManager::_update()
 	{
 		Lock lock(mWindowMutex);
 
@@ -232,14 +232,14 @@ namespace bs
 		mDirtyProperties.clear();
 	}
 
-	void RenderWindowCoreManager::windowCreated(RenderWindowCore* window)
+	void RenderWindowManager::windowCreated(RenderWindowCore* window)
 	{
 		Lock lock(mWindowMutex);
 
 		mCreatedWindows.push_back(window);
 	}
 
-	void RenderWindowCoreManager::windowDestroyed(RenderWindowCore* window)
+	void RenderWindowManager::windowDestroyed(RenderWindowCore* window)
 	{
 		{
 			Lock lock(mWindowMutex);
@@ -254,14 +254,14 @@ namespace bs
 		}
 	}
 
-	Vector<RenderWindowCore*> RenderWindowCoreManager::getRenderWindows() const
+	Vector<RenderWindowCore*> RenderWindowManager::getRenderWindows() const
 	{
 		Lock lock(mWindowMutex);
 
 		return mCreatedWindows;
 	}
 
-	void RenderWindowCoreManager::notifySyncDataDirty(RenderWindowCore* window)
+	void RenderWindowManager::notifySyncDataDirty(RenderWindowCore* window)
 	{
 		Lock lock(mWindowMutex);
 

Source/BansheeCore/Source/BsSamplerState.cpp

@@ -62,7 +62,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> SamplerState::createCore() const
 	{
-		return ct::RenderStateCoreManager::instance()._createSamplerState(mProperties.mData);
+		return ct::RenderStateManager::instance()._createSamplerState(mProperties.mData);
 	}
 
 	SPtr<SamplerState> SamplerState::create(const SAMPLER_STATE_DESC& desc)
@@ -124,7 +124,7 @@ namespace bs
 
 	SamplerStateCore::~SamplerStateCore()
 	{
-		RenderStateCoreManager::instance().notifySamplerStateDestroyed(mProperties.mData);
+		RenderStateManager::instance().notifySamplerStateDestroyed(mProperties.mData);
 	}
 
 	void SamplerStateCore::initialize()
@@ -145,12 +145,12 @@ namespace bs
 
 	SPtr<SamplerStateCore> SamplerStateCore::create(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return RenderStateCoreManager::instance().createSamplerState(desc, deviceMask);
+		return RenderStateManager::instance().createSamplerState(desc, deviceMask);
 	}
 
 	const SPtr<SamplerStateCore>& SamplerStateCore::getDefault()
 	{
-		return RenderStateCoreManager::instance().getDefaultSamplerState();
+		return RenderStateManager::instance().getDefaultSamplerState();
 	}
 
 	}

Source/BansheeCore/Source/BsTexture.cpp

@@ -108,7 +108,7 @@ namespace bs
 	{
 		const TextureProperties& props = getProperties();
 
-		SPtr<ct::CoreObjectCore> coreObj = ct::TextureCoreManager::instance().createTextureInternal(props.mDesc, mInitData);
+		SPtr<ct::CoreObjectCore> coreObj = ct::TextureManager::instance().createTextureInternal(props.mDesc, mInitData);
 
 		if ((mProperties.getUsage() & TU_CPUCACHED) == 0)
 			mInitData = nullptr;
@@ -546,7 +546,7 @@ namespace bs
 	/************************************************************************/
 	SPtr<TextureCore> TextureCore::create(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return TextureCoreManager::instance().createTexture(desc, deviceMask);
+		return TextureManager::instance().createTexture(desc, deviceMask);
 	}
 
 	SPtr<TextureCore> TextureCore::create(const SPtr<PixelData>& pixelData, int usage, bool hwGammaCorrection, 
@@ -561,7 +561,7 @@ namespace bs
 		desc.usage = usage;
 		desc.hwGamma = hwGammaCorrection;
 
-		return TextureCoreManager::instance().createTextureInternal(desc, pixelData, deviceMask);
+		return TextureManager::instance().createTextureInternal(desc, pixelData, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsTextureManager.cpp

@@ -84,7 +84,7 @@ namespace bs
 
 	namespace ct
 	{
-	void TextureCoreManager::onStartUp()
+	void TextureManager::onStartUp()
     {
 		TEXTURE_DESC desc;
 		desc.type = TEX_TYPE_2D;
@@ -131,7 +131,7 @@ namespace bs
 		TextureCore::NORMAL = normalTexture;
     }
 
-	void TextureCoreManager::onShutDown()
+	void TextureManager::onShutDown()
     {
 		// Need to make sure these are freed while still on the core thread
 		TextureCore::WHITE = nullptr;
@@ -139,7 +139,7 @@ namespace bs
 		TextureCore::NORMAL = nullptr;
     }
 
-	SPtr<TextureCore> TextureCoreManager::createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
+	SPtr<TextureCore> TextureManager::createTexture(const TEXTURE_DESC& desc, GpuDeviceFlags deviceMask)
 	{
 		SPtr<TextureCore> newRT = createTextureInternal(desc, nullptr, deviceMask);
 		newRT->initialize();
@@ -147,7 +147,7 @@ namespace bs
 		return newRT;
 	}
 
-	SPtr<RenderTextureCore> TextureCoreManager::createRenderTexture(const RENDER_TEXTURE_DESC& desc, 
+	SPtr<RenderTextureCore> TextureManager::createRenderTexture(const RENDER_TEXTURE_DESC& desc, 
 																	UINT32 deviceIdx)
 	{
 		SPtr<RenderTextureCore> newRT = createRenderTextureInternal(desc, deviceIdx);

Source/BansheeCore/Source/BsVertexBuffer.cpp

@@ -23,7 +23,7 @@ namespace bs
 		desc.usage = mUsage;
 		desc.streamOut = mStreamOut;
 
-		return ct::HardwareBufferCoreManager::instance().createVertexBufferInternal(desc);
+		return ct::HardwareBufferManager::instance().createVertexBufferInternal(desc);
 	}
 
 	SPtr<ct::VertexBufferCore> VertexBuffer::getCore() const
@@ -44,7 +44,7 @@ namespace bs
 
 	SPtr<VertexBufferCore> VertexBufferCore::create(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createVertexBuffer(desc, deviceMask);
+		return HardwareBufferManager::instance().createVertexBuffer(desc, deviceMask);
 	}
 	}
 }

Source/BansheeCore/Source/BsVertexDeclaration.cpp

@@ -261,7 +261,7 @@ namespace bs
 
 	SPtr<ct::CoreObjectCore> VertexDeclaration::createCore() const
 	{
-		return ct::HardwareBufferCoreManager::instance().createVertexDeclarationInternal(mProperties.mElementList);
+		return ct::HardwareBufferManager::instance().createVertexDeclarationInternal(mProperties.mElementList);
 	}
 
 	SPtr<VertexDeclaration> VertexDeclaration::create(const SPtr<VertexDataDesc>& desc)
@@ -334,7 +334,7 @@ namespace bs
 
 	SPtr<VertexDeclarationCore> VertexDeclarationCore::create(const SPtr<VertexDataDesc>& desc, GpuDeviceFlags deviceMask)
 	{
-		return HardwareBufferCoreManager::instance().createVertexDeclaration(desc, deviceMask);
+		return HardwareBufferManager::instance().createVertexDeclaration(desc, deviceMask);
 	}
 
 	bool VertexDeclarationCore::isCompatible(const SPtr<VertexDeclarationCore>& shaderDecl)

Source/BansheeD3D11RenderAPI/Include/BsD3D11HardwareBufferManager.h

@@ -12,25 +12,25 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of DirectX 11 hardware buffers. */
-	class BS_D3D11_EXPORT D3D11HardwareBufferManager : public HardwareBufferCoreManager
+	class BS_D3D11_EXPORT D3D11HardwareBufferManager : public HardwareBufferManager
 	{
 	public:
 		D3D11HardwareBufferManager(D3D11Device& device);
 
 	protected:     
-		/** @copydoc HardwareBufferCoreManager::createVertexBufferInternal */
+		/** @copydoc HardwareBufferManager::createVertexBufferInternal */
 		SPtr<VertexBufferCore> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createIndexBufferInternal */
+		/** @copydoc HardwareBufferManager::createIndexBufferInternal */
 		SPtr<IndexBufferCore> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuParamBlockBufferInternal  */
+		/** @copydoc HardwareBufferManager::createGpuParamBlockBufferInternal  */
 		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBufferInternal(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuBufferInternal */
+		/** @copydoc HardwareBufferManager::createGpuBufferInternal */
 		SPtr<GpuBufferCore> createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 

Source/BansheeD3D11RenderAPI/Include/BsD3D11RenderStateManager.h

@@ -12,19 +12,19 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of DirectX 11 pipeline states. */
-	class BS_D3D11_EXPORT D3D11RenderStateManager : public RenderStateCoreManager
+	class BS_D3D11_EXPORT D3D11RenderStateManager : public RenderStateManager
 	{
 	protected:
-		/** @copydoc RenderStateCoreManager::createSamplerStateInternal */
+		/** @copydoc RenderStateManager::createSamplerStateInternal */
 		SPtr<SamplerStateCore> createSamplerStateInternal(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask) const override;
 
-		/** @copydoc RenderStateCoreManager::createBlendStateInternal */
+		/** @copydoc RenderStateManager::createBlendStateInternal */
 		SPtr<BlendStateCore> createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const override;
 
-		/** @copydoc RenderStateCoreManager::createRasterizerStateInternal */
+		/** @copydoc RenderStateManager::createRasterizerStateInternal */
 		SPtr<RasterizerStateCore> createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const override;
 
-		/** @copydoc RenderStateCoreManager::createDepthStencilStateInternal */
+		/** @copydoc RenderStateManager::createDepthStencilStateInternal */
 		SPtr<DepthStencilStateCore> createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const override;
 	};
 

Source/BansheeD3D11RenderAPI/Include/BsD3D11RenderWindowManager.h

@@ -28,14 +28,14 @@ namespace bs
 
 	namespace ct
 	{
-	/** @copydoc RenderWindowCoreManager */
-	class BS_D3D11_EXPORT D3D11RenderWindowManager : public RenderWindowCoreManager
+	/** @copydoc RenderWindowManager */
+	class BS_D3D11_EXPORT D3D11RenderWindowManager : public RenderWindowManager
 	{
 	public:
 		D3D11RenderWindowManager(D3D11RenderAPI* renderSystem);
 
 	protected:
-		/** @copydoc RenderWindowCoreManager::createInternal */
+		/** @copydoc RenderWindowManager::createInternal */
 		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) override;
 
 	private:

Source/BansheeD3D11RenderAPI/Include/BsD3D11TextureManager.h

@@ -26,14 +26,14 @@ namespace bs
 	namespace ct
 	{
 	/**	Handles creation of DirectX 11 textures. */
-	class BS_D3D11_EXPORT D3D11TextureManager : public TextureCoreManager
+	class BS_D3D11_EXPORT D3D11TextureManager : public TextureManager
 	{
 	protected:
-		/** @copydoc TextureCoreManager::createTextureInternal */
+		/** @copydoc TextureManager::createTextureInternal */
 		SPtr<TextureCore> createTextureInternal(const TEXTURE_DESC& desc, 
 			const SPtr<PixelData>& initialData = nullptr, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc TextureCoreManager::createRenderTextureInternal */
+		/** @copydoc TextureManager::createRenderTextureInternal */
 		SPtr<RenderTextureCore> createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc, 
 			UINT32 deviceIdx = 0) override;
 	};

Source/BansheeD3D11RenderAPI/Source/BsD3D11GpuProgram.cpp

@@ -178,7 +178,7 @@ namespace bs { namespace ct
 			List<VertexElement> inputParams;
 			parser.parse(microcode, mProperties.getType(), *mParametersDesc, &inputParams);
 
-			mInputDeclaration = HardwareBufferCoreManager::instance().createVertexDeclaration(inputParams);
+			mInputDeclaration = HardwareBufferManager::instance().createVertexDeclaration(inputParams);
 		}
 		else
 		{

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderAPI.cpp

@@ -98,28 +98,28 @@ namespace bs { namespace ct
 		mDevice = bs_new<D3D11Device>(device);
 		
 		// Create the texture manager for use by others		
-		TextureManager::startUp<bs::D3D11TextureManager>();
-		TextureCoreManager::startUp<D3D11TextureManager>();
+		bs::TextureManager::startUp<bs::D3D11TextureManager>();
+		TextureManager::startUp<D3D11TextureManager>();
 
 		// Create hardware buffer manager		
-		HardwareBufferManager::startUp();
-		HardwareBufferCoreManager::startUp<D3D11HardwareBufferManager>(std::ref(*mDevice));
+		bs::HardwareBufferManager::startUp();
+		HardwareBufferManager::startUp<D3D11HardwareBufferManager>(std::ref(*mDevice));
 
 		// Create render window manager
-		RenderWindowManager::startUp<bs::D3D11RenderWindowManager>(this);
-		RenderWindowCoreManager::startUp<D3D11RenderWindowManager>(this);
+		bs::RenderWindowManager::startUp<bs::D3D11RenderWindowManager>(this);
+		RenderWindowManager::startUp<D3D11RenderWindowManager>(this);
 
 		// Create & register HLSL factory		
 		mHLSLFactory = bs_new<D3D11HLSLProgramFactory>();
 
 		// Create render state manager
-		RenderStateCoreManager::startUp<D3D11RenderStateManager>();
+		RenderStateManager::startUp<D3D11RenderStateManager>();
 
 		mNumDevices = 1;
 		mCurrentCapabilities = bs_newN<RenderAPICapabilities>(mNumDevices);
 		initCapabilites(selectedAdapter, mCurrentCapabilities[0]);
 				
-		GpuProgramCoreManager::instance().addFactory(mHLSLFactory);
+		GpuProgramManager::instance().addFactory(mHLSLFactory);
 
 		mIAManager = bs_new<D3D11InputLayoutManager>();
 
@@ -179,13 +179,13 @@ namespace bs { namespace ct
 		mActiveRenderTarget = nullptr;
 		mActiveDepthStencilState = nullptr;
 
-		RenderStateCoreManager::shutDown();
-		RenderWindowCoreManager::shutDown();
+		RenderStateManager::shutDown();
 		RenderWindowManager::shutDown();
-		HardwareBufferCoreManager::shutDown();
+		bs::RenderWindowManager::shutDown();
 		HardwareBufferManager::shutDown();
-		TextureCoreManager::shutDown();
+		bs::HardwareBufferManager::shutDown();
 		TextureManager::shutDown();
+		bs::TextureManager::shutDown();
 
 		SAFE_RELEASE(mDXGIFactory);
 

Source/BansheeD3D11RenderAPI/Source/BsD3D11RenderUtility.cpp

@@ -112,25 +112,25 @@ namespace bs { namespace ct
 	void D3D11RenderUtility::initClearQuadResources()
 	{
 		BLEND_STATE_DESC blendStateDescYesC;
-		mClearQuadBlendStateYesC = RenderStateCoreManager::instance().createBlendState(blendStateDescYesC);
+		mClearQuadBlendStateYesC = RenderStateManager::instance().createBlendState(blendStateDescYesC);
 
 		BLEND_STATE_DESC blendStateDescNoC;
 		for(int i = 0; i < BS_MAX_MULTIPLE_RENDER_TARGETS; i++)
 			blendStateDescNoC.renderTargetDesc[i].renderTargetWriteMask = 0;
 
-		mClearQuadBlendStateNoC = RenderStateCoreManager::instance().createBlendState(blendStateDescNoC);
+		mClearQuadBlendStateNoC = RenderStateManager::instance().createBlendState(blendStateDescNoC);
 
 		DEPTH_STENCIL_STATE_DESC depthStateDescNoD_NoS;
 		depthStateDescNoD_NoS.depthReadEnable = false;
 		depthStateDescNoD_NoS.depthWriteEnable = false;
 		depthStateDescNoD_NoS.depthComparisonFunc = CMPF_ALWAYS_PASS;
-		mClearQuadDSStateNoD_NoS = RenderStateCoreManager::instance().createDepthStencilState(depthStateDescNoD_NoS);
+		mClearQuadDSStateNoD_NoS = RenderStateManager::instance().createDepthStencilState(depthStateDescNoD_NoS);
 
 		DEPTH_STENCIL_STATE_DESC depthStateDescYesD_NoS;
 		depthStateDescYesD_NoS.depthReadEnable = false;
 		depthStateDescYesD_NoS.depthWriteEnable = false; // TODO - Set to true
 		//depthStateDescYesD_NoS.depthComparisonFunc = CMPF_ALWAYS_PASS;
-		mClearQuadDSStateYesD_NoS = RenderStateCoreManager::instance().createDepthStencilState(depthStateDescYesD_NoS);
+		mClearQuadDSStateYesD_NoS = RenderStateManager::instance().createDepthStencilState(depthStateDescYesD_NoS);
 
 		DEPTH_STENCIL_STATE_DESC depthStateDescYesD_YesS;
 		depthStateDescYesD_YesS.depthReadEnable = false;
@@ -139,7 +139,7 @@ namespace bs { namespace ct
 		depthStateDescYesD_YesS.stencilEnable = true;
 		depthStateDescYesD_YesS.frontStencilComparisonFunc = CMPF_ALWAYS_PASS;
 		depthStateDescYesD_YesS.frontStencilPassOp = SOP_REPLACE;
-		mClearQuadDSStateYesD_YesS = RenderStateCoreManager::instance().createDepthStencilState(depthStateDescYesD_YesS);
+		mClearQuadDSStateYesD_YesS = RenderStateManager::instance().createDepthStencilState(depthStateDescYesD_YesS);
 
 		DEPTH_STENCIL_STATE_DESC depthStateDescNoD_YesS;
 		depthStateDescNoD_YesS.depthReadEnable = false;
@@ -147,10 +147,10 @@ namespace bs { namespace ct
 		depthStateDescNoD_YesS.depthComparisonFunc = CMPF_ALWAYS_PASS;
 		depthStateDescNoD_YesS.stencilEnable = true;
 		depthStateDescNoD_YesS.frontStencilComparisonFunc = CMPF_ALWAYS_PASS;
-		mClearQuadDSStateNoD_YesS = RenderStateCoreManager::instance().createDepthStencilState(depthStateDescNoD_YesS);
+		mClearQuadDSStateNoD_YesS = RenderStateManager::instance().createDepthStencilState(depthStateDescNoD_YesS);
 
 		RASTERIZER_STATE_DESC rasterizerStateDesc;
-		mClearQuadRasterizerState = RenderStateCoreManager::instance().createRasterizerState(rasterizerStateDesc);
+		mClearQuadRasterizerState = RenderStateManager::instance().createRasterizerState(rasterizerStateDesc);
 
 		String vsShaderCode = "										\
 						void main(									\

Source/BansheeEngine/Source/BsGUIManager.cpp

@@ -1747,7 +1747,7 @@ namespace bs
 		ssDesc.minFilter = FO_POINT;
 		ssDesc.mipFilter = FO_POINT;
 
-		mSamplerState = RenderStateCoreManager::instance().createSamplerState(ssDesc);
+		mSamplerState = RenderStateManager::instance().createSamplerState(ssDesc);
 	}
 
 	bool GUIRenderer::check(const CameraCore& camera)

Source/BansheeGLRenderAPI/Include/BsGLHardwareBufferManager.h

@@ -12,7 +12,7 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of OpenGL specific hardware buffers. */
-    class BS_RSGL_EXPORT GLHardwareBufferManager : public HardwareBufferCoreManager
+    class BS_RSGL_EXPORT GLHardwareBufferManager : public HardwareBufferManager
     {
     public:
 		/**	Converts engine buffer usage flags into OpenGL specific flags. */
@@ -22,19 +22,19 @@ namespace bs { namespace ct
         static GLenum getGLType(VertexElementType type);
 
 	protected:
-		/** @copydoc HardwareBufferCoreManager::createVertexBufferInternal */
+		/** @copydoc HardwareBufferManager::createVertexBufferInternal */
         SPtr<VertexBufferCore> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
         	GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createIndexBufferInternal */
+		/** @copydoc HardwareBufferManager::createIndexBufferInternal */
 		SPtr<IndexBufferCore> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuParamBlockBufferInternal */
+		/** @copydoc HardwareBufferManager::createGpuParamBlockBufferInternal */
 		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBufferInternal(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuBufferInternal */
+		/** @copydoc HardwareBufferManager::createGpuBufferInternal */
 		SPtr<GpuBufferCore> createGpuBufferInternal(const GPU_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
     };

Source/BansheeGLRenderAPI/Include/BsGLRenderWindowManager.h

@@ -28,13 +28,13 @@ namespace bs
 	namespace ct
 	{
 	/**	Manager that handles window creation for OpenGL. */
-	class BS_RSGL_EXPORT GLRenderWindowManager : public RenderWindowCoreManager
+	class BS_RSGL_EXPORT GLRenderWindowManager : public RenderWindowManager
 	{
 	public:
 		GLRenderWindowManager(GLRenderAPI* renderSystem);
 
 	protected:
-		/** @copydoc RenderWindowCoreManager::createInternal */
+		/** @copydoc RenderWindowManager::createInternal */
 		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) override;
 
 	private:

Source/BansheeGLRenderAPI/Include/BsGLTextureManager.h

@@ -35,17 +35,17 @@ namespace bs
 	namespace ct
 	{
 	/** Handles creation of OpenGL textures. */
-	class BS_RSGL_EXPORT GLTextureManager : public TextureCoreManager
+	class BS_RSGL_EXPORT GLTextureManager : public TextureManager
 	{
 	public:
 		GLTextureManager(GLSupport& support);
 
 	protected:		
-		/** @copydoc TextureCoreManager::createTextureInternal */
+		/** @copydoc TextureManager::createTextureInternal */
 		SPtr<TextureCore> createTextureInternal(const TEXTURE_DESC& desc,
 			const SPtr<PixelData>& initialData = nullptr, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc TextureCoreManager::createRenderTextureInternal */
+		/** @copydoc TextureManager::createRenderTextureInternal */
 		SPtr<RenderTextureCore> createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc, 
 			UINT32 deviceIdx = 0) override;
 

Source/BansheeGLRenderAPI/Source/BsGLRenderAPI.cpp

@@ -100,9 +100,9 @@ namespace bs { namespace ct
 
 		CommandBufferManager::startUp<GLCommandBufferManager>();
 		bs::RenderWindowManager::startUp<bs::GLRenderWindowManager>(this);
-		RenderWindowCoreManager::startUp<GLRenderWindowManager>(this);
+		RenderWindowManager::startUp<GLRenderWindowManager>(this);
 
-		RenderStateCoreManager::startUp();
+		RenderStateManager::startUp();
 
 		QueryManager::startUp<GLQueryManager>();
 
@@ -153,14 +153,14 @@ namespace bs { namespace ct
 		if (mGLSLProgramFactory)
 		{
 			// Remove from manager safely
-			GpuProgramCoreManager::instance().removeFactory(mGLSLProgramFactory);
+			GpuProgramManager::instance().removeFactory(mGLSLProgramFactory);
 			bs_delete(mGLSLProgramFactory);
 			mGLSLProgramFactory = nullptr;
 		}
 
 		// Deleting the hardware buffer manager.  Has to be done before the mGLSupport->stop().
-		HardwareBufferCoreManager::shutDown();
 		HardwareBufferManager::shutDown();
+		bs::HardwareBufferManager::shutDown();
 		GLRTTManager::shutDown();
 
 		for (UINT32 i = 0; i < MAX_VB_COUNT; i++)
@@ -178,12 +178,12 @@ namespace bs { namespace ct
 
 		mGLSupport->stop();
 
-		TextureCoreManager::shutDown();
 		TextureManager::shutDown();
+		bs::TextureManager::shutDown();
 		QueryManager::shutDown();
-		RenderWindowCoreManager::shutDown();
 		RenderWindowManager::shutDown();
-		RenderStateCoreManager::shutDown();
+		bs::RenderWindowManager::shutDown();
+		RenderStateManager::shutDown();
 		GLVertexArrayObjectManager::shutDown(); // Note: Needs to be after QueryManager shutdown as some resources might be waiting for queries to complete
 		CommandBufferManager::shutDown();
 
@@ -1992,13 +1992,13 @@ namespace bs { namespace ct
 #endif
 
 		HardwareBufferManager::startUp();
-		HardwareBufferCoreManager::startUp<GLHardwareBufferManager>();
+		HardwareBufferManager::startUp<GLHardwareBufferManager>();
 
 		// GPU Program Manager setup
 		if(caps->isShaderProfileSupported("glsl"))
 		{
 			mGLSLProgramFactory = bs_new<GLSLProgramFactory>();
-			GpuProgramCoreManager::instance().addFactory(mGLSLProgramFactory);
+			GpuProgramManager::instance().addFactory(mGLSLProgramFactory);
 		}
 
 		GLRTTManager::startUp<GLRTTManager>();
@@ -2019,7 +2019,7 @@ namespace bs { namespace ct
 			mTextureInfos[i].type = GL_TEXTURE_2D;
 		
 		bs::TextureManager::startUp<bs::GLTextureManager>(std::ref(*mGLSupport));
-		TextureCoreManager::startUp<GLTextureManager>(std::ref(*mGLSupport));
+		TextureManager::startUp<GLTextureManager>(std::ref(*mGLSupport));
 	}
 
 	void GLRenderAPI::switchContext(const SPtr<GLContext>& context)

Source/BansheeGLRenderAPI/Source/GLSL/src/BsGLSLGpuProgram.cpp

@@ -194,7 +194,7 @@ namespace bs { namespace ct
 			if (mProperties.getType() == GPT_VERTEX_PROGRAM)
 			{
 				List<VertexElement> elementList = paramParser.buildVertexDeclaration(mGLHandle);
-				mInputDeclaration = HardwareBufferCoreManager::instance().createVertexDeclaration(elementList);
+				mInputDeclaration = HardwareBufferManager::instance().createVertexDeclaration(elementList);
 			}
 		}
 

Source/BansheeVulkanRenderAPI/Include/BsVulkanHardwareBufferManager.h

@@ -12,7 +12,7 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of Vulkan hardware buffers. */
-	class VulkanHardwareBufferManager : public HardwareBufferCoreManager
+	class VulkanHardwareBufferManager : public HardwareBufferManager
 	{
 	public:
 		VulkanHardwareBufferManager();
@@ -28,23 +28,23 @@ namespace bs { namespace ct
 		VkBuffer getDummyUniformBuffer(UINT32 deviceIdx) const;
 
 	protected:     
-		/** @copydoc HardwareBufferCoreManager::createVertexBufferInternal */
+		/** @copydoc HardwareBufferManager::createVertexBufferInternal */
 		SPtr<VertexBufferCore> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createIndexBufferInternal */
+		/** @copydoc HardwareBufferManager::createIndexBufferInternal */
 		SPtr<IndexBufferCore> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuParamBlockBufferInternal  */
+		/** @copydoc HardwareBufferManager::createGpuParamBlockBufferInternal  */
 		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBufferInternal(UINT32 size, 
 			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuBufferInternal */
+		/** @copydoc HardwareBufferManager::createGpuBufferInternal */
 		SPtr<GpuBufferCore> createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc HardwareBufferCoreManager::createGpuParamsInternal */
+		/** @copydoc HardwareBufferManager::createGpuParamsInternal */
 		SPtr<GpuParamsCore> createGpuParamsInternal(const SPtr<GpuPipelineParamInfoCore>& paramInfo,
 													GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderStateManager.h

@@ -12,22 +12,22 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of Vulkan pipeline states. */
-	class VulkanRenderStateManager : public RenderStateCoreManager
+	class VulkanRenderStateManager : public RenderStateManager
 	{
 	protected:
-		/** @copydoc RenderStateCoreManager::createSamplerStateStateInternal */
+		/** @copydoc RenderStateManager::createSamplerStateStateInternal */
 		SPtr<SamplerStateCore> createSamplerStateInternal(const SAMPLER_STATE_DESC& desc,
 			GpuDeviceFlags deviceMask) const override;
 
-		/** @copydoc RenderStateCoreManager::_createGraphicsPipelineState */
+		/** @copydoc RenderStateManager::_createGraphicsPipelineState */
 		SPtr<GraphicsPipelineStateCore> _createGraphicsPipelineState(const PIPELINE_STATE_DESC& desc,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const override;
 
-		/** @copydoc RenderStateCoreManager::_createComputePipelineState */
+		/** @copydoc RenderStateManager::_createComputePipelineState */
 		SPtr<ComputePipelineStateCore> _createComputePipelineState(const SPtr<GpuProgramCore>& program,
 			GpuDeviceFlags deviceMask = GDF_DEFAULT) const override;
 
-		/** @copydoc RenderStateCoreManager::_createPipelineParamInfo */
+		/** @copydoc RenderStateManager::_createPipelineParamInfo */
 		SPtr<GpuPipelineParamInfoCore> _createPipelineParamInfo(const GPU_PIPELINE_PARAMS_DESC& desc,
 			 GpuDeviceFlags deviceMask = GDF_DEFAULT) const override;
 	};

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderWindowManager.h

@@ -24,14 +24,14 @@ namespace bs
 
 	namespace ct
 	{
-	/** @copydoc RenderWindowCoreManager */
-	class VulkanRenderWindowManager : public RenderWindowCoreManager
+	/** @copydoc RenderWindowManager */
+	class VulkanRenderWindowManager : public RenderWindowManager
 	{
 	public:
 		VulkanRenderWindowManager(VulkanRenderAPI& renderAPI);
 
 	protected:
-		/** @copydoc RenderWindowCoreManager::createInternal */
+		/** @copydoc RenderWindowManager::createInternal */
 		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) override;
 
 		VulkanRenderAPI& mRenderAPI;

Source/BansheeVulkanRenderAPI/Include/BsVulkanTextureManager.h

@@ -26,10 +26,10 @@ namespace bs
 	namespace ct
 	{
 	/**	Handles creation of Vulkan textures. */
-	class VulkanTextureManager : public TextureCoreManager
+	class VulkanTextureManager : public TextureManager
 	{
 	public:
-		/** @copydoc TextureCoreManager::onStartUp */
+		/** @copydoc TextureManager::onStartUp */
 		void onStartUp() override;
 
 		/** Returns a image view that can be used for shader read operations when no other image is bound. */
@@ -39,11 +39,11 @@ namespace bs
 		VkImageView getDummyStorageImageView(UINT32 deviceIdx) const;
 
 	protected:
-		/** @copydoc TextureCoreManager::createTextureInternal */
+		/** @copydoc TextureManager::createTextureInternal */
 		SPtr<TextureCore> createTextureInternal(const TEXTURE_DESC& desc, 
 			const SPtr<PixelData>& initialData = nullptr, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 
-		/** @copydoc TextureCoreManager::createRenderTextureInternal */
+		/** @copydoc TextureManager::createRenderTextureInternal */
 		SPtr<RenderTextureCore> createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc, 
 			UINT32 deviceIdx = 0) override;
 

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuParams.cpp

@@ -88,9 +88,9 @@ namespace bs { namespace ct
 		bs_zero_out(mSetsDirty, numSets);
 
 		VulkanSamplerState* defaultSampler = static_cast<VulkanSamplerState*>(SamplerStateCore::getDefault().get());
-		VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(TextureCoreManager::instance());
+		VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(TextureManager::instance());
 		VulkanHardwareBufferManager& vkBufManager = static_cast<VulkanHardwareBufferManager&>(
-			HardwareBufferCoreManager::instance());
+			HardwareBufferManager::instance());
 
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
@@ -250,7 +250,7 @@ namespace bs { namespace ct
 			else
 			{
 				VulkanHardwareBufferManager& vkBufManager = static_cast<VulkanHardwareBufferManager&>(
-					HardwareBufferCoreManager::instance());
+					HardwareBufferManager::instance());
 
 				perSetData.writeInfos[bindingIdx].buffer.buffer = vkBufManager.getDummyUniformBuffer(i);
 				mPerDeviceData[i].uniformBuffers[sequentialIdx] = VK_NULL_HANDLE;
@@ -298,7 +298,7 @@ namespace bs { namespace ct
 			else
 			{
 				VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(
-					TextureCoreManager::instance());
+					TextureManager::instance());
 
 				perSetData.writeInfos[bindingIdx].image.imageView = vkTexManager.getDummyReadImageView(i);
 				mPerDeviceData[i].sampledImages[sequentialIdx] = VK_NULL_HANDLE;
@@ -347,7 +347,7 @@ namespace bs { namespace ct
 			else
 			{
 				VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(
-					TextureCoreManager::instance());
+					TextureManager::instance());
 
 				perSetData.writeInfos[bindingIdx].image.imageView = vkTexManager.getDummyStorageImageView(i);
 				mPerDeviceData[i].storageImages[sequentialIdx] = VK_NULL_HANDLE;
@@ -399,7 +399,7 @@ namespace bs { namespace ct
 			else
 			{
 				VulkanHardwareBufferManager& vkBufManager = static_cast<VulkanHardwareBufferManager&>(
-					HardwareBufferCoreManager::instance());
+					HardwareBufferManager::instance());
 
 				bool isLoadStore = writeSetInfo.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
 				if(isLoadStore)

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuProgram.cpp

@@ -627,7 +627,7 @@ namespace bs { namespace ct
 			List<VertexElement> elementList;
 					
 			if (parseVertexAttributes(program, elementList, mCompileError))
-				mInputDeclaration = HardwareBufferCoreManager::instance().createVertexDeclaration(elementList, mDeviceMask);
+				mInputDeclaration = HardwareBufferManager::instance().createVertexDeclaration(elementList, mDeviceMask);
 			else
 			{
 				mIsCompiled = false;

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderAPI.cpp

@@ -237,15 +237,15 @@ namespace bs { namespace ct
 
 		// Create the texture manager for use by others		
 		bs::TextureManager::startUp<bs::VulkanTextureManager>();
-		TextureCoreManager::startUp<VulkanTextureManager>();
+		TextureManager::startUp<VulkanTextureManager>();
 
 		// Create hardware buffer manager		
-		HardwareBufferManager::startUp();
-		HardwareBufferCoreManager::startUp<VulkanHardwareBufferManager>();
+		bs::HardwareBufferManager::startUp();
+		HardwareBufferManager::startUp<VulkanHardwareBufferManager>();
 
 		// Create render window manager
 		bs::RenderWindowManager::startUp<bs::VulkanRenderWindowManager>();
-		RenderWindowCoreManager::startUp<VulkanRenderWindowManager>(*this);
+		RenderWindowManager::startUp<VulkanRenderWindowManager>(*this);
 
 		// Create query manager 
 		QueryManager::startUp<VulkanQueryManager>(*this);
@@ -257,8 +257,8 @@ namespace bs { namespace ct
 		mGLSLFactory = bs_new<VulkanGLSLProgramFactory>();
 
 		// Create render state manager
-		RenderStateCoreManager::startUp<VulkanRenderStateManager>();
-		GpuProgramCoreManager::instance().addFactory(mGLSLFactory);
+		RenderStateManager::startUp<VulkanRenderStateManager>();
+		GpuProgramManager::instance().addFactory(mGLSLFactory);
 
 		initCapabilites();
 		
@@ -277,13 +277,13 @@ namespace bs { namespace ct
 
 		VulkanVertexInputManager::shutDown();
 		QueryManager::shutDown();
-		RenderStateCoreManager::shutDown();
-		RenderWindowCoreManager::shutDown();
+		RenderStateManager::shutDown();
 		RenderWindowManager::shutDown();
-		HardwareBufferCoreManager::shutDown();
+		bs::RenderWindowManager::shutDown();
 		HardwareBufferManager::shutDown();
-		TextureCoreManager::shutDown();
+		bs::HardwareBufferManager::shutDown();
 		TextureManager::shutDown();
+		bs::TextureManager::shutDown();
 
 		mMainCommandBuffer = nullptr;
 

Source/BansheeVulkanRenderAPI/Source/BsVulkanTextureManager.cpp

@@ -23,7 +23,7 @@ namespace bs
 	{
 	void VulkanTextureManager::onStartUp()
 	{
-		TextureCoreManager::onStartUp();
+		TextureManager::onStartUp();
 
 		SPtr<PixelData> whitePixelData = PixelData::create(2, 2, 1, PF_R8G8B8A8);
 		whitePixelData->setColorAt(Color::White, 0, 0);

Source/RenderBeast/Source/BsRenderTargets.cpp

@@ -85,7 +85,7 @@ namespace bs { namespace ct
 			sceneColorDesc.depthStencilSurface.numFaces = 1;
 			sceneColorDesc.depthStencilSurface.mipLevel = 0;
 
-			mSceneColorRT = TextureCoreManager::instance().createRenderTexture(sceneColorDesc);
+			mSceneColorRT = TextureManager::instance().createRenderTexture(sceneColorDesc);
 		}
 	}
 

Source/RenderBeast/Source/BsRenderTexturePool.cpp

@@ -55,7 +55,7 @@ namespace bs { namespace ct
 		texDesc.hwGamma = desc.hwGamma;
 		texDesc.numSamples = desc.numSamples;
 
-		newTextureData->texture = TextureCoreManager::instance().createTexture(texDesc);
+		newTextureData->texture = TextureManager::instance().createTexture(texDesc);
 		
 		if ((desc.flag & (TU_RENDERTARGET | TU_DEPTHSTENCIL)) != 0)
 		{
@@ -77,7 +77,7 @@ namespace bs { namespace ct
 				rtDesc.depthStencilSurface.mipLevel = 0;
 			}
 
-			newTextureData->renderTexture = TextureCoreManager::instance().createRenderTexture(rtDesc);
+			newTextureData->renderTexture = TextureManager::instance().createRenderTexture(rtDesc);
 		}
 
 		return newTextureData;

Source/RenderBeast/Source/BsSamplerOverrides.cpp

@@ -287,6 +287,6 @@ namespace bs { namespace ct
 
 		desc.maxAniso = options->anisotropyMax;
 
-		return RenderStateCoreManager::instance().createSamplerState(desc);
+		return RenderStateManager::instance().createSamplerState(desc);
 	}
 }}