Cleanup: Getting rid of the Core suffix on core thread objects since they're now in their own namespace (Contd.)

Source/BansheeVulkanRenderAPI/Include/BsVulkanCommandBuffer.h

@@ -394,8 +394,8 @@ namespace bs { namespace ct
 		Vector<ImageInfo> mImageInfos;
 		UINT32 mGlobalQueueIdx;
 
-		SPtr<VulkanGraphicsPipelineStateCore> mGraphicsPipeline;
-		SPtr<VulkanComputePipelineStateCore> mComputePipeline;
+		SPtr<VulkanGraphicsPipelineState> mGraphicsPipeline;
+		SPtr<VulkanComputePipelineState> mComputePipeline;
 		SPtr<VertexDeclarationCore> mVertexDecl;
 		Rect2 mViewport;
 		Rect2I mScissor;

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuBuffer.h

@@ -12,10 +12,10 @@ namespace bs { namespace ct
 	 */
 
 	/**	DirectX 11 implementation of a generic GPU buffer. */
-	class VulkanGpuBufferCore : public GpuBufferCore
+	class VulkanGpuBuffer : public GpuBufferCore
     {
     public:
-		~VulkanGpuBufferCore();
+		~VulkanGpuBuffer();
 
 		/** @copydoc GpuBufferCore::lock */
 		void* lock(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx = 0, UINT32 queueIdx = 0) override;
@@ -40,9 +40,9 @@ namespace bs { namespace ct
 		 */
 		VulkanBuffer* getResource(UINT32 deviceIdx) const;
 	protected:
-		friend class VulkanHardwareBufferCoreManager;
+		friend class VulkanHardwareBufferManager;
 
-		VulkanGpuBufferCore(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
+		VulkanGpuBuffer(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
 
 		/** @copydoc GpuBufferCore::initialize */
 		void initialize() override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuParamBlockBuffer.h

@@ -12,11 +12,11 @@ namespace bs { namespace ct
 	 */
 
 	/**	Vulkan implementation of a parameter block buffer (uniform buffer in Vulkan lingo). */
-	class VulkanGpuParamBlockBufferCore : public GpuParamBlockBufferCore
+	class VulkanGpuParamBlockBuffer : public GpuParamBlockBufferCore
 	{
 	public:
-		VulkanGpuParamBlockBufferCore(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask);
-		~VulkanGpuParamBlockBufferCore();
+		VulkanGpuParamBlockBuffer(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask);
+		~VulkanGpuParamBlockBuffer();
 
 		/** @copydoc GpuParamBlockBufferCore::writeToGPU */
 		void writeToGPU(const UINT8* data, UINT32 queueIdx = 0) override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuParams.h

@@ -87,7 +87,7 @@ namespace bs { namespace ct
 			VkSampler* samplers;
 		};
 
-		friend class VulkanHardwareBufferCoreManager;
+		friend class VulkanHardwareBufferManager;
 
 		VulkanGpuParams(const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask);
 

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuPipelineState.h

@@ -37,10 +37,10 @@ namespace bs { namespace ct
 	};
 
 	/**	Vulkan implementation of a graphics pipeline state. */
-	class VulkanGraphicsPipelineStateCore : public GraphicsPipelineStateCore
+	class VulkanGraphicsPipelineState : public GraphicsPipelineStateCore
 	{
 	public:
-		~VulkanGraphicsPipelineStateCore();
+		~VulkanGraphicsPipelineState();
 
 		/** Checks does the pipeline enable scissor tests. */
 		bool isScissorEnabled() const { return mScissorEnabled; }
@@ -77,9 +77,9 @@ namespace bs { namespace ct
 		void registerPipelineResources(VulkanCmdBuffer* cmdBuffer);
 
 	protected:
-		friend class VulkanRenderStateCoreManager;
+		friend class VulkanRenderStateManager;
 
-		VulkanGraphicsPipelineStateCore(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask);
+		VulkanGraphicsPipelineState(const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask);
 
 		/**	@copydoc GraphicsPipelineStateCore::initialize */
 		void initialize() override;
@@ -154,10 +154,10 @@ namespace bs { namespace ct
 	};
 
 	/**	Vulkan implementation of a compute pipeline state. */
-	class VulkanComputePipelineStateCore : public ComputePipelineStateCore
+	class VulkanComputePipelineState : public ComputePipelineStateCore
 	{
 	public:
-		~VulkanComputePipelineStateCore();
+		~VulkanComputePipelineState();
 
 		/** 
 		 * Returns a pipeline object for the specified device index. If the device index doesn't match a bit in the
@@ -178,9 +178,9 @@ namespace bs { namespace ct
 		void registerPipelineResources(VulkanCmdBuffer* cmdBuffer);
 
 	protected:
-		friend class VulkanRenderStateCoreManager;
+		friend class VulkanRenderStateManager;
 
-		VulkanComputePipelineStateCore(const SPtr<GpuProgramCore>& program, GpuDeviceFlags deviceMask);
+		VulkanComputePipelineState(const SPtr<GpuProgramCore>& program, GpuDeviceFlags deviceMask);
 
 		/**	@copydoc ComputePipelineStateCore::initialize */
 		void initialize() override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuProgram.h

@@ -27,10 +27,10 @@ namespace bs { namespace ct
 	};
 
 	/**	Abstraction of a Vulkan shader object. */
-	class VulkanGpuProgramCore : public GpuProgramCore
+	class VulkanGpuProgram : public GpuProgramCore
 	{
 	public:
-		virtual ~VulkanGpuProgramCore();
+		virtual ~VulkanGpuProgram();
 
 		/** 
 		 * Returns the shader module for the specified device. If program device mask doesn't include the provided device, 
@@ -41,7 +41,7 @@ namespace bs { namespace ct
 	protected:
 		friend class VulkanGLSLProgramFactory;
 
-		VulkanGpuProgramCore(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask);
+		VulkanGpuProgram(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask);
 
 		/** @copydoc GpuProgramCore::initialize */
 		void initialize() override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanHardwareBufferManager.h

@@ -12,11 +12,11 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of Vulkan hardware buffers. */
-	class VulkanHardwareBufferCoreManager : public HardwareBufferCoreManager
+	class VulkanHardwareBufferManager : public HardwareBufferCoreManager
 	{
 	public:
-		VulkanHardwareBufferCoreManager();
-		~VulkanHardwareBufferCoreManager();
+		VulkanHardwareBufferManager();
+		~VulkanHardwareBufferManager();
 
 		/** Returns a buffer view that can be used for buffer read operations when no other buffer is bound. */
 		VkBufferView getDummyReadBufferView(UINT32 deviceIdx) const;

Source/BansheeVulkanRenderAPI/Include/BsVulkanIndexBuffer.h

@@ -12,11 +12,11 @@ namespace bs { namespace ct
 	 */
 
 	/**	Vulkan implementation of an index buffer. */
-	class VulkanIndexBufferCore : public IndexBufferCore
+	class VulkanIndexBuffer : public IndexBufferCore
 	{
 	public:
-		VulkanIndexBufferCore(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
-		~VulkanIndexBufferCore();
+		VulkanIndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
+		~VulkanIndexBuffer();
 
 		/** @copydoc IndexBufferCore::readData */
 		void readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx = 0, UINT32 queueIdx = 0) override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanPrerequisites.h

@@ -48,7 +48,7 @@ namespace bs { namespace ct
 {
 	class VulkanRenderAPI;
 	class Win32RenderWindow;
-	class VulkanTextureCore;
+	class VulkanTexture;
 	class Win32VideoMode;
 	class VulkanVertexDeclaration;
 	class VulkanHardwareBuffer;
@@ -64,7 +64,7 @@ namespace bs { namespace ct
 	class VulkanCommandBuffer;
 	class VulkanQueue;
 	class VulkanResourceManager;
-	class VulkanGpuParamBlockBufferCore;
+	class VulkanGpuParamBlockBuffer;
 	class VulkanBuffer;
 	class VulkanImage;
 	class VulkanDescriptorPool;

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderStateManager.h

@@ -12,7 +12,7 @@ namespace bs { namespace ct
 	 */
 
 	/**	Handles creation of Vulkan pipeline states. */
-	class VulkanRenderStateCoreManager : public RenderStateCoreManager
+	class VulkanRenderStateManager : public RenderStateCoreManager
 	{
 	protected:
 		/** @copydoc RenderStateCoreManager::createSamplerStateStateInternal */

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderTexture.h

@@ -6,60 +6,62 @@
 #include "BsTexture.h"
 #include "BsRenderTexture.h"
 
-namespace bs { namespace ct
+namespace bs
 {
 	/** @addtogroup Vulkan
 	 *  @{
 	 */
 
-	class VulkanRenderTexture;
-
 	/**
 	 * Vulkan implementation of a render texture.
 	 *
-	 * @note	Core thread only.
+	 * @note	Sim thread only.
 	 */
-	class VulkanRenderTextureCore : public RenderTextureCore
+	class VulkanRenderTexture : public RenderTexture
 	{
 	public:
-		VulkanRenderTextureCore(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx);
-		virtual ~VulkanRenderTextureCore();
-
-		/** @copydoc RenderTextureCore::getCustomAttribute */
-		void getCustomAttribute(const String& name, void* data) const override;
+		virtual ~VulkanRenderTexture() { }
 
 	protected:
-		/** @copydoc CoreObjectCore::initialize() */
-		void initialize() override;
+		friend class VulkanTextureManager;
 
-		/** @copydoc RenderTextureCore::getProperties */
+		VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc);
+
+		/** @copydoc RenderTexture::getProperties */
 		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
 
 		RenderTextureProperties mProperties;
-		UINT32 mDeviceIdx;
-		VulkanFramebuffer* mFramebuffer;
 	};
 
+	namespace ct
+	{
 	/**
 	 * Vulkan implementation of a render texture.
 	 *
-	 * @note	Sim thread only.
+	 * @note	Core thread only.
 	 */
-	class VulkanRenderTexture : public RenderTexture
+	class VulkanRenderTexture : public RenderTextureCore
 	{
 	public:
-		virtual ~VulkanRenderTexture() { }
+		VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx);
+		virtual ~VulkanRenderTexture();
 
-	protected:
-		friend class VulkanTextureManager;
+		/** @copydoc RenderTextureCore::getCustomAttribute */
+		void getCustomAttribute(const String& name, void* data) const override;
 
-		VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc);
+	protected:
+		/** @copydoc CoreObjectCore::initialize() */
+		void initialize() override;
 
-		/** @copydoc RenderTexture::getProperties */
+		/** @copydoc RenderTextureCore::getProperties */
 		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
 
 		RenderTextureProperties mProperties;
+		UINT32 mDeviceIdx;
+		VulkanFramebuffer* mFramebuffer;
 	};
+		
+	}
 
 	/** @} */
-}}
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderWindowManager.h

@@ -5,7 +5,7 @@
 #include "BsVulkanPrerequisites.h"
 #include "BsRenderWindowManager.h"
 
-namespace bs { namespace ct
+namespace bs
 {
 	/** @addtogroup Vulkan
 	 *  @{
@@ -22,11 +22,13 @@ namespace bs { namespace ct
 		SPtr<RenderWindow> createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const SPtr<RenderWindow>& parentWindow) override;
 	};
 
+	namespace ct
+	{
 	/** @copydoc RenderWindowCoreManager */
-	class VulkanRenderWindowCoreManager : public RenderWindowCoreManager
+	class VulkanRenderWindowManager : public RenderWindowCoreManager
 	{
 	public:
-		VulkanRenderWindowCoreManager(VulkanRenderAPI& renderAPI);
+		VulkanRenderWindowManager(VulkanRenderAPI& renderAPI);
 
 	protected:
 		/** @copydoc RenderWindowCoreManager::createInternal */
@@ -34,6 +36,6 @@ namespace bs { namespace ct
 
 		VulkanRenderAPI& mRenderAPI;
 	};
-
+	}
 	/** @} */
-}}
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanSamplerState.h

@@ -27,10 +27,10 @@ namespace bs { namespace ct
 	};
 
 	/**	Vulkan implementation of a sampler state. Wraps a Vulkan sampler object. */
-	class VulkanSamplerStateCore : public SamplerStateCore
+	class VulkanSamplerState : public SamplerStateCore
 	{
 	public:
-		~VulkanSamplerStateCore();
+		~VulkanSamplerState();
 
 		/** 
 		 * Gets the resource wrapping the sampler object, on the specified device. If sampler state device mask doesn't 
@@ -39,9 +39,9 @@ namespace bs { namespace ct
 		VulkanSampler* getResource(UINT32 deviceIdx) const { return mSamplers[deviceIdx]; }
 
 	protected:
-		friend class VulkanRenderStateCoreManager;
+		friend class VulkanRenderStateManager;
 
-		VulkanSamplerStateCore(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask);
+		VulkanSamplerState(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask);
 
 		/** @copydoc SamplerStateCore::createInternal */
 		void createInternal() override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanTexture.h

@@ -178,10 +178,10 @@ namespace bs { namespace ct
 	};
 
 	/**	Vulkan implementation of a texture. */
-	class VulkanTextureCore : public TextureCore
+	class VulkanTexture : public TextureCore
 	{
 	public:
-		~VulkanTextureCore();
+		~VulkanTexture();
 
 		/** 
 		 * Gets the resource wrapping the Vulkan image object, on the specified device. If texture device mask doesn't 
@@ -190,9 +190,9 @@ namespace bs { namespace ct
 		VulkanImage* getResource(UINT32 deviceIdx) const { return mImages[deviceIdx]; }
 
 	protected:
-		friend class VulkanTextureCoreManager;
+		friend class VulkanTextureManager;
 
-		VulkanTextureCore(const TEXTURE_DESC& desc, const SPtr<PixelData>& initialData, GpuDeviceFlags deviceMask);
+		VulkanTexture(const TEXTURE_DESC& desc, const SPtr<PixelData>& initialData, GpuDeviceFlags deviceMask);
 
 		/** @copydoc CoreObjectCore::initialize() */
 		void initialize() override;

Source/BansheeVulkanRenderAPI/Include/BsVulkanTextureManager.h

@@ -5,7 +5,7 @@
 #include "BsVulkanPrerequisites.h"
 #include "BsTextureManager.h"
 
-namespace bs { namespace ct
+namespace bs
 {
 	/** @addtogroup Vulkan
 	 *  @{
@@ -23,8 +23,10 @@ namespace bs { namespace ct
 		SPtr<RenderTexture> createRenderTextureImpl(const RENDER_TEXTURE_DESC& desc) override;
 	};
 
+	namespace ct
+	{
 	/**	Handles creation of Vulkan textures. */
-	class VulkanTextureCoreManager : public TextureCoreManager
+	class VulkanTextureManager : public TextureCoreManager
 	{
 	public:
 		/** @copydoc TextureCoreManager::onStartUp */
@@ -45,9 +47,9 @@ namespace bs { namespace ct
 		SPtr<RenderTextureCore> createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc, 
 			UINT32 deviceIdx = 0) override;
 
-		SPtr<VulkanTextureCore> mDummyReadTexture;
-		SPtr<VulkanTextureCore> mDummyStorageTexture;
+		SPtr<VulkanTexture> mDummyReadTexture;
+		SPtr<VulkanTexture> mDummyStorageTexture;
 	};
-
+	}
 	/** @} */
-}}
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanVertexBuffer.h

@@ -12,11 +12,11 @@ namespace bs { namespace ct
 	 */
 
 	/**	Vulkan implementation of a vertex buffer. */
-	class VulkanVertexBufferCore : public VertexBufferCore
+	class VulkanVertexBuffer : public VertexBufferCore
 	{
 	public:
-		VulkanVertexBufferCore(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
-		~VulkanVertexBufferCore();
+		VulkanVertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
+		~VulkanVertexBuffer();
 
 		/** @copydoc VertexBufferCore::readData */
 		void readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx = 0, UINT32 queueIdx = 0) override;

Source/BansheeVulkanRenderAPI/Include/Win32/BsWin32RenderWindow.h

@@ -5,14 +5,12 @@
 #include "BsVulkanPrerequisites.h"
 #include "BsRenderWindow.h"
 
-namespace bs { namespace ct
+namespace bs
 {
 	/** @addtogroup Vulkan
 	 *  @{
 	 */
 
-	class Win32RenderWindow;
-
 	/**	Contains various properties that describe a render window. */
 	class Win32RenderWindowProperties : public RenderWindowProperties
 	{
@@ -21,20 +19,63 @@ namespace bs { namespace ct
 		virtual ~Win32RenderWindowProperties() { }
 
 	private:
-		friend class Win32RenderWindowCore;
+		friend class ct::Win32RenderWindow;
 		friend class Win32RenderWindow;
 	};
 
+	/**
+	 * Render window implementation for Windows and Vulkan.
+	 *
+	 * @note	Sim thread only.
+	 */
+	class Win32RenderWindow : public RenderWindow
+	{
+	public:
+		~Win32RenderWindow() { }
+
+		/** @copydoc RenderWindow::screenToWindowPos */
+		void getCustomAttribute(const String& name, void* pData) const override;
+
+		/** @copydoc RenderWindow::screenToWindowPos */
+		Vector2I screenToWindowPos(const Vector2I& screenPos) const override;
+
+		/** @copydoc RenderWindow::windowToScreenPos */
+		Vector2I windowToScreenPos(const Vector2I& windowPos) const override;
+
+		/** @copydoc RenderWindow::getCore */
+		SPtr<ct::Win32RenderWindow> getCore() const;
+
+		/**	Retrieves internal window handle. */
+		HWND getHWnd() const;
+
+	protected:
+		friend class VulkanRenderWindowManager;
+		friend class Win32RenderWindowCore;
+
+		Win32RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
+
+		/** @copydoc RenderWindowCore::getProperties */
+		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
+
+		/** @copydoc RenderWindow::syncProperties */
+		void syncProperties() override;
+
+	private:
+		Win32RenderWindowProperties mProperties;
+	};
+
+	namespace ct
+	{
 	/**
 	 * Render window implementation for Windows and Vulkan.
 	 *
 	 * @note	Core thread only.
 	 */
-	class Win32RenderWindowCore : public RenderWindowCore
+	class Win32RenderWindow : public RenderWindowCore
 	{
 	public:
-		Win32RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, VulkanRenderAPI& renderAPI);
-		~Win32RenderWindowCore();
+		Win32RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, VulkanRenderAPI& renderAPI);
+		~Win32RenderWindow();
 
 		/** @copydoc RenderWindowCore::move */
 		void move(INT32 left, INT32 top) override;
@@ -89,7 +130,7 @@ namespace bs { namespace ct
 		/**	Returns internal window handle. */
 		HWND _getWindowHandle() const;
 	protected:
-		friend class Win32RenderWindow;
+		friend class bs::Win32RenderWindow;
 
 		/** @copydoc CoreObjectCore::initialize */
 		void initialize() override;
@@ -121,48 +162,8 @@ namespace bs { namespace ct
 
 		Win32RenderWindowProperties mProperties;
 		Win32RenderWindowProperties mSyncedProperties;
-	};
-
-	/**
-	 * Render window implementation for Windows and Vulkan.
-	 *
-	 * @note	Sim thread only.
-	 */
-	class Win32RenderWindow : public RenderWindow
-	{
-	public:
-		~Win32RenderWindow() { }
-
-		/** @copydoc RenderWindow::screenToWindowPos */
-		void getCustomAttribute(const String& name, void* pData) const override;
-
-		/** @copydoc RenderWindow::screenToWindowPos */
-		Vector2I screenToWindowPos(const Vector2I& screenPos) const override;
-
-		/** @copydoc RenderWindow::windowToScreenPos */
-		Vector2I windowToScreenPos(const Vector2I& windowPos) const override;
-
-		/** @copydoc RenderWindow::getCore */
-		SPtr<Win32RenderWindowCore> getCore() const;
-
-		/**	Retrieves internal window handle. */
-		HWND getHWnd() const;
-
-	protected:
-		friend class VulkanRenderWindowManager;
-		friend class Win32RenderWindowCore;
-
-		Win32RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
-
-		/** @copydoc RenderWindowCore::getProperties */
-		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
-
-		/** @copydoc RenderWindow::syncProperties */
-		void syncProperties() override;
-
-	private:
-		Win32RenderWindowProperties mProperties;
-	};
+	};	
+	}
 	
 	/** @} */
-}}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanCommandBuffer.cpp

@@ -706,7 +706,7 @@ namespace bs { namespace ct
 		{
 			if (rt->getProperties().isWindow())
 			{
-				Win32RenderWindowCore* window = static_cast<Win32RenderWindowCore*>(rt.get());
+				Win32RenderWindow* window = static_cast<Win32RenderWindow*>(rt.get());
 				window->acquireBackBuffer();
 			}
 
@@ -946,7 +946,7 @@ namespace bs { namespace ct
 		if (mGraphicsPipeline == state)
 			return;
 
-		mGraphicsPipeline = std::static_pointer_cast<VulkanGraphicsPipelineStateCore>(state);
+		mGraphicsPipeline = std::static_pointer_cast<VulkanGraphicsPipelineState>(state);
 		mGfxPipelineRequiresBind = true; 
 	}
 
@@ -955,7 +955,7 @@ namespace bs { namespace ct
 		if (mComputePipeline == state)
 			return;
 
-		mComputePipeline = std::static_pointer_cast<VulkanComputePipelineStateCore>(state);
+		mComputePipeline = std::static_pointer_cast<VulkanComputePipelineState>(state);
 		mCmpPipelineRequiresBind = true;
 	}
 
@@ -1021,7 +1021,7 @@ namespace bs { namespace ct
 
 		for(UINT32 i = 0; i < numBuffers; i++)
 		{
-			VulkanVertexBufferCore* vertexBuffer = static_cast<VulkanVertexBufferCore*>(buffers[i].get());
+			VulkanVertexBuffer* vertexBuffer = static_cast<VulkanVertexBuffer*>(buffers[i].get());
 
 			if (vertexBuffer != nullptr)
 			{
@@ -1044,7 +1044,7 @@ namespace bs { namespace ct
 
 	void VulkanCmdBuffer::setIndexBuffer(const SPtr<IndexBufferCore>& buffer)
 	{
-		VulkanIndexBufferCore* indexBuffer = static_cast<VulkanIndexBufferCore*>(buffer.get());
+		VulkanIndexBuffer* indexBuffer = static_cast<VulkanIndexBuffer*>(buffer.get());
 
 		VkBuffer vkBuffer = VK_NULL_HANDLE;
 		VkIndexType indexType = VK_INDEX_TYPE_UINT32;

Source/BansheeVulkanRenderAPI/Source/BsVulkanGLSLProgramFactory.cpp

@@ -27,8 +27,8 @@ namespace bs { namespace ct
 
 	SPtr<GpuProgramCore> VulkanGLSLProgramFactory::create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
     {
-		SPtr<GpuProgramCore> gpuProg = bs_shared_ptr<VulkanGpuProgramCore>(new (bs_alloc<VulkanGpuProgramCore>())
-			VulkanGpuProgramCore(desc, deviceMask));
+		SPtr<GpuProgramCore> gpuProg = bs_shared_ptr<VulkanGpuProgram>(new (bs_alloc<VulkanGpuProgram>())
+			VulkanGpuProgram(desc, deviceMask));
 		gpuProg->_setThisPtr(gpuProg);
 
 		return gpuProg;
@@ -39,8 +39,8 @@ namespace bs { namespace ct
 		GPU_PROGRAM_DESC desc;
 		desc.type = type;
 
-		SPtr<GpuProgramCore> gpuProg = bs_shared_ptr<VulkanGpuProgramCore>(new (bs_alloc<VulkanGpuProgramCore>())
-			VulkanGpuProgramCore(desc, deviceMask));
+		SPtr<GpuProgramCore> gpuProg = bs_shared_ptr<VulkanGpuProgram>(new (bs_alloc<VulkanGpuProgram>())
+			VulkanGpuProgram(desc, deviceMask));
 		gpuProg->_setThisPtr(gpuProg);
 
 		return gpuProg;

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuBuffer.cpp

@@ -7,7 +7,7 @@
 
 namespace bs { namespace ct
 {
-	VulkanGpuBufferCore::VulkanGpuBufferCore(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	VulkanGpuBuffer::VulkanGpuBuffer(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 		: GpuBufferCore(desc, deviceMask), mBuffer(nullptr), mDeviceMask(deviceMask)
 	{
 		if (desc.type != GBT_STANDARD)
@@ -16,7 +16,7 @@ namespace bs { namespace ct
 			assert(desc.elementSize == 0 && "No element size can be provided for standard buffer. Size is determined from format.");
 	}
 
-	VulkanGpuBufferCore::~VulkanGpuBufferCore()
+	VulkanGpuBuffer::~VulkanGpuBuffer()
 	{ 
 		if (mBuffer != nullptr)
 			bs_delete(mBuffer);
@@ -24,7 +24,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuBuffer);
 	}
 
-	void VulkanGpuBufferCore::initialize()
+	void VulkanGpuBuffer::initialize()
 	{
 		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuBuffer);
 
@@ -42,7 +42,7 @@ namespace bs { namespace ct
 		GpuBufferCore::initialize();
 	}
 
-	void* VulkanGpuBufferCore::lock(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
+	void* VulkanGpuBuffer::lock(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 #if BS_PROFILING_ENABLED
 		if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
@@ -59,19 +59,19 @@ namespace bs { namespace ct
 		return mBuffer->lock(offset, length, options, deviceIdx, queueIdx);
 	}
 
-	void VulkanGpuBufferCore::unlock()
+	void VulkanGpuBuffer::unlock()
 	{
 		mBuffer->unlock();
 	}
 
-	void VulkanGpuBufferCore::readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx, UINT32 queueIdx)
+	void VulkanGpuBuffer::readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		mBuffer->readData(offset, length, dest, deviceIdx, queueIdx);
 
 		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_GpuBuffer);
 	}
 
-	void VulkanGpuBufferCore::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags,
+	void VulkanGpuBuffer::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags,
 										UINT32 queueIdx)
 	{
 		mBuffer->writeData(offset, length, source, writeFlags, queueIdx);
@@ -79,13 +79,13 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_GpuBuffer);
 	}
 
-	void VulkanGpuBufferCore::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
+	void VulkanGpuBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
 		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer, UINT32 queueIdx)
 	{
 		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer, queueIdx);
 	}
 
-	VulkanBuffer* VulkanGpuBufferCore::getResource(UINT32 deviceIdx) const
+	VulkanBuffer* VulkanGpuBuffer::getResource(UINT32 deviceIdx) const
 	{
 		return mBuffer->getResource(deviceIdx);
 	}

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuParamBlockBuffer.cpp

@@ -6,12 +6,12 @@
 
 namespace bs { namespace ct
 {
-	VulkanGpuParamBlockBufferCore::VulkanGpuParamBlockBufferCore(UINT32 size, GpuParamBlockUsage usage,
+	VulkanGpuParamBlockBuffer::VulkanGpuParamBlockBuffer(UINT32 size, GpuParamBlockUsage usage,
 		GpuDeviceFlags deviceMask)
 		:GpuParamBlockBufferCore(size, usage, deviceMask), mBuffer(nullptr), mDeviceMask(deviceMask)
 	{ }
 
-	VulkanGpuParamBlockBufferCore::~VulkanGpuParamBlockBufferCore()
+	VulkanGpuParamBlockBuffer::~VulkanGpuParamBlockBuffer()
 	{
 		if(mBuffer != nullptr)
 			bs_delete(mBuffer);
@@ -19,7 +19,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuParamBuffer);
 	}
 
-	void VulkanGpuParamBlockBufferCore::initialize()
+	void VulkanGpuParamBlockBuffer::initialize()
 	{
 		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuParamBuffer);
 
@@ -30,14 +30,14 @@ namespace bs { namespace ct
 		GpuParamBlockBufferCore::initialize();
 	}
 
-	void VulkanGpuParamBlockBufferCore::writeToGPU(const UINT8* data, UINT32 queueIdx)
+	void VulkanGpuParamBlockBuffer::writeToGPU(const UINT8* data, UINT32 queueIdx)
 	{
 		mBuffer->writeData(0, mSize, data, BWT_DISCARD, queueIdx);
 
 		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_GpuParamBuffer);
 	}
 
-	VulkanBuffer* VulkanGpuParamBlockBufferCore::getResource(UINT32 deviceIdx) const
+	VulkanBuffer* VulkanGpuParamBlockBuffer::getResource(UINT32 deviceIdx) const
 	{
 		return mBuffer->getResource(deviceIdx);
 	}

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuParams.cpp

@@ -87,9 +87,9 @@ namespace bs { namespace ct
 		mSetsDirty = mAlloc.alloc<bool>(numSets);
 		bs_zero_out(mSetsDirty, numSets);
 
-		VulkanSamplerStateCore* defaultSampler = static_cast<VulkanSamplerStateCore*>(SamplerStateCore::getDefault().get());
-		VulkanTextureCoreManager& vkTexManager = static_cast<VulkanTextureCoreManager&>(TextureCoreManager::instance());
-		VulkanHardwareBufferCoreManager& vkBufManager = static_cast<VulkanHardwareBufferCoreManager&>(
+		VulkanSamplerState* defaultSampler = static_cast<VulkanSamplerState*>(SamplerStateCore::getDefault().get());
+		VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(TextureCoreManager::instance());
+		VulkanHardwareBufferManager& vkBufManager = static_cast<VulkanHardwareBufferManager&>(
 			HardwareBufferCoreManager::instance());
 
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
@@ -226,8 +226,8 @@ namespace bs { namespace ct
 
 		Lock(mMutex);
 
-		VulkanGpuParamBlockBufferCore* vulkanParamBlockBuffer =
-			static_cast<VulkanGpuParamBlockBufferCore*>(paramBlockBuffer.get());
+		VulkanGpuParamBlockBuffer* vulkanParamBlockBuffer =
+			static_cast<VulkanGpuParamBlockBuffer*>(paramBlockBuffer.get());
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			if (mPerDeviceData[i].perSetData == nullptr)
@@ -249,7 +249,7 @@ namespace bs { namespace ct
 			}
 			else
 			{
-				VulkanHardwareBufferCoreManager& vkBufManager = static_cast<VulkanHardwareBufferCoreManager&>(
+				VulkanHardwareBufferManager& vkBufManager = static_cast<VulkanHardwareBufferManager&>(
 					HardwareBufferCoreManager::instance());
 
 				perSetData.writeInfos[bindingIdx].buffer.buffer = vkBufManager.getDummyUniformBuffer(i);
@@ -277,7 +277,7 @@ namespace bs { namespace ct
 
 		Lock(mMutex);
 
-		VulkanTextureCore* vulkanTexture = static_cast<VulkanTextureCore*>(texture.get());
+		VulkanTexture* vulkanTexture = static_cast<VulkanTexture*>(texture.get());
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			if (mPerDeviceData[i].perSetData == nullptr)
@@ -297,7 +297,7 @@ namespace bs { namespace ct
 			}
 			else
 			{
-				VulkanTextureCoreManager& vkTexManager = static_cast<VulkanTextureCoreManager&>(
+				VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(
 					TextureCoreManager::instance());
 
 				perSetData.writeInfos[bindingIdx].image.imageView = vkTexManager.getDummyReadImageView(i);
@@ -326,7 +326,7 @@ namespace bs { namespace ct
 
 		Lock(mMutex);
 
-		VulkanTextureCore* vulkanTexture = static_cast<VulkanTextureCore*>(texture.get());
+		VulkanTexture* vulkanTexture = static_cast<VulkanTexture*>(texture.get());
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			if (mPerDeviceData[i].perSetData == nullptr)
@@ -346,7 +346,7 @@ namespace bs { namespace ct
 			}
 			else
 			{
-				VulkanTextureCoreManager& vkTexManager = static_cast<VulkanTextureCoreManager&>(
+				VulkanTextureManager& vkTexManager = static_cast<VulkanTextureManager&>(
 					TextureCoreManager::instance());
 
 				perSetData.writeInfos[bindingIdx].image.imageView = vkTexManager.getDummyStorageImageView(i);
@@ -374,7 +374,7 @@ namespace bs { namespace ct
 
 		Lock(mMutex);
 
-		VulkanGpuBufferCore* vulkanBuffer = static_cast<VulkanGpuBufferCore*>(buffer.get());
+		VulkanGpuBuffer* vulkanBuffer = static_cast<VulkanGpuBuffer*>(buffer.get());
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			if (mPerDeviceData[i].perSetData == nullptr)
@@ -398,7 +398,7 @@ namespace bs { namespace ct
 			}
 			else
 			{
-				VulkanHardwareBufferCoreManager& vkBufManager = static_cast<VulkanHardwareBufferCoreManager&>(
+				VulkanHardwareBufferManager& vkBufManager = static_cast<VulkanHardwareBufferManager&>(
 					HardwareBufferCoreManager::instance());
 
 				bool isLoadStore = writeSetInfo.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
@@ -433,7 +433,7 @@ namespace bs { namespace ct
 
 		Lock(mMutex);
 
-		VulkanSamplerStateCore* vulkanSampler = static_cast<VulkanSamplerStateCore*>(sampler.get());
+		VulkanSamplerState* vulkanSampler = static_cast<VulkanSamplerState*>(sampler.get());
 		for(UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			if (mPerDeviceData[i].perSetData == nullptr)
@@ -456,8 +456,8 @@ namespace bs { namespace ct
 			}
 			else
 			{
-				VulkanSamplerStateCore* defaultSampler = 
-					static_cast<VulkanSamplerStateCore*>(SamplerStateCore::getDefault().get());
+				VulkanSamplerState* defaultSampler = 
+					static_cast<VulkanSamplerState*>(SamplerStateCore::getDefault().get());
 
 				VkSampler vkSampler = defaultSampler->getResource(i)->getHandle();;
 				perSetData.writeInfos[bindingIdx].image.sampler = vkSampler;
@@ -488,7 +488,7 @@ namespace bs { namespace ct
 
 		Lock(mMutex);
 
-		VulkanTextureCore* vulkanTexture = static_cast<VulkanTextureCore*>(texture.get());
+		VulkanTexture* vulkanTexture = static_cast<VulkanTexture*>(texture.get());
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
 			if (mPerDeviceData[i].perSetData == nullptr)
@@ -538,7 +538,7 @@ namespace bs { namespace ct
 			if (mParamBlockBuffers[i] == nullptr)
 				continue;
 
-			VulkanGpuParamBlockBufferCore* element = static_cast<VulkanGpuParamBlockBufferCore*>(mParamBlockBuffers[i].get());
+			VulkanGpuParamBlockBuffer* element = static_cast<VulkanGpuParamBlockBuffer*>(mParamBlockBuffers[i].get());
 			VulkanBuffer* resource = element->getResource(deviceIdx);
 			if (resource == nullptr)
 				continue;
@@ -569,7 +569,7 @@ namespace bs { namespace ct
 			if (mBuffers[i] == nullptr)
 				continue;
 
-			VulkanGpuBufferCore* element = static_cast<VulkanGpuBufferCore*>(mBuffers[i].get());
+			VulkanGpuBuffer* element = static_cast<VulkanGpuBuffer*>(mBuffers[i].get());
 			VulkanBuffer* resource = element->getResource(deviceIdx);
 			if (resource == nullptr)
 				continue;
@@ -611,7 +611,7 @@ namespace bs { namespace ct
 			if (mSamplerStates[i] == nullptr)
 				continue;
 
-			VulkanSamplerStateCore* element = static_cast<VulkanSamplerStateCore*>(mSamplerStates[i].get());
+			VulkanSamplerState* element = static_cast<VulkanSamplerState*>(mSamplerStates[i].get());
 			VulkanSampler* resource = element->getResource(deviceIdx);
 			if (resource == nullptr)
 				continue;
@@ -642,7 +642,7 @@ namespace bs { namespace ct
 			if (mLoadStoreTextures[i] == nullptr)
 				continue;
 
-			VulkanTextureCore* element = static_cast<VulkanTextureCore*>(mLoadStoreTextures[i].get());
+			VulkanTexture* element = static_cast<VulkanTexture*>(mLoadStoreTextures[i].get());
 			VulkanImage* resource = element->getResource(deviceIdx);
 			if (resource == nullptr)
 				continue;
@@ -676,7 +676,7 @@ namespace bs { namespace ct
 			if (mTextures[i] == nullptr)
 				continue;
 
-			VulkanTextureCore* element = static_cast<VulkanTextureCore*>(mTextures[i].get());
+			VulkanTexture* element = static_cast<VulkanTexture*>(mTextures[i].get());
 			VulkanImage* resource = element->getResource(deviceIdx);
 			if (resource == nullptr)
 				continue;

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuPipelineState.cpp

@@ -31,7 +31,7 @@ namespace bs { namespace ct
 		vkDestroyPipeline(mOwner->getDevice().getLogical(), mPipeline, gVulkanAllocator);
 	}
 
-	VulkanGraphicsPipelineStateCore::GpuPipelineKey::GpuPipelineKey(
+	VulkanGraphicsPipelineState::GpuPipelineKey::GpuPipelineKey(
 		UINT32 framebufferId, UINT32 vertexInputId, bool readOnlyDepth, DrawOperationType drawOp)
 		: framebufferId(framebufferId), vertexInputId(vertexInputId), readOnlyDepth(readOnlyDepth)
 		, drawOp(drawOp)
@@ -39,7 +39,7 @@ namespace bs { namespace ct
 		
 	}
 
-	size_t VulkanGraphicsPipelineStateCore::HashFunc::operator()(const GpuPipelineKey& key) const
+	size_t VulkanGraphicsPipelineState::HashFunc::operator()(const GpuPipelineKey& key) const
 	{
 		size_t hash = 0;
 		hash_combine(hash, key.framebufferId);
@@ -50,7 +50,7 @@ namespace bs { namespace ct
 		return hash;
 	}
 
-	bool VulkanGraphicsPipelineStateCore::EqualFunc::operator()(const GpuPipelineKey& a, const GpuPipelineKey& b) const
+	bool VulkanGraphicsPipelineState::EqualFunc::operator()(const GpuPipelineKey& a, const GpuPipelineKey& b) const
 	{
 		if (a.framebufferId != b.framebufferId)
 			return false;
@@ -67,7 +67,7 @@ namespace bs { namespace ct
 		return true;
 	}
 
-	VulkanGraphicsPipelineStateCore::VulkanGraphicsPipelineStateCore(const PIPELINE_STATE_DESC& desc,
+	VulkanGraphicsPipelineState::VulkanGraphicsPipelineState(const PIPELINE_STATE_DESC& desc,
 																	 GpuDeviceFlags deviceMask)
 		:GraphicsPipelineStateCore(desc, deviceMask), mScissorEnabled(false), mDeviceMask(deviceMask)
 	{
@@ -78,7 +78,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	VulkanGraphicsPipelineStateCore::~VulkanGraphicsPipelineStateCore()
+	VulkanGraphicsPipelineState::~VulkanGraphicsPipelineState()
 	{
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
@@ -92,7 +92,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_PipelineState);
 	}
 
-	void VulkanGraphicsPipelineStateCore::initialize()
+	void VulkanGraphicsPipelineState::initialize()
 	{
 		Lock(mMutex);
 
@@ -111,7 +111,7 @@ namespace bs { namespace ct
 		UINT32 numStages = sizeof(stages) / sizeof(stages[0]);
 		for(UINT32 i = 0; i < numStages; i++)
 		{
-			VulkanGpuProgramCore* program = static_cast<VulkanGpuProgramCore*>(stages[i].second);
+			VulkanGpuProgram* program = static_cast<VulkanGpuProgram*>(stages[i].second);
 			if (program == nullptr)
 				continue;
 
@@ -317,7 +317,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_PipelineState);
 	}
 
-	VulkanPipeline* VulkanGraphicsPipelineStateCore::getPipeline(
+	VulkanPipeline* VulkanGraphicsPipelineState::getPipeline(
 		UINT32 deviceIdx, VulkanFramebuffer* framebuffer, bool readOnlyDepth, DrawOperationType drawOp, 
 			const SPtr<VulkanVertexInput>& vertexInput)
 	{
@@ -339,21 +339,21 @@ namespace bs { namespace ct
 		return newPipeline;
 	}
 
-	VkPipelineLayout VulkanGraphicsPipelineStateCore::getPipelineLayout(UINT32 deviceIdx) const
+	VkPipelineLayout VulkanGraphicsPipelineState::getPipelineLayout(UINT32 deviceIdx) const
 	{
 		return mPerDeviceData[deviceIdx].pipelineLayout;
 	}
 
-	void VulkanGraphicsPipelineStateCore::registerPipelineResources(VulkanCmdBuffer* cmdBuffer)
+	void VulkanGraphicsPipelineState::registerPipelineResources(VulkanCmdBuffer* cmdBuffer)
 	{
 		UINT32 deviceIdx = cmdBuffer->getDeviceIdx();
 
-		std::array<VulkanGpuProgramCore*, 5> programs = {
-			static_cast<VulkanGpuProgramCore*>(mData.vertexProgram.get()),
-			static_cast<VulkanGpuProgramCore*>(mData.hullProgram.get()),
-			static_cast<VulkanGpuProgramCore*>(mData.domainProgram.get()),
-			static_cast<VulkanGpuProgramCore*>(mData.geometryProgram.get()),
-			static_cast<VulkanGpuProgramCore*>(mData.fragmentProgram.get()),
+		std::array<VulkanGpuProgram*, 5> programs = {
+			static_cast<VulkanGpuProgram*>(mData.vertexProgram.get()),
+			static_cast<VulkanGpuProgram*>(mData.hullProgram.get()),
+			static_cast<VulkanGpuProgram*>(mData.domainProgram.get()),
+			static_cast<VulkanGpuProgram*>(mData.geometryProgram.get()),
+			static_cast<VulkanGpuProgram*>(mData.fragmentProgram.get()),
 		};
 
 		for(auto& entry : programs)
@@ -368,7 +368,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	VulkanPipeline* VulkanGraphicsPipelineStateCore::createPipeline(UINT32 deviceIdx, VulkanFramebuffer* framebuffer,
+	VulkanPipeline* VulkanGraphicsPipelineState::createPipeline(UINT32 deviceIdx, VulkanFramebuffer* framebuffer,
 		bool readOnlyDepth, DrawOperationType drawOp, const SPtr<VulkanVertexInput>& vertexInput)
 	{
 		mInputAssemblyInfo.topology = VulkanUtility::getDrawOp(drawOp);
@@ -460,7 +460,7 @@ namespace bs { namespace ct
 		UINT32 numStages = sizeof(stages) / sizeof(stages[0]);
 		for (UINT32 i = 0; i < numStages; i++)
 		{
-			VulkanGpuProgramCore* program = static_cast<VulkanGpuProgramCore*>(stages[i].second);
+			VulkanGpuProgram* program = static_cast<VulkanGpuProgram*>(stages[i].second);
 			if (program == nullptr)
 				continue;
 
@@ -495,14 +495,14 @@ namespace bs { namespace ct
 		return device->getResourceManager().create<VulkanPipeline>(pipeline, colorReadOnly, depthStencilReadOnly);
 	}
 
-	VulkanComputePipelineStateCore::VulkanComputePipelineStateCore(const SPtr<GpuProgramCore>& program, 
+	VulkanComputePipelineState::VulkanComputePipelineState(const SPtr<GpuProgramCore>& program, 
 		GpuDeviceFlags deviceMask)
 		:ComputePipelineStateCore(program, deviceMask), mDeviceMask(deviceMask)
 	{
 		bs_zero_out(mPerDeviceData);
 	}
 
-	VulkanComputePipelineStateCore::~VulkanComputePipelineStateCore()
+	VulkanComputePipelineState::~VulkanComputePipelineState()
 	{
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
@@ -513,7 +513,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	void VulkanComputePipelineStateCore::initialize()
+	void VulkanComputePipelineState::initialize()
 	{
 		ComputePipelineStateCore::initialize();
 
@@ -522,7 +522,7 @@ namespace bs { namespace ct
 		if (!mProgram->isCompiled())
 			return;
 
-		VulkanGpuProgramCore* vkProgram = static_cast<VulkanGpuProgramCore*>(mProgram.get());
+		VulkanGpuProgram* vkProgram = static_cast<VulkanGpuProgram*>(mProgram.get());
 
 		VkPipelineShaderStageCreateInfo stageCI;
 		stageCI.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
@@ -586,21 +586,21 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_PipelineState);
 	}
 
-	VulkanPipeline* VulkanComputePipelineStateCore::getPipeline(UINT32 deviceIdx) const
+	VulkanPipeline* VulkanComputePipelineState::getPipeline(UINT32 deviceIdx) const
 	{
 		return mPerDeviceData[deviceIdx].pipeline;
 	}
 
-	VkPipelineLayout VulkanComputePipelineStateCore::getPipelineLayout(UINT32 deviceIdx) const
+	VkPipelineLayout VulkanComputePipelineState::getPipelineLayout(UINT32 deviceIdx) const
 	{
 		return mPerDeviceData[deviceIdx].pipelineLayout;
 	}
 
-	void VulkanComputePipelineStateCore::registerPipelineResources(VulkanCmdBuffer* cmdBuffer)
+	void VulkanComputePipelineState::registerPipelineResources(VulkanCmdBuffer* cmdBuffer)
 	{
 		UINT32 deviceIdx = cmdBuffer->getDeviceIdx();
 
-		VulkanGpuProgramCore* program = static_cast<VulkanGpuProgramCore*>(mProgram.get());
+		VulkanGpuProgram* program = static_cast<VulkanGpuProgram*>(mProgram.get());
 		if(program != nullptr)
 		{
 			VulkanShaderModule* module = program->getShaderModule(deviceIdx);

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuProgram.cpp

@@ -524,13 +524,13 @@ namespace bs { namespace ct
 		vkDestroyShaderModule(mOwner->getDevice().getLogical(), mModule, gVulkanAllocator);
 	}
 
-	VulkanGpuProgramCore::VulkanGpuProgramCore(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+	VulkanGpuProgram::VulkanGpuProgram(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
 		: GpuProgramCore(desc, deviceMask), mDeviceMask(deviceMask), mModules()
 	{
 
 	}
 
-	VulkanGpuProgramCore::~VulkanGpuProgramCore()
+	VulkanGpuProgram::~VulkanGpuProgram()
 	{
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
@@ -541,7 +541,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuProgram);
 	}
 
-	void VulkanGpuProgramCore::initialize()
+	void VulkanGpuProgram::initialize()
 	{
 		if (!isSupported())
 		{

Source/BansheeVulkanRenderAPI/Source/BsVulkanHardwareBufferManager.cpp

@@ -11,7 +11,7 @@
 
 namespace bs { namespace ct
 {
-	VulkanHardwareBufferCoreManager::VulkanHardwareBufferCoreManager()
+	VulkanHardwareBufferManager::VulkanHardwareBufferManager()
 	{
 		// Note: When multi-GPU is properly tested, make sure to create these textures on all GPUs
 		mDummyReadBuffer = bs_new<VulkanHardwareBuffer>(
@@ -24,70 +24,70 @@ namespace bs { namespace ct
 			VulkanHardwareBuffer::BT_UNIFORM, BF_UNKNOWN, GBU_STATIC, 16, GDF_DEFAULT);
 	}
 
-	VulkanHardwareBufferCoreManager::~VulkanHardwareBufferCoreManager()
+	VulkanHardwareBufferManager::~VulkanHardwareBufferManager()
 	{
 		bs_delete(mDummyReadBuffer);
 		bs_delete(mDummyStorageBuffer);
 		bs_delete(mDummyUniformBuffer);
 	}
 
-	VkBufferView VulkanHardwareBufferCoreManager::getDummyReadBufferView(UINT32 deviceIdx) const
+	VkBufferView VulkanHardwareBufferManager::getDummyReadBufferView(UINT32 deviceIdx) const
 	{
 		return mDummyReadBuffer->getResource(deviceIdx)->getView();
 	}
 
-	VkBufferView VulkanHardwareBufferCoreManager::getDummyStorageBufferView(UINT32 deviceIdx) const
+	VkBufferView VulkanHardwareBufferManager::getDummyStorageBufferView(UINT32 deviceIdx) const
 	{
 		return mDummyStorageBuffer->getResource(deviceIdx)->getView();
 	}
 
-	VkBuffer VulkanHardwareBufferCoreManager::getDummyUniformBuffer(UINT32 deviceIdx) const
+	VkBuffer VulkanHardwareBufferManager::getDummyUniformBuffer(UINT32 deviceIdx) const
 	{
 		return mDummyUniformBuffer->getResource(deviceIdx)->getHandle();
 	}
 
-	SPtr<VertexBufferCore> VulkanHardwareBufferCoreManager::createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc,
+	SPtr<VertexBufferCore> VulkanHardwareBufferManager::createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc,
 		GpuDeviceFlags deviceMask)
 	{
-		SPtr<VulkanVertexBufferCore> ret = bs_shared_ptr_new<VulkanVertexBufferCore>(desc, deviceMask);
+		SPtr<VulkanVertexBuffer> ret = bs_shared_ptr_new<VulkanVertexBuffer>(desc, deviceMask);
 		ret->_setThisPtr(ret);
 
 		return ret;
 	}
 
-	SPtr<IndexBufferCore> VulkanHardwareBufferCoreManager::createIndexBufferInternal(const INDEX_BUFFER_DESC& desc,
+	SPtr<IndexBufferCore> VulkanHardwareBufferManager::createIndexBufferInternal(const INDEX_BUFFER_DESC& desc,
 		GpuDeviceFlags deviceMask)
 	{
-		SPtr<VulkanIndexBufferCore> ret = bs_shared_ptr_new<VulkanIndexBufferCore>( desc, deviceMask);
+		SPtr<VulkanIndexBuffer> ret = bs_shared_ptr_new<VulkanIndexBuffer>( desc, deviceMask);
 		ret->_setThisPtr(ret);
 
 		return ret;
 	}
 
-	SPtr<GpuParamBlockBufferCore> VulkanHardwareBufferCoreManager::createGpuParamBlockBufferInternal(UINT32 size,
+	SPtr<GpuParamBlockBufferCore> VulkanHardwareBufferManager::createGpuParamBlockBufferInternal(UINT32 size,
 		GpuParamBlockUsage usage, GpuDeviceFlags deviceMask)
 	{
-		VulkanGpuParamBlockBufferCore* paramBlockBuffer =
-			new (bs_alloc<VulkanGpuParamBlockBufferCore>()) VulkanGpuParamBlockBufferCore(size, usage, deviceMask);
+		VulkanGpuParamBlockBuffer* paramBlockBuffer =
+			new (bs_alloc<VulkanGpuParamBlockBuffer>()) VulkanGpuParamBlockBuffer(size, usage, deviceMask);
 
-		SPtr<GpuParamBlockBufferCore> paramBlockBufferPtr = bs_shared_ptr<VulkanGpuParamBlockBufferCore>(paramBlockBuffer);
+		SPtr<GpuParamBlockBufferCore> paramBlockBufferPtr = bs_shared_ptr<VulkanGpuParamBlockBuffer>(paramBlockBuffer);
 		paramBlockBufferPtr->_setThisPtr(paramBlockBufferPtr);
 
 		return paramBlockBufferPtr;
 	}
 
-	SPtr<GpuBufferCore> VulkanHardwareBufferCoreManager::createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
+	SPtr<GpuBufferCore> VulkanHardwareBufferManager::createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
 		GpuDeviceFlags deviceMask)
 	{
-		VulkanGpuBufferCore* buffer = new (bs_alloc<VulkanGpuBufferCore>()) VulkanGpuBufferCore(desc, deviceMask);
+		VulkanGpuBuffer* buffer = new (bs_alloc<VulkanGpuBuffer>()) VulkanGpuBuffer(desc, deviceMask);
 
-		SPtr<VulkanGpuBufferCore> bufferPtr = bs_shared_ptr<VulkanGpuBufferCore>(buffer);
+		SPtr<VulkanGpuBuffer> bufferPtr = bs_shared_ptr<VulkanGpuBuffer>(buffer);
 		bufferPtr->_setThisPtr(bufferPtr);
 
 		return bufferPtr;
 	}
 
-	SPtr<GpuParamsCore> VulkanHardwareBufferCoreManager::createGpuParamsInternal(
+	SPtr<GpuParamsCore> VulkanHardwareBufferManager::createGpuParamsInternal(
 		const SPtr<GpuPipelineParamInfoCore>& paramInfo, GpuDeviceFlags deviceMask)
 	{
 		VulkanGpuParams* params = new (bs_alloc<VulkanGpuParams>()) VulkanGpuParams(paramInfo, deviceMask);

Source/BansheeVulkanRenderAPI/Source/BsVulkanIndexBuffer.cpp

@@ -6,11 +6,11 @@
 
 namespace bs { namespace ct
 {
-	VulkanIndexBufferCore::VulkanIndexBufferCore(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	VulkanIndexBuffer::VulkanIndexBuffer(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 		:IndexBufferCore(desc, deviceMask), mBuffer(nullptr),  mUsage(desc.usage), mDeviceMask(deviceMask)
 	{ }
 
-	VulkanIndexBufferCore::~VulkanIndexBufferCore()
+	VulkanIndexBuffer::~VulkanIndexBuffer()
 	{
 		if (mBuffer != nullptr)
 			bs_delete(mBuffer);
@@ -18,7 +18,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_IndexBuffer);
 	}
 
-	void VulkanIndexBufferCore::initialize()
+	void VulkanIndexBuffer::initialize()
 	{
 		mBuffer = bs_new<VulkanHardwareBuffer>(VulkanHardwareBuffer::BT_INDEX, BF_UNKNOWN, mUsage, mSize, mDeviceMask);
 
@@ -26,7 +26,7 @@ namespace bs { namespace ct
 		IndexBufferCore::initialize();
 	}
 
-	void* VulkanIndexBufferCore::map(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
+	void* VulkanIndexBuffer::map(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 #if BS_PROFILING_ENABLED
 		if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
@@ -43,32 +43,32 @@ namespace bs { namespace ct
 		return mBuffer->lock(offset, length, options, deviceIdx, queueIdx);
 	}
 
-	void VulkanIndexBufferCore::unmap()
+	void VulkanIndexBuffer::unmap()
 	{
 		mBuffer->unlock();
 	}
 
-	void VulkanIndexBufferCore::readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx, UINT32 queueIdx)
+	void VulkanIndexBuffer::readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		mBuffer->readData(offset, length, dest, deviceIdx, queueIdx);
 
 		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_IndexBuffer);
 	}
 
-	void VulkanIndexBufferCore::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags, UINT32 queueIdx)
+	void VulkanIndexBuffer::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags, UINT32 queueIdx)
 	{
 		mBuffer->writeData(offset, length, source, writeFlags, queueIdx);
 
 		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_IndexBuffer);
 	}
 
-	void VulkanIndexBufferCore::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
+	void VulkanIndexBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
 										UINT32 dstOffset, UINT32 length, bool discardWholeBuffer, UINT32 queueIdx)
 	{
 		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer, queueIdx);
 	}
 
-	VulkanBuffer* VulkanIndexBufferCore::getResource(UINT32 deviceIdx) const
+	VulkanBuffer* VulkanIndexBuffer::getResource(UINT32 deviceIdx) const
 	{
 		return mBuffer->getResource(deviceIdx);
 	}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderAPI.cpp

@@ -236,16 +236,16 @@ namespace bs { namespace ct
 		mMainCommandBuffer = std::static_pointer_cast<VulkanCommandBuffer>(CommandBuffer::create(GQT_GRAPHICS));
 
 		// Create the texture manager for use by others		
-		TextureManager::startUp<VulkanTextureManager>();
-		TextureCoreManager::startUp<VulkanTextureCoreManager>();
+		bs::TextureManager::startUp<bs::VulkanTextureManager>();
+		TextureCoreManager::startUp<VulkanTextureManager>();
 
 		// Create hardware buffer manager		
 		HardwareBufferManager::startUp();
-		HardwareBufferCoreManager::startUp<VulkanHardwareBufferCoreManager>();
+		HardwareBufferCoreManager::startUp<VulkanHardwareBufferManager>();
 
 		// Create render window manager
-		RenderWindowManager::startUp<VulkanRenderWindowManager>();
-		RenderWindowCoreManager::startUp<VulkanRenderWindowCoreManager>(*this);
+		bs::RenderWindowManager::startUp<bs::VulkanRenderWindowManager>();
+		RenderWindowCoreManager::startUp<VulkanRenderWindowManager>(*this);
 
 		// Create query manager 
 		QueryManager::startUp<VulkanQueryManager>(*this);
@@ -257,7 +257,7 @@ namespace bs { namespace ct
 		mGLSLFactory = bs_new<VulkanGLSLProgramFactory>();
 
 		// Create render state manager
-		RenderStateCoreManager::startUp<VulkanRenderStateCoreManager>();
+		RenderStateCoreManager::startUp<VulkanRenderStateManager>();
 		GpuProgramCoreManager::instance().addFactory(mGLSLFactory);
 
 		initCapabilites();

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderStateManager.cpp

@@ -7,39 +7,39 @@
 
 namespace bs { namespace ct
 {
-	SPtr<SamplerStateCore> VulkanRenderStateCoreManager::createSamplerStateInternal(const SAMPLER_STATE_DESC& desc,
+	SPtr<SamplerStateCore> VulkanRenderStateManager::createSamplerStateInternal(const SAMPLER_STATE_DESC& desc,
 		GpuDeviceFlags deviceMask) const
 	{
-		SPtr<VulkanSamplerStateCore> samplerState =
-			bs_shared_ptr<VulkanSamplerStateCore>(new (bs_alloc<VulkanSamplerStateCore>()) VulkanSamplerStateCore(desc, deviceMask));
+		SPtr<VulkanSamplerState> samplerState =
+			bs_shared_ptr<VulkanSamplerState>(new (bs_alloc<VulkanSamplerState>()) VulkanSamplerState(desc, deviceMask));
 		samplerState->_setThisPtr(samplerState);
 
 		return samplerState;
 	}
 
-	SPtr<GraphicsPipelineStateCore> VulkanRenderStateCoreManager::_createGraphicsPipelineState(
+	SPtr<GraphicsPipelineStateCore> VulkanRenderStateManager::_createGraphicsPipelineState(
 		const PIPELINE_STATE_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
-		SPtr<VulkanGraphicsPipelineStateCore> pipelineState =
-			bs_shared_ptr<VulkanGraphicsPipelineStateCore>(new (bs_alloc<VulkanGraphicsPipelineStateCore>()) 
-			VulkanGraphicsPipelineStateCore(desc, deviceMask));
+		SPtr<VulkanGraphicsPipelineState> pipelineState =
+			bs_shared_ptr<VulkanGraphicsPipelineState>(new (bs_alloc<VulkanGraphicsPipelineState>()) 
+			VulkanGraphicsPipelineState(desc, deviceMask));
 		pipelineState->_setThisPtr(pipelineState);
 
 		return pipelineState;
 	}
 
-	SPtr<ComputePipelineStateCore> VulkanRenderStateCoreManager::_createComputePipelineState(
+	SPtr<ComputePipelineStateCore> VulkanRenderStateManager::_createComputePipelineState(
 		const SPtr<GpuProgramCore>& program, GpuDeviceFlags deviceMask) const
 	{
-		SPtr<VulkanComputePipelineStateCore> pipelineState =
-			bs_shared_ptr<VulkanComputePipelineStateCore>(new (bs_alloc<VulkanComputePipelineStateCore>())
-														  VulkanComputePipelineStateCore(program, deviceMask));
+		SPtr<VulkanComputePipelineState> pipelineState =
+			bs_shared_ptr<VulkanComputePipelineState>(new (bs_alloc<VulkanComputePipelineState>())
+														  VulkanComputePipelineState(program, deviceMask));
 		pipelineState->_setThisPtr(pipelineState);
 
 		return pipelineState;
 	}
 
-	SPtr<GpuPipelineParamInfoCore> VulkanRenderStateCoreManager::_createPipelineParamInfo(
+	SPtr<GpuPipelineParamInfoCore> VulkanRenderStateManager::_createPipelineParamInfo(
 		const GPU_PIPELINE_PARAMS_DESC& desc, GpuDeviceFlags deviceMask) const
 	{
 		SPtr<VulkanGpuPipelineParamInfo> paramInfo =

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderTexture.cpp

@@ -7,20 +7,28 @@
 #include "BsVulkanRenderAPI.h"
 #include "BsVulkanDevice.h"
 
-namespace bs { namespace ct
+namespace bs
 {
-	VulkanRenderTextureCore::VulkanRenderTextureCore(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
+	VulkanRenderTexture::VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc)
+		:RenderTexture(desc), mProperties(desc, false)
+	{ 
+
+	}
+
+	namespace ct
+	{
+	VulkanRenderTexture::VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc, UINT32 deviceIdx)
 		:RenderTextureCore(desc, deviceIdx), mProperties(desc, false), mDeviceIdx(deviceIdx), mFramebuffer(nullptr)
 	{
 		
 	}
 
-	VulkanRenderTextureCore::~VulkanRenderTextureCore()
+	VulkanRenderTexture::~VulkanRenderTexture()
 	{
 		mFramebuffer->destroy();
 	}
 
-	void VulkanRenderTextureCore::initialize()
+	void VulkanRenderTexture::initialize()
 	{
 		RenderTextureCore::initialize();
 
@@ -37,7 +45,7 @@ namespace bs { namespace ct
 				continue;
 
 			const SPtr<TextureView>& view = mColorSurfaces[i];
-			VulkanTextureCore* texture = static_cast<VulkanTextureCore*>(view->getTexture().get());
+			VulkanTexture* texture = static_cast<VulkanTexture*>(view->getTexture().get());
 
 			VulkanImage* image = texture->getResource(mDeviceIdx);
 			if (image == nullptr)
@@ -78,7 +86,7 @@ namespace bs { namespace ct
 		if(mDepthStencilSurface != nullptr)
 		{
 			const SPtr<TextureView>& view = mDepthStencilSurface;
-			VulkanTextureCore* texture = static_cast<VulkanTextureCore*>(view->getTexture().get());
+			VulkanTexture* texture = static_cast<VulkanTexture*>(view->getTexture().get());
 
 			VulkanImage* image = texture->getResource(mDeviceIdx);
 			if (image != nullptr)
@@ -123,7 +131,7 @@ namespace bs { namespace ct
 		mFramebuffer = device->getResourceManager().create<VulkanFramebuffer>(fbDesc);
 	}
 
-	void VulkanRenderTextureCore::getCustomAttribute(const String& name, void* data) const
+	void VulkanRenderTexture::getCustomAttribute(const String& name, void* data) const
 	{
 		if (name == "FB")
 		{
@@ -131,11 +139,6 @@ namespace bs { namespace ct
 			*fb = mFramebuffer;
 			return;
 		}
+	}		
 	}
-
-	VulkanRenderTexture::VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc)
-		:RenderTexture(desc), mProperties(desc, false)
-	{ 
-
-	}
-}}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderWindowManager.cpp

@@ -3,7 +3,7 @@
 #include "BsVulkanRenderWindowManager.h"
 #include "Win32/BsWin32RenderWindow.h"
 
-namespace bs { namespace ct
+namespace bs 
 {
 	VulkanRenderWindowManager::VulkanRenderWindowManager()
 	{ }
@@ -22,21 +22,24 @@ namespace bs { namespace ct
 		return bs_core_ptr<Win32RenderWindow>(renderWindow);
 	}
 
-	VulkanRenderWindowCoreManager::VulkanRenderWindowCoreManager(VulkanRenderAPI& renderAPI)
+	namespace ct
+	{
+		VulkanRenderWindowManager::VulkanRenderWindowManager(VulkanRenderAPI& renderAPI)
 		:mRenderAPI(renderAPI)
 	{ }
 
-	SPtr<RenderWindowCore> VulkanRenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
+	SPtr<RenderWindowCore> VulkanRenderWindowManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
 	{
 		// Create the window
-		Win32RenderWindowCore* renderWindow =
-			new (bs_alloc<Win32RenderWindowCore>()) Win32RenderWindowCore(desc, windowId, mRenderAPI);
+		Win32RenderWindow* renderWindow =
+			new (bs_alloc<Win32RenderWindow>()) Win32RenderWindow(desc, windowId, mRenderAPI);
 
-		SPtr<Win32RenderWindowCore> renderWindowPtr = bs_shared_ptr<Win32RenderWindowCore>(renderWindow);
+		SPtr<Win32RenderWindow> renderWindowPtr = bs_shared_ptr<Win32RenderWindow>(renderWindow);
 		renderWindowPtr->_setThisPtr(renderWindowPtr);
 
 		windowCreated(renderWindow);
 
 		return renderWindowPtr;
 	}
-}}
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanSamplerState.cpp

@@ -16,11 +16,11 @@ namespace bs { namespace ct
 		vkDestroySampler(mOwner->getDevice().getLogical(), mSampler, gVulkanAllocator);
 	}
 
-	VulkanSamplerStateCore::VulkanSamplerStateCore(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
+	VulkanSamplerState::VulkanSamplerState(const SAMPLER_STATE_DESC& desc, GpuDeviceFlags deviceMask)
 		:SamplerStateCore(desc, deviceMask), mSamplers(), mDeviceMask(deviceMask)
 	{ }
 
-	VulkanSamplerStateCore::~VulkanSamplerStateCore()
+	VulkanSamplerState::~VulkanSamplerState()
 	{
 		for(UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
@@ -31,7 +31,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	void VulkanSamplerStateCore::createInternal()
+	void VulkanSamplerState::createInternal()
 	{
 		FilterOptions minFilter = getProperties().getTextureFiltering(FT_MIN);
 		FilterOptions magFilter = getProperties().getTextureFiltering(FT_MAG);

Source/BansheeVulkanRenderAPI/Source/BsVulkanTexture.cpp

@@ -382,7 +382,7 @@ namespace bs { namespace ct
 		:VulkanResource(owner, false)
 	{ }
 
-	VulkanTextureCore::VulkanTextureCore(const TEXTURE_DESC& desc, const SPtr<PixelData>& initialData,
+	VulkanTexture::VulkanTexture(const TEXTURE_DESC& desc, const SPtr<PixelData>& initialData,
 										 GpuDeviceFlags deviceMask)
 		: TextureCore(desc, initialData, deviceMask), mImages(), mDeviceMask(deviceMask), mStagingBuffer(nullptr)
 		, mMappedDeviceIdx(-1), mMappedGlobalQueueIdx(-1), mMappedMip(0), mMappedFace(0), mMappedRowPitch(false)
@@ -392,7 +392,7 @@ namespace bs { namespace ct
 		
 	}
 
-	VulkanTextureCore::~VulkanTextureCore()
+	VulkanTexture::~VulkanTexture()
 	{ 
 		for (UINT32 i = 0; i < BS_MAX_DEVICES; i++)
 		{
@@ -407,7 +407,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Texture);
 	}
 
-	void VulkanTextureCore::initialize()
+	void VulkanTexture::initialize()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -515,7 +515,7 @@ namespace bs { namespace ct
 		TextureCore::initialize();
 	}
 
-	VulkanImage* VulkanTextureCore::createImage(VulkanDevice& device, PixelFormat format)
+	VulkanImage* VulkanTexture::createImage(VulkanDevice& device, PixelFormat format)
 	{
 		bool directlyMappable = mImageCI.tiling == VK_IMAGE_TILING_LINEAR;
 		VkMemoryPropertyFlags flags = directlyMappable ?
@@ -540,7 +540,7 @@ namespace bs { namespace ct
 		return device.getResourceManager().create<VulkanImage>(image, memory, mImageCI.initialLayout, getProperties());
 	}
 
-	VulkanBuffer* VulkanTextureCore::createStaging(VulkanDevice& device, const PixelData& pixelData, bool readable)
+	VulkanBuffer* VulkanTexture::createStaging(VulkanDevice& device, const PixelData& pixelData, bool readable)
 	{
 		VkBufferCreateInfo bufferCI;
 		bufferCI.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
@@ -576,7 +576,7 @@ namespace bs { namespace ct
 			pixelData.getRowPitch(), pixelData.getSlicePitch());
 	}
 
-	void VulkanTextureCore::copyImage(VulkanTransferBuffer* cb, VulkanImage* srcImage, VulkanImage* dstImage, 
+	void VulkanTexture::copyImage(VulkanTransferBuffer* cb, VulkanImage* srcImage, VulkanImage* dstImage, 
 									  VkImageLayout srcFinalLayout, VkImageLayout dstFinalLayout)
 	{
 		UINT32 numFaces = mProperties.getNumFaces();
@@ -653,10 +653,10 @@ namespace bs { namespace ct
 		bs_stack_free(imageRegions);
 	}
 
-	void VulkanTextureCore::copyImpl(UINT32 srcFace, UINT32 srcMipLevel, UINT32 destFace, UINT32 destMipLevel,
+	void VulkanTexture::copyImpl(UINT32 srcFace, UINT32 srcMipLevel, UINT32 destFace, UINT32 destMipLevel,
 									 const SPtr<TextureCore>& target, UINT32 queueIdx)
 	{
-		VulkanTextureCore* other = static_cast<VulkanTextureCore*>(target.get());
+		VulkanTexture* other = static_cast<VulkanTexture*>(target.get());
 
 		const TextureProperties& srcProps = mProperties;
 		const TextureProperties& dstProps = other->getProperties();
@@ -835,7 +835,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	PixelData VulkanTextureCore::lockImpl(GpuLockOptions options, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx,
+	PixelData VulkanTexture::lockImpl(GpuLockOptions options, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx,
 										  UINT32 queueIdx)
 	{
 		const TextureProperties& props = getProperties();
@@ -1092,7 +1092,7 @@ namespace bs { namespace ct
 		return lockedArea;
 	}
 
-	void VulkanTextureCore::unlockImpl()
+	void VulkanTexture::unlockImpl()
 	{
 		// Possibly map() failed with some error
 		if (!mIsMapped)
@@ -1248,7 +1248,7 @@ namespace bs { namespace ct
 		mIsMapped = false;
 	}
 
-	void VulkanTextureCore::readDataImpl(PixelData& dest, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
+	void VulkanTexture::readDataImpl(PixelData& dest, UINT32 mipLevel, UINT32 face, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		if (mProperties.getNumSamples() > 1)
 		{
@@ -1263,7 +1263,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_Texture);
 	}
 
-	void VulkanTextureCore::writeDataImpl(const PixelData& src, UINT32 mipLevel, UINT32 face, bool discardWholeBuffer,
+	void VulkanTexture::writeDataImpl(const PixelData& src, UINT32 mipLevel, UINT32 face, bool discardWholeBuffer,
 									  UINT32 queueIdx)
 	{
 		if (mProperties.getNumSamples() > 1)

Source/BansheeVulkanRenderAPI/Source/BsVulkanTextureManager.cpp

@@ -5,7 +5,7 @@
 #include "BsVulkanRenderTexture.h"
 #include "BsVulkanResource.h"
 
-namespace bs { namespace ct
+namespace bs
 {
 	SPtr<RenderTexture> VulkanTextureManager::createRenderTextureImpl(const RENDER_TEXTURE_DESC& desc)
 	{
@@ -19,7 +19,9 @@ namespace bs { namespace ct
 		return PF_R8G8B8A8;;
 	}
 
-	void VulkanTextureCoreManager::onStartUp()
+	namespace ct
+	{
+	void VulkanTextureManager::onStartUp()
 	{
 		TextureCoreManager::onStartUp();
 
@@ -37,41 +39,42 @@ namespace bs { namespace ct
 		desc.usage = TU_STATIC;
 
 		// Note: When multi-GPU is properly tested, make sure to create these textures on all GPUs
-		mDummyReadTexture = std::static_pointer_cast<VulkanTextureCore>(createTexture(desc));
+		mDummyReadTexture = std::static_pointer_cast<VulkanTexture>(createTexture(desc));
 		mDummyReadTexture->writeData(*whitePixelData);
 
 		desc.usage = TU_LOADSTORE;
 
-		mDummyStorageTexture = std::static_pointer_cast<VulkanTextureCore>(createTexture(desc));
+		mDummyStorageTexture = std::static_pointer_cast<VulkanTexture>(createTexture(desc));
 	}
 
-	VkImageView VulkanTextureCoreManager::getDummyReadImageView(UINT32 deviceIdx) const
+	VkImageView VulkanTextureManager::getDummyReadImageView(UINT32 deviceIdx) const
 	{
 		return mDummyReadTexture->getResource(deviceIdx)->getView(false);
 	}
 
-	VkImageView VulkanTextureCoreManager::getDummyStorageImageView(UINT32 deviceIdx) const
+	VkImageView VulkanTextureManager::getDummyStorageImageView(UINT32 deviceIdx) const
 	{
 		return mDummyStorageTexture->getResource(deviceIdx)->getView(false);
 	}
 
-	SPtr<TextureCore> VulkanTextureCoreManager::createTextureInternal(const TEXTURE_DESC& desc,
+	SPtr<TextureCore> VulkanTextureManager::createTextureInternal(const TEXTURE_DESC& desc,
 		const SPtr<PixelData>& initialData, GpuDeviceFlags deviceMask)
 	{
-		VulkanTextureCore* tex = new (bs_alloc<VulkanTextureCore>()) VulkanTextureCore(desc, initialData, deviceMask);
+		VulkanTexture* tex = new (bs_alloc<VulkanTexture>()) VulkanTexture(desc, initialData, deviceMask);
 
-		SPtr<VulkanTextureCore> texPtr = bs_shared_ptr<VulkanTextureCore>(tex);
+		SPtr<VulkanTexture> texPtr = bs_shared_ptr<VulkanTexture>(tex);
 		texPtr->_setThisPtr(texPtr);
 
 		return texPtr;
 	}
 
-	SPtr<RenderTextureCore> VulkanTextureCoreManager::createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc,
+	SPtr<RenderTextureCore> VulkanTextureManager::createRenderTextureInternal(const RENDER_TEXTURE_DESC& desc,
 																				  UINT32 deviceIdx)
 	{
-		SPtr<VulkanRenderTextureCore> texPtr = bs_shared_ptr_new<VulkanRenderTextureCore>(desc, deviceIdx);
+		SPtr<VulkanRenderTexture> texPtr = bs_shared_ptr_new<VulkanRenderTexture>(desc, deviceIdx);
 		texPtr->_setThisPtr(texPtr);
 
 		return texPtr;
 	}
-}}
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanVertexBuffer.cpp

@@ -6,11 +6,11 @@
 
 namespace bs { namespace ct
 {
-	VulkanVertexBufferCore::VulkanVertexBufferCore(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+	VulkanVertexBuffer::VulkanVertexBuffer(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
 		:VertexBufferCore(desc, deviceMask), mBuffer(nullptr), mUsage(desc.usage), mDeviceMask(deviceMask)
 	{ }
 
-	VulkanVertexBufferCore::~VulkanVertexBufferCore()
+	VulkanVertexBuffer::~VulkanVertexBuffer()
 	{
 		if (mBuffer != nullptr)
 			bs_delete(mBuffer);
@@ -18,7 +18,7 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_VertexBuffer);
 	}
 
-	void VulkanVertexBufferCore::initialize()
+	void VulkanVertexBuffer::initialize()
 	{
 		mBuffer = bs_new<VulkanHardwareBuffer>(VulkanHardwareBuffer::BT_VERTEX, BF_UNKNOWN, mUsage, mSize, mDeviceMask);
 
@@ -26,7 +26,7 @@ namespace bs { namespace ct
 		VertexBufferCore::initialize();
 	}
 
-	void* VulkanVertexBufferCore::map(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
+	void* VulkanVertexBuffer::map(UINT32 offset, UINT32 length, GpuLockOptions options, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 #if BS_PROFILING_ENABLED
 		if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
@@ -43,19 +43,19 @@ namespace bs { namespace ct
 		return mBuffer->lock(offset, length, options, deviceIdx, queueIdx);
 	}
 
-	void VulkanVertexBufferCore::unmap()
+	void VulkanVertexBuffer::unmap()
 	{
 		mBuffer->unlock();
 	}
 
-	void VulkanVertexBufferCore::readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx, UINT32 queueIdx)
+	void VulkanVertexBuffer::readData(UINT32 offset, UINT32 length, void* dest, UINT32 deviceIdx, UINT32 queueIdx)
 	{
 		mBuffer->readData(offset, length, dest, deviceIdx, queueIdx);
 
 		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_VertexBuffer);
 	}
 
-	void VulkanVertexBufferCore::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags, 
+	void VulkanVertexBuffer::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags, 
 		UINT32 queueIdx)
 	{
 		mBuffer->writeData(offset, length, source, writeFlags, queueIdx);
@@ -63,13 +63,13 @@ namespace bs { namespace ct
 		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_VertexBuffer);
 	}
 
-	void VulkanVertexBufferCore::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
+	void VulkanVertexBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
 		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer, UINT32 queueIdx)
 	{
 		mBuffer->copyData(srcBuffer, srcOffset, dstOffset, length, discardWholeBuffer, queueIdx);
 	}
 
-	VulkanBuffer* VulkanVertexBufferCore::getResource(UINT32 deviceIdx) const
+	VulkanBuffer* VulkanVertexBuffer::getResource(UINT32 deviceIdx) const
 	{
 		return mBuffer->getResource(deviceIdx);
 	}

Source/BansheeVulkanRenderAPI/Source/Win32/BsWin32RenderWindow.cpp

@@ -16,18 +16,73 @@
 #include "BsVulkanQueue.h"
 #include "BsMath.h"
 
-namespace bs { namespace ct
+namespace bs
 {
 	Win32RenderWindowProperties::Win32RenderWindowProperties(const RENDER_WINDOW_DESC& desc)
 		:RenderWindowProperties(desc)
 	{ }
 
-	Win32RenderWindowCore::Win32RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId, VulkanRenderAPI& renderAPI)
+	Win32RenderWindow::Win32RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
+		: RenderWindow(desc, windowId), mProperties(desc)
+	{
+
+	}
+
+	void Win32RenderWindow::getCustomAttribute(const String& name, void* pData) const
+	{
+		if (name == "WINDOW")
+		{
+			UINT64 *pHwnd = (UINT64*)pData;
+			*pHwnd = (UINT64)getHWnd();
+			return;
+		}
+	}
+
+	Vector2I Win32RenderWindow::screenToWindowPos(const Vector2I& screenPos) const
+	{
+		POINT pos;
+		pos.x = screenPos.x;
+		pos.y = screenPos.y;
+
+		ScreenToClient(getHWnd(), &pos);
+		return Vector2I(pos.x, pos.y);
+	}
+
+	Vector2I Win32RenderWindow::windowToScreenPos(const Vector2I& windowPos) const
+	{
+		POINT pos;
+		pos.x = windowPos.x;
+		pos.y = windowPos.y;
+
+		ClientToScreen(getHWnd(), &pos);
+		return Vector2I(pos.x, pos.y);
+	}
+
+	SPtr<ct::Win32RenderWindow> Win32RenderWindow::getCore() const
+	{
+		return std::static_pointer_cast<ct::Win32RenderWindow>(mCoreSpecific);
+	}
+
+	HWND Win32RenderWindow::getHWnd() const
+	{
+		blockUntilCoreInitialized();
+		return getCore()->_getWindowHandle();
+	}
+
+	void Win32RenderWindow::syncProperties()
+	{
+		ScopedSpinLock lock(getCore()->mLock);
+		mProperties = getCore()->mSyncedProperties;
+	}
+
+	namespace ct
+	{
+		Win32RenderWindow::Win32RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId, VulkanRenderAPI& renderAPI)
 		: RenderWindowCore(desc, windowId), mProperties(desc), mSyncedProperties(desc), mWindow(nullptr), mIsChild(false)
 		, mShowOnSwap(false), mDisplayFrequency(0), mRenderAPI(renderAPI), mRequiresNewBackBuffer(true)
 	{ }
 
-	Win32RenderWindowCore::~Win32RenderWindowCore()
+		Win32RenderWindow::~Win32RenderWindow()
 	{ 
 		SPtr<VulkanDevice> presentDevice = mRenderAPI._getPresentDevice();
 		presentDevice->waitIdle();
@@ -45,7 +100,7 @@ namespace bs { namespace ct
 		vkDestroySurfaceKHR(mRenderAPI._getInstance(), mSurface, gVulkanAllocator);
 	}
 
-	void Win32RenderWindowCore::initialize()
+	void Win32RenderWindow::initialize()
 	{
 		Win32RenderWindowProperties& props = mProperties;
 
@@ -276,7 +331,7 @@ namespace bs { namespace ct
 		RenderWindowCore::initialize();
 	}
 
-	void Win32RenderWindowCore::acquireBackBuffer()
+	void Win32RenderWindow::acquireBackBuffer()
 	{
 		// We haven't presented the current back buffer yet, so just use that one
 		if (!mRequiresNewBackBuffer)
@@ -286,7 +341,7 @@ namespace bs { namespace ct
 		mRequiresNewBackBuffer = false;
 	}
 
-	void Win32RenderWindowCore::swapBuffers(UINT32 syncMask)
+	void Win32RenderWindow::swapBuffers(UINT32 syncMask)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -320,7 +375,7 @@ namespace bs { namespace ct
 		mRequiresNewBackBuffer = true;
 	}
 
-	void Win32RenderWindowCore::move(INT32 left, INT32 top)
+	void Win32RenderWindow::move(INT32 left, INT32 top)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -343,7 +398,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	void Win32RenderWindowCore::resize(UINT32 width, UINT32 height)
+	void Win32RenderWindow::resize(UINT32 width, UINT32 height)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -366,7 +421,7 @@ namespace bs { namespace ct
 		}
 	}
 
-	void Win32RenderWindowCore::setActive(bool state)
+	void Win32RenderWindow::setActive(bool state)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -375,7 +430,7 @@ namespace bs { namespace ct
 		RenderWindowCore::setActive(state);
 	}
 
-	void Win32RenderWindowCore::setHidden(bool hidden)
+	void Win32RenderWindow::setHidden(bool hidden)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -385,28 +440,28 @@ namespace bs { namespace ct
 		RenderWindowCore::setHidden(hidden);
 	}
 
-	void Win32RenderWindowCore::minimize()
+	void Win32RenderWindow::minimize()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		mWindow->minimize();
 	}
 
-	void Win32RenderWindowCore::maximize()
+	void Win32RenderWindow::maximize()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		mWindow->maximize();
 	}
 
-	void Win32RenderWindowCore::restore()
+	void Win32RenderWindow::restore()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		mWindow->restore();
 	}
 
-	void Win32RenderWindowCore::setFullscreen(UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
+	void Win32RenderWindow::setFullscreen(UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -459,14 +514,14 @@ namespace bs { namespace ct
 		SetWindowPos(mWindow->getHWnd(), HWND_TOP, props.mLeft, props.mTop, width, height, SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
 	}
 
-	void Win32RenderWindowCore::setFullscreen(const VideoMode& mode)
+	void Win32RenderWindow::setFullscreen(const VideoMode& mode)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
 		setFullscreen(mode.getWidth(), mode.getHeight(), mode.getRefreshRate(), mode.getOutputIdx());
 	}
 
-	void Win32RenderWindowCore::setWindowed(UINT32 width, UINT32 height)
+	void Win32RenderWindow::setWindowed(UINT32 width, UINT32 height)
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -520,12 +575,12 @@ namespace bs { namespace ct
 		RenderWindowManager::instance().notifySyncDataDirty(this);
 	}
 
-	HWND Win32RenderWindowCore::_getWindowHandle() const
+	HWND Win32RenderWindow::_getWindowHandle() const
 	{
 		return mWindow->getHWnd();
 	}
 
-	void Win32RenderWindowCore::getCustomAttribute(const String& name, void* data) const
+	void Win32RenderWindow::getCustomAttribute(const String& name, void* data) const
 	{
 		if (name == "FB")
 		{
@@ -544,7 +599,7 @@ namespace bs { namespace ct
 		RenderWindowCore::getCustomAttribute(name, data);
 	}
 
-	void Win32RenderWindowCore::_windowMovedOrResized()
+	void Win32RenderWindow::_windowMovedOrResized()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -576,62 +631,10 @@ namespace bs { namespace ct
 		RenderWindowCore::_windowMovedOrResized();
 	}
 
-	void Win32RenderWindowCore::syncProperties()
+	void Win32RenderWindow::syncProperties()
 	{
 		ScopedSpinLock lock(mLock);
 		mProperties = mSyncedProperties;
 	}
-
-	Win32RenderWindow::Win32RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
-		:RenderWindow(desc, windowId), mProperties(desc)
-	{
-
-	}
-
-	void Win32RenderWindow::getCustomAttribute(const String& name, void* pData) const
-	{
-		if (name == "WINDOW")
-		{
-			UINT64 *pHwnd = (UINT64*)pData;
-			*pHwnd = (UINT64)getHWnd();
-			return;
-		}
-	}
-
-	Vector2I Win32RenderWindow::screenToWindowPos(const Vector2I& screenPos) const
-	{
-		POINT pos;
-		pos.x = screenPos.x;
-		pos.y = screenPos.y;
-
-		ScreenToClient(getHWnd(), &pos);
-		return Vector2I(pos.x, pos.y);
-	}
-
-	Vector2I Win32RenderWindow::windowToScreenPos(const Vector2I& windowPos) const
-	{
-		POINT pos;
-		pos.x = windowPos.x;
-		pos.y = windowPos.y;
-
-		ClientToScreen(getHWnd(), &pos);
-		return Vector2I(pos.x, pos.y);
-	}
-
-	SPtr<Win32RenderWindowCore> Win32RenderWindow::getCore() const
-	{
-		return std::static_pointer_cast<Win32RenderWindowCore>(mCoreSpecific);
-	}
-
-	HWND Win32RenderWindow::getHWnd() const
-	{
-		blockUntilCoreInitialized();
-		return getCore()->_getWindowHandle();
-	}
-
-	void Win32RenderWindow::syncProperties()
-	{
-		ScopedSpinLock lock(getCore()->mLock);
-		mProperties = getCore()->mSyncedProperties;
 	}
-}}
+}