Added skeleton for Vulkan render API

Documentation/GitHub/compiling.md

@@ -14,7 +14,7 @@ To compile follow these steps:
  1. Download source code
  2. Set up [third party dependencies](#dependencies)
  3. Generate a build file (e.g. Visual Studio solution or a Makefile) using CMake
-  - You can customize your build by choosing options like render API (DirectX, OpenGL), audio module and whether to build the entire editor or just the engine.
+  - You can customize your build by choosing options like render API (Vulkan, DirectX, OpenGL), audio module and whether to build the entire editor or just the engine.
  4. Compile using your favorite tool
 
 # <a name="dependencies"></a>Third party dependencies
@@ -39,6 +39,11 @@ The following dependencies will need to be installed manually regardless if you
  - Only needed if on Windows 10 and using DirectX 11 render API
  - Go to Settings panel (type "Settings" in Start)->System->Apps & features->Manage optional Features->Add a feature->Select "Graphics Tools"
  
+**Vulkan SDK** (Optional if not using Vulkan) 
+ - Only needed if you selected the Vulkan render API during build configuration (selected by default)
+ - https://lunarg.com/vulkan-sdk/
+ - If CMake complains it cannot find Vulkan, manually set the Vulkan_INSTALL_DIRS to your installation directory
+ 
 **Python 3.5** (Optional)
  - Only needed if you plan on running Python scripts in the /Scripts folder
  - https://www.python.org/downloads/

Documentation/GitHub/dependencies.md

@@ -169,7 +169,7 @@ If the library structure still isn't clear, download one of the pre-compiled dep
     - libvorbisfile.dll (All configurations)
    
 **libFLAC**
- - libflac commit:94a61241b02064c7d9fe508f72a742f2a90b8492
+ - libflac commit: 94a61241b02064c7d9fe508f72a742f2a90b8492
  - https://git.xiph.org/?p=flac.git
  - Compilation notes:
   - Requires libogg, as described in its readme file.
@@ -179,6 +179,23 @@ If the library structure still isn't clear, download one of the pre-compiled dep
     - libFLAC.lib (Compile using "release" configuration)
     - libFLAC_dynamic.dll (All configurations)
    
+**glslang**
+ - glslang commit: 19bdf90eba71390f04bb85226337517df65d73e2
+ - https://github.com/KhronosGroup/glslang
+ - Compilation notes:
+  - Read the glslangCompilationGuide.txt before compiling
+ - Required by BansheeVulkanRenderAPI
+ - Outputs:
+  - Windows (Static library):
+    - glslang.lib (Compile using "release" configuration)
+	- glslangd.lib (Compile using "debug" configuration)
+	- HLSL.lib (Compile using "release" configuration)
+	- HLSLd.lib (Compile using "debug" configuration)
+	- OGLCompiler.lib (Compile using "release" configuration)
+	- OGLCompilerd.lib (Compile using "debug" configuration)
+	- OSDependent.lib (Compile using "release" configuration)
+	- OSDependentd.lib (Compile using "debug" configuration)
+   
 **bison**
  - Bison 2.7
  - http://sourceforge.net/projects/winflexbison/files/

Documentation/glslangCompilationGuide.txt

@@ -0,0 +1,4 @@
+Certain Banshee specific modification is required before compiling glslang:
+ - Add getAttributeTType to TProgram's public interface:
+  - Method signature: const TType* getAttributeTType(int index) const;
+  - Method implementation: const TType* TProgram::getAttributeTType(int index) const	 { return reflection->getAttribute(index).getType(); }

Source/BansheeD3D11RenderAPI/Include/BsD3D11Prerequisites.h

@@ -35,16 +35,13 @@ namespace BansheeEngine
 	class D3D11RenderWindow;
 	class D3D11Texture;
 	class D3D11TextureManager;
-	class D3D11DepthBuffer;
 	class D3D11Driver;
 	class D3D11DriverList;
 	class D3D11VideoMode;
 	class D3D11VideoModeList;
 	class D3D11GpuProgramManager;
 	class D3D11IndexBuffer;
-	class D3D11HardwareConstantBuffer;
 	class D3D11HLSLProgramFactory;
-	class D3D11HLSLProgram;
 	class D3D11VertexDeclaration;
 	class D3D11Device;
 	class D3D11HardwareBuffer;

Source/BansheeD3D11RenderAPI/Include/BsD3D11RenderAPIFactory.h

@@ -2,7 +2,6 @@
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
 #pragma once
 
-#include <string>
 #include "BsRenderAPIFactory.h"
 #include "BsRenderAPIManager.h"
 #include "BsD3D11RenderAPI.h"

Source/BansheeD3D11RenderAPI/Include/BsD3D11RenderStateManager.h

@@ -16,16 +16,16 @@ namespace BansheeEngine
 	{
 	protected:
 		/** @copydoc RenderStateCoreManager::createSamplerStateInternal */
-		virtual SPtr<SamplerStateCore> createSamplerStateInternal(const SAMPLER_STATE_DESC& desc) const override;
+		SPtr<SamplerStateCore> createSamplerStateInternal(const SAMPLER_STATE_DESC& desc) const override;
 
 		/** @copydoc RenderStateCoreManager::createBlendStateInternal */
-		virtual SPtr<BlendStateCore> createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const override;
+		SPtr<BlendStateCore> createBlendStateInternal(const BLEND_STATE_DESC& desc, UINT32 id) const override;
 
 		/** @copydoc RenderStateCoreManager::createRasterizerStateInternal */
-		virtual SPtr<RasterizerStateCore> createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const override;
+		SPtr<RasterizerStateCore> createRasterizerStateInternal(const RASTERIZER_STATE_DESC& desc, UINT32 id) const override;
 
 		/** @copydoc RenderStateCoreManager::createDepthStencilStateInternal */
-		virtual SPtr<DepthStencilStateCore> createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const override;
+		SPtr<DepthStencilStateCore> createDepthStencilStateInternal(const DEPTH_STENCIL_STATE_DESC& desc, UINT32 id) const override;
 	};
 
 	/** @} */

Source/BansheeD3D11RenderAPI/Include/BsD3D11TextureManager.h

@@ -27,7 +27,7 @@ namespace BansheeEngine
 	class BS_D3D11_EXPORT D3D11TextureCoreManager : public TextureCoreManager
 	{
 	protected:
-		/** @copydoc	TextureCoreManager::createTextureInternal */
+		/** @copydoc TextureCoreManager::createTextureInternal */
 		SPtr<TextureCore> createTextureInternal(const TEXTURE_DESC& desc, 
 			const SPtr<PixelData>& initialData = nullptr, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
 

Source/BansheeD3D11RenderAPI/Source/BsD3D11HardwareBuffer.cpp

@@ -6,8 +6,6 @@
 #include "BsException.h"
 #include "BsDebug.h"
 
-#include "BsProfilerCPU.h"
-
 namespace BansheeEngine
 {
 	D3D11HardwareBuffer::D3D11HardwareBuffer(BufferType btype, GpuBufferUsage usage, UINT32 elementCount, UINT32 elementSize, 
@@ -195,7 +193,7 @@ namespace BansheeEngine
 		}
 	}
 
-	void D3D11HardwareBuffer::unmap(void)
+	void D3D11HardwareBuffer::unmap()
 	{
 		if (mUseTempStagingBuffer)
 		{

Source/BansheeFMOD/CMakeLists.txt

@@ -26,13 +26,7 @@ target_compile_definitions(BansheeFMOD PRIVATE -DBS_FMOD_EXPORTS)
 
 # Libraries
 ## External libs: FMOD, Vorbis, Ogg
-add_library(FMOD STATIC IMPORTED)
-
-set_target_properties(FMOD PROPERTIES IMPORTED_LOCATION_DEBUG "${FMOD_LIBRARIES_DEBUG}")
-set_target_properties(FMOD PROPERTIES IMPORTED_LOCATION_OPTIMIZEDDEBUG "${FMOD_LIBRARIES_DEBUG}")
-set_target_properties(FMOD PROPERTIES IMPORTED_LOCATION_RELEASE "${FMOD_LIBRARIES_OPTIMIZED}")	
-
-target_link_libraries(BansheeFMOD PRIVATE FMOD)	
+add_package_library(BansheeFMOD FMOD)
 
 add_library_per_config_multi(BansheeFMOD libvorbis libvorbis libvorbis libvorbis)
 add_library_per_config_multi(BansheeFMOD libvorbisfile libvorbis libvorbisfile libvorbisfile)

Source/BansheeVulkanRenderAPI/CMakeLists.txt

@@ -0,0 +1,38 @@
+# Source files and their filters
+include(CMakeSources.cmake)
+
+# Packages
+if(RENDER_API_MODULE MATCHES "Vulkan")
+	find_package(Vulkan)
+	find_package(glslang)
+endif()
+
+# Includes
+set(BansheeVulkanRenderAPI_INC 
+	"Include" 
+	"../BansheeUtility/Include" 
+	"../BansheeCore/Include"
+	${Vulkan_INCLUDE_DIR}
+	${glslang_INCLUDE_DIR})
+
+if(WIN32)
+	set(BansheeVulkanRenderAPI_INC ${BansheeVulkanRenderAPI_INC} "Source/Win32")
+else()
+# TODO_OTHER_PLATFORMS_GO_HERE
+endif()	
+	
+include_directories(${BansheeVulkanRenderAPI_INC})	
+	
+# Target
+add_library(BansheeVulkanRenderAPI SHARED ${BS_BANSHEEVULKANRENDERAPI_SRC})
+
+# Libraries	
+## External libs: Vulkan, glslang
+add_package_library(BansheeVulkanRenderAPI Vulkan)
+add_package_library(BansheeVulkanRenderAPI glslang)
+
+## Local libs
+target_link_libraries(BansheeVulkanRenderAPI PRIVATE BansheeUtility BansheeCore)
+
+# IDE specific
+set_property(TARGET BansheeVulkanRenderAPI PROPERTY FOLDER Plugins)

Source/BansheeVulkanRenderAPI/CMakeSources.cmake

@@ -0,0 +1,71 @@
+set(BS_BANSHEEVULKANRENDERAPI_INC_NOFILTER
+	"Include/Win32/BsWin32VideoModeInfo.h"
+	"Include/Win32/BsWin32RenderWindow.h"	
+	"Include/BsVulkanVertexBuffer.h"
+	"Include/BsVulkanTimerQuery.h"
+	"Include/BsVulkanTexture.h"
+	"Include/BsVulkanRenderTexture.h"
+	"Include/BsVulkanPrerequisites.h"
+	"Include/BsVulkanOcclusionQuery.h"
+	"Include/BsVulkanMappings.h"
+	"Include/BsVulkanIndexBuffer.h"
+	"Include/BsVulkanHardwareBuffer.h"
+	"Include/BsVulkanGpuProgram.h"
+	"Include/BsVulkanGpuParamBlockBuffer.h"
+	"Include/BsVulkanGpuBuffer.h"
+	"Include/BsVulkanEventQuery.h"
+	"Include/BsVulkanRenderAPI.h"
+	"Include/BsVulkanCommandBuffer.h"
+)
+
+set(BS_BANSHEEVULKANRENDERAPI_INC_MANAGERS
+	"Include/BsVulkanTextureManager.h"
+	"Include/BsVulkanRenderWindowManager.h"
+	"Include/BsVulkanQueryManager.h"
+	"Include/BsVulkanGLSLProgramFactory.h"
+	"Include/BsVulkanHardwareBufferManager.h"
+	"Include/BsVulkanRenderAPIFactory.h"
+	"Include/BsVulkanCommandBufferManager.h"
+)
+
+set(BS_BANSHEEVULKANRENDERAPI_SRC_NOFILTER
+	"Source/Win32/BsWin32VideoModeInfo.cpp"
+	"Source/Win32/BsWin32RenderWindow.cpp"	
+	"Source/BsVulkanVertexBuffer.cpp"
+	"Source/BsVulkanTimerQuery.cpp"
+	"Source/BsVulkanTexture.cpp"
+	"Source/BsVulkanRenderTexture.cpp"
+	"Source/BsVulkanPlugin.cpp"
+	"Source/BsVulkanOcclusionQuery.cpp"
+	"Source/BsVulkanMappings.cpp"
+	"Source/BsVulkanIndexBuffer.cpp"
+	"Source/BsVulkanHardwareBuffer.cpp"
+	"Source/BsVulkanGpuProgram.cpp"
+	"Source/BsVulkanGpuParamBlockBuffer.cpp"
+	"Source/BsVulkanGpuBuffer.cpp"
+	"Source/BsVulkanEventQuery.cpp"
+	"Source/BsVulkanRenderAPI.cpp"
+	"Source/BsVulkanCommandBuffer.cpp"
+)
+
+set(BS_BANSHEEVULKANRENDERAPI_SRC_MANAGERS
+	"Source/BsVulkanTextureManager.cpp"
+	"Source/BsVulkanRenderWindowManager.cpp"
+	"Source/BsVulkanQueryManager.cpp"
+	"Source/BsVulkanGLSLProgramFactory.cpp"
+	"Source/BsVulkanHardwareBufferManager.cpp"
+	"Source/BsVulkanRenderAPIFactory.cpp"
+	"Source/BsVulkanCommandBufferManager.cpp"
+)
+
+source_group("Header Files" FILES ${BS_BANSHEEVULKANRENDERAPI_INC_NOFILTER})
+source_group("Header Files\\Managers" FILES ${BS_BANSHEEVULKANRENDERAPI_INC_MANAGERS})
+source_group("Source Files" FILES ${BS_BANSHEEVULKANRENDERAPI_SRC_NOFILTER})
+source_group("Source Files\\Managers" FILES ${BS_BANSHEEVULKANRENDERAPI_SRC_MANAGERS})
+
+set(BS_BANSHEEVULKANRENDERAPI_SRC
+	${BS_BANSHEEVULKANRENDERAPI_INC_NOFILTER}
+	${BS_BANSHEEVULKANRENDERAPI_SRC_NOFILTER}
+	${BS_BANSHEEVULKANRENDERAPI_INC_MANAGERS}
+	${BS_BANSHEEVULKANRENDERAPI_SRC_MANAGERS}
+)

Source/BansheeVulkanRenderAPI/Include/BsVulkanCommandBuffer.h

@@ -0,0 +1,27 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsCommandBuffer.h"
+#include "BsVulkanRenderAPI.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** CommandBuffer implementation for Vulkan. */
+	class VulkanCommandBuffer : public CommandBuffer
+	{
+	public:
+
+	private:
+		friend class VulkanCommandBufferManager;
+
+		VulkanCommandBuffer(CommandBufferType type, UINT32 deviceIdx, UINT32 syncMask, bool secondary);
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanCommandBufferManager.h

@@ -0,0 +1,28 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsCommandBufferManager.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** 
+	 * Handles creation of Vulkan command buffers. See CommandBuffer. 
+	 *
+	 * @note Core thread only.
+	 */
+	class VulkanCommandBufferManager : public CommandBufferManager
+	{
+	public:
+		/** @copydoc CommandBufferManager::create() */
+		SPtr<CommandBuffer> create(CommandBufferType type, UINT32 deviceIdx = 0, UINT32 syncMask = 0xFFFFFFFF, 
+			bool secondary = false) override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanEventQuery.h

@@ -0,0 +1,31 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsEventQuery.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** @copydoc EventQuery */
+	class VulkanEventQuery : public EventQuery
+	{
+	public:
+		VulkanEventQuery(UINT32 deviceIdx);
+		~VulkanEventQuery();
+
+		/** @copydoc EventQuery::begin */
+		void begin() override;
+
+		/** @copydoc EventQuery::isReady */
+		bool isReady() const override;
+
+	private:
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanGLSLProgramFactory.h

@@ -0,0 +1,35 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsGpuProgramManager.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Handles creation of GLSL GPU programs. */
+	class VulkanGLSLProgramFactory : public GpuProgramFactory
+	{
+	public:
+		VulkanGLSLProgramFactory() {}
+		~VulkanGLSLProgramFactory() {}
+
+		/** @copydoc GpuProgramFactory::getLanguage */
+		const String& getLanguage() const override;
+
+		/** @copydoc GpuProgramFactory::create(const GPU_PROGRAM_DESC&, GpuDeviceFlags) */
+		SPtr<GpuProgramCore> create(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+
+		/** @copydoc GpuProgramFactory::create(GpuProgramType, GpuDeviceFlags) */
+		SPtr<GpuProgramCore> create(GpuProgramType type, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+
+	protected:
+		static const String LANGUAGE_NAME;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuBuffer.h

@@ -0,0 +1,54 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsGpuBuffer.h"
+
+namespace BansheeEngine 
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	DirectX 11 implementation of a generic GPU buffer. */
+	class VulkanGpuBufferCore : public GpuBufferCore
+    {
+    public:
+		~VulkanGpuBufferCore();
+
+		/** @copydoc GpuBufferCore::lock */
+		void* lock(UINT32 offset, UINT32 length, GpuLockOptions options) override;
+
+		/** @copydoc GpuBufferCore::unlock */
+		void unlock() override;
+
+		/** @copydoc GpuBufferCore::readData */
+		void readData(UINT32 offset, UINT32 length, void* pDest) override;
+
+		/** @copydoc GpuBufferCore::writeData */
+        void writeData(UINT32 offset, UINT32 length, const void* pSource,
+			BufferWriteType writeFlags = BufferWriteType::Normal) override;
+
+		/** @copydoc GpuBufferCore::copyData */
+		void copyData(GpuBufferCore& srcBuffer, UINT32 srcOffset, 
+			UINT32 dstOffset, UINT32 length, bool discardWholeBuffer = false) override;
+		
+	protected:
+		friend class VulkanHardwareBufferCoreManager;
+
+		VulkanGpuBufferCore(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
+
+		/** @copydoc GpuBufferCore::createView */
+		GpuBufferView* createView() override;
+
+		/** @copydoc GpuBufferCore::destroyView */
+		void destroyView(GpuBufferView* view) override;
+
+		/** @copydoc GpuBufferCore::initialize */
+		void initialize() override;
+	private:
+    };
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuParamBlockBuffer.h

@@ -0,0 +1,34 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsGpuParamBlockBuffer.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Vulkan implementation of a parameter block buffer (uniform buffer in Vulkan lingo). */
+	class VulkanGpuParamBlockBufferCore : public GpuParamBlockBufferCore
+	{
+	public:
+		VulkanGpuParamBlockBufferCore(UINT32 size, GpuParamBlockUsage usage, GpuDeviceFlags deviceMask);
+		~VulkanGpuParamBlockBufferCore();
+
+		/** @copydoc GpuParamBlockBufferCore::writeToGPU */
+		void writeToGPU(const UINT8* data) override;
+
+		/** @copydoc GpuParamBlockBufferCore::readFromGPU */
+		void readFromGPU(UINT8* data) const override;
+	protected:
+		/** @copydoc GpuParamBlockBufferCore::initialize */
+		void initialize() override;
+
+	private:
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanGpuProgram.h

@@ -0,0 +1,32 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsGpuProgram.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Abstraction of a Vulkan shader object. */
+	class VulkanGpuProgramCore : public GpuProgramCore
+	{
+	public:
+		virtual ~VulkanGpuProgramCore();
+
+	protected:
+		friend class VulkanGLSLProgramFactory;
+
+		VulkanGpuProgramCore(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask);
+
+		/** @copydoc GpuProgramCore::initialize */
+		void initialize() override;
+
+	private:
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanHardwareBuffer.h

@@ -0,0 +1,47 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsHardwareBuffer.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Class containing common functionality for all Vulkan hardware buffers. */
+	class VulkanHardwareBuffer : public HardwareBuffer
+	{
+	public:
+		VulkanHardwareBuffer(GpuBufferUsage usage, UINT32 elementCount, UINT32 elementSize, bool systemMemory = false, 
+			bool streamOut = false, bool randomGpuWrite = false, bool useCounter = false);
+		~VulkanHardwareBuffer();
+
+		/** @copydoc HardwareBuffer::readData */
+		void readData(UINT32 offset, UINT32 length, void* dest) override;
+
+		/** @copydoc HardwareBuffer::writeData */
+		void writeData(UINT32 offset, UINT32 length, const void* source, 
+			BufferWriteType writeFlags = BufferWriteType::Normal) override;
+
+		/** @copydoc HardwareBuffer::copyData */
+		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, UINT32 dstOffset, 
+			UINT32 length, bool discardWholeBuffer = false) override;
+
+	protected:
+		/** @copydoc HardwareBuffer::map */
+		void* map(UINT32 offset, UINT32 length, GpuLockOptions options) override;
+
+		/** @copydoc HardwareBuffer::unmap */
+		void unmap() override;
+
+		bool mRandomGpuWrite;
+		bool mUseCounter;
+		UINT32 mElementCount;
+		UINT32 mElementSize;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanHardwareBufferManager.h

@@ -0,0 +1,39 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsHardwareBufferManager.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Handles creation of Vulkan hardware buffers. */
+	class VulkanHardwareBufferCoreManager : public HardwareBufferCoreManager
+	{
+	public:
+		VulkanHardwareBufferCoreManager();
+
+	protected:     
+		/** @copydoc HardwareBufferCoreManager::createVertexBufferInternal */
+		SPtr<VertexBufferCore> createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc, 
+			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+
+		/** @copydoc HardwareBufferCoreManager::createIndexBufferInternal */
+		SPtr<IndexBufferCore> createIndexBufferInternal(const INDEX_BUFFER_DESC& desc, 
+			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+
+		/** @copydoc HardwareBufferCoreManager::createGpuParamBlockBufferInternal  */
+		SPtr<GpuParamBlockBufferCore> createGpuParamBlockBufferInternal(UINT32 size, 
+			GpuParamBlockUsage usage = GPBU_DYNAMIC, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+
+		/** @copydoc HardwareBufferCoreManager::createGpuBufferInternal */
+		SPtr<GpuBufferCore> createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
+			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanIndexBuffer.h

@@ -0,0 +1,45 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsIndexBuffer.h"
+#include "BsVulkanHardwareBuffer.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Vulkan implementation of an index buffer. */
+	class VulkanIndexBufferCore : public IndexBufferCore
+	{
+	public:
+		VulkanIndexBufferCore(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
+		~VulkanIndexBufferCore();
+
+		/** @copydoc IndexBufferCore::readData */
+		void readData(UINT32 offset, UINT32 length, void* dest) override;
+
+		/** @copydoc IndexBufferCore::writeData */
+		void writeData(UINT32 offset, UINT32 length, const void* source, 
+			BufferWriteType writeFlags = BufferWriteType::Normal) override;
+
+		/** @copydoc IndexBufferCore::copyData */
+		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, UINT32 dstOffset, UINT32 length, 
+			bool discardWholeBuffer = false) override;
+
+	protected:
+		/** @copydoc IndexBufferCore::map */
+		void* map(UINT32 offset, UINT32 length, GpuLockOptions options) override;
+
+		/** @copydoc IndexBufferCore::unmap */
+		void unmap() override;
+
+		/** @copydoc IndexBufferCore::initialize */
+		void initialize() override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanMappings.h

@@ -0,0 +1,14 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+	
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanOcclusionQuery.h

@@ -0,0 +1,38 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsOcclusionQuery.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** @copydoc OcclusionQuery */
+	class VulkanOcclusionQuery : public OcclusionQuery
+	{
+	public:
+		VulkanOcclusionQuery(bool binary, UINT32 deviceIdx);
+		~VulkanOcclusionQuery();
+
+		/** @copydoc OcclusionQuery::begin */
+		void begin() override;
+
+		/** @copydoc OcclusionQuery::end */
+		void end() override;
+
+		/** @copydoc OcclusionQuery::isReady */
+		bool isReady() const override;
+
+		/** @copydoc OcclusionQuery::getNumSamples */
+		UINT32 getNumSamples() override;
+
+	private:
+		friend class QueryManager;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanPrerequisites.h

@@ -0,0 +1,33 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsCorePrerequisites.h"
+
+#define WIN32_LEAN_AND_MEAN
+#if !defined(NOMINMAX) && defined(_MSC_VER)
+#	define NOMINMAX // Required to stop windows.h messing up std::min
+#endif
+
+#include "vulkan/vulkan.h"
+
+/** @addtogroup Plugins
+ *  @{
+ */
+
+/** @defgroup Vulkan BansheeVulkanRenderAPI
+ *	Wrapper around the Vulkan render API.
+ */
+
+/** @} */
+
+namespace BansheeEngine
+{
+	class VulkanRenderAPI;
+	class Win32RenderWindow;
+	class VulkanTexture;
+	class Win32VideoMode;
+	class VulkanIndexBuffer;
+	class VulkanVertexDeclaration;
+	class VulkanHardwareBuffer;
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanQueryManager.h

@@ -0,0 +1,29 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsQueryManager.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Handles creation of Vulkan queries. */
+	class VulkanQueryManager : public QueryManager
+	{
+	public:
+		/** @copydoc QueryManager::createEventQuery */
+		SPtr<EventQuery> createEventQuery(UINT32 deviceIdx = 0) const override;
+
+		/** @copydoc QueryManager::createTimerQuery */
+		SPtr<TimerQuery> createTimerQuery(UINT32 deviceIdx = 0) const override;
+
+		/** @copydoc QueryManager::createOcclusionQuery */
+		SPtr<OcclusionQuery> createOcclusionQuery(bool binary, UINT32 deviceIdx = 0) const override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderAPI.h

@@ -0,0 +1,130 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsRenderAPI.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** Implementation of a render system using Vulkan. Provides abstracted access to various low level Vulkan methods. */
+	class VulkanRenderAPI : public RenderAPICore
+	{
+	public:
+		VulkanRenderAPI();
+		~VulkanRenderAPI();
+
+		/** @copydoc RenderAPICore::getName */
+		const StringID& getName() const override;
+		
+		/** @copydoc RenderAPICore::getShadingLanguageName */
+		const String& getShadingLanguageName() const override;
+
+		/** @copydoc RenderAPICore::setGraphicsPipeline */
+		void setGraphicsPipeline(const SPtr<GpuPipelineStateCore>& pipelineState, 
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setComputePipeline */
+		void setComputePipeline(const SPtr<GpuProgramCore>& computeProgram,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setGpuParams */
+		void setGpuParams(const SPtr<GpuParamsCore>& gpuParams, 
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::beginFrame */
+		void beginFrame(const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::endFrame */
+		void endFrame(const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::clearRenderTarget */
+		void clearRenderTarget(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0, 
+			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::clearViewport */
+		void clearViewport(UINT32 buffers, const Color& color = Color::Black, float depth = 1.0f, UINT16 stencil = 0,
+			UINT8 targetMask = 0xFF, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setRenderTarget */
+		void setRenderTarget(const SPtr<RenderTargetCore>& target, bool readOnlyDepthStencil = false, 
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setViewport */
+		void setViewport(const Rect2& area, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setScissorRect */
+		void setScissorRect(UINT32 left, UINT32 top, UINT32 right, UINT32 bottom, 
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setStencilRef */
+		void setStencilRef(UINT32 value, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setVertexBuffers */
+		void setVertexBuffers(UINT32 index, SPtr<VertexBufferCore>* buffers, UINT32 numBuffers,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setIndexBuffer */
+		void setIndexBuffer(const SPtr<IndexBufferCore>& buffer, 
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setVertexDeclaration */
+		void setVertexDeclaration(const SPtr<VertexDeclarationCore>& vertexDeclaration,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::setDrawOperation */
+		void setDrawOperation(DrawOperationType op,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::draw */
+		void draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount = 0,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::drawIndexed */
+		void drawIndexed(UINT32 startIndex, UINT32 indexCount, UINT32 vertexOffset, UINT32 vertexCount, 
+			UINT32 instanceCount = 0, const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::dispatchCompute */
+		void dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY = 1, UINT32 numGroupsZ = 1,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::swapBuffers() */
+		void swapBuffers(const SPtr<RenderTargetCore>& target,
+			const SPtr<CommandBuffer>& commandBuffer = nullptr) override;
+
+		/** @copydoc RenderAPICore::addCommands() */
+		void addCommands(const SPtr<CommandBuffer>& commandBuffer, const SPtr<CommandBuffer>& secondary) override;
+
+		/** @copydoc RenderAPICore::executeCommands() */
+		void executeCommands(const SPtr<CommandBuffer>& commandBuffer) override;
+
+		/** @copydoc RenderAPICore::convertProjectionMatrix */
+		void convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest) override;
+
+		/** @copydoc RenderAPICore::getAPIInfo */
+		const RenderAPIInfo& getAPIInfo() const override;
+
+		/** @copydoc RenderAPICore::generateParamBlockDesc() */
+		GpuParamBlockDesc generateParamBlockDesc(const String& name, Vector<GpuParamDataDesc>& params) override;
+
+	protected:
+		friend class VulkanRenderAPIFactory;
+
+		/** @copydoc RenderAPICore::initializePrepare */
+		void initializePrepare() override;
+
+		/** @copydoc RenderAPICore::initializeFinalize */
+		void initializeFinalize(const SPtr<RenderWindowCore>& primaryWindow) override;
+
+		/** @copydoc RenderAPICore::destroyCore */
+		void destroyCore() override;
+
+	private:
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderAPIFactory.h

@@ -0,0 +1,48 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsRenderAPIFactory.h"
+#include "BsRenderAPIManager.h"
+#include "BsVulkanRenderAPI.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	extern const char* SystemName;
+
+	/**	Handles creation of the Vulkan render system. */
+	class VulkanRenderAPIFactory : public RenderAPIFactory
+	{
+	public:
+		/** @copydoc RenderAPIFactory::create */
+		void create() override;
+
+		/** @copydoc RenderAPIFactory::name */
+		const char* name() const override { return SystemName; }
+
+	private:
+
+		/**	Registers the factory with the render system manager when constructed. */
+		class InitOnStart
+		{
+		public:
+			InitOnStart() 
+			{ 
+				static SPtr<RenderAPIFactory> newFactory;
+				if(newFactory == nullptr)
+				{
+					newFactory = bs_shared_ptr_new<VulkanRenderAPIFactory>();
+					RenderAPIManager::instance().registerFactory(newFactory);
+				}
+			}
+		};
+
+		static InitOnStart initOnStart; // Makes sure factory is registered on program start
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderTexture.h

@@ -0,0 +1,60 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsTexture.h"
+#include "BsRenderTexture.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	class VulkanRenderTexture;
+
+	/**
+	 * Vulkan implementation of a render texture.
+	 *
+	 * @note	Core thread only.
+	 */
+	class VulkanRenderTextureCore : public RenderTextureCore
+	{
+	public:
+		VulkanRenderTextureCore(const RENDER_TEXTURE_DESC_CORE& desc, GpuDeviceFlags deviceMask);
+		virtual ~VulkanRenderTextureCore() { }
+
+		/** @copydoc RenderTextureCore::getCustomAttribute */
+		void getCustomAttribute(const String& name, void* data) const override;
+
+	protected:
+		/** @copydoc RenderTextureCore::getProperties */
+		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
+
+		RenderTextureProperties mProperties;
+	};
+
+	/**
+	 * Vulkan implementation of a render texture.
+	 *
+	 * @note	Sim thread only.
+	 */
+	class VulkanRenderTexture : public RenderTexture
+	{
+	public:
+		virtual ~VulkanRenderTexture() { }
+
+	protected:
+		friend class VulkanTextureManager;
+
+		VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc);
+
+		/** @copydoc RenderTexture::getProperties */
+		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
+
+		RenderTextureProperties mProperties;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanRenderWindowManager.h

@@ -0,0 +1,37 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsRenderWindowManager.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** @copydoc RenderWindowManager */
+	class VulkanRenderWindowManager : public RenderWindowManager
+	{
+	public:
+		VulkanRenderWindowManager();
+
+	protected:
+		/** @copydoc RenderWindowManager::createImpl */
+		SPtr<RenderWindow> createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const SPtr<RenderWindow>& parentWindow) override;
+	};
+
+	/** @copydoc RenderWindowCoreManager */
+	class VulkanRenderWindowCoreManager : public RenderWindowCoreManager
+	{
+	public:
+		VulkanRenderWindowCoreManager();
+
+	protected:
+		/** @copydoc RenderWindowCoreManager::createInternal */
+		SPtr<RenderWindowCore> createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId) override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanTexture.h

@@ -0,0 +1,47 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsTexture.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Vulkan implementation of a texture. */
+	class VulkanTextureCore : public TextureCore
+	{
+	public:
+		~VulkanTextureCore();
+
+	protected:
+		friend class VulkanTextureCoreManager;
+
+		VulkanTextureCore(const TEXTURE_DESC& desc, const SPtr<PixelData>& initialData, GpuDeviceFlags deviceMask);
+
+		/** @copydoc CoreObjectCore::initialize() */
+		void initialize() override;
+
+		/** @copydoc TextureCore::lockImpl */
+		PixelData lockImpl(GpuLockOptions options, UINT32 mipLevel = 0, UINT32 face = 0) override;
+
+		/** @copydoc TextureCore::unlockImpl */
+		void unlockImpl() override;
+
+		/** @copydoc TextureCore::copyImpl */
+		void copyImpl(UINT32 srcFace, UINT32 srcMipLevel, UINT32 destFace, UINT32 destMipLevel, const SPtr<TextureCore>& target) override;
+
+		/** @copydoc TextureCore::readData */
+		void readData(PixelData& dest, UINT32 mipLevel = 0, UINT32 face = 0) override;
+
+		/** @copydoc TextureCore::writeData */
+		void writeData(const PixelData& src, UINT32 mipLevel = 0, UINT32 face = 0, bool discardWholeBuffer = false) override;
+
+	protected:
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanTextureManager.h

@@ -0,0 +1,40 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsTextureManager.h"
+
+namespace BansheeEngine 
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Handles creation of Vulkan textures. */
+	class VulkanTextureManager : public TextureManager
+	{
+	public:
+		/** @copydoc TextureManager::getNativeFormat */
+		PixelFormat getNativeFormat(TextureType ttype, PixelFormat format, int usage, bool hwGamma) override;
+
+	protected:		
+		/** @copydoc TextureManager::createRenderTextureImpl */
+		SPtr<RenderTexture> createRenderTextureImpl(const RENDER_TEXTURE_DESC& desc) override;
+	};
+
+	/**	Handles creation of Vulkan textures. */
+	class VulkanTextureCoreManager : public TextureCoreManager
+	{
+	protected:
+		/** @copydoc TextureCoreManager::createTextureInternal */
+		SPtr<TextureCore> createTextureInternal(const TEXTURE_DESC& desc, 
+			const SPtr<PixelData>& initialData = nullptr, GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+
+		/** @copydoc TextureCoreManager::createRenderTextureInternal */
+		SPtr<RenderTextureCore> createRenderTextureInternal(const RENDER_TEXTURE_DESC_CORE& desc, 
+			GpuDeviceFlags deviceMask = GDF_DEFAULT) override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanTimerQuery.h

@@ -0,0 +1,37 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsTimerQuery.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** @copydoc TimerQuery */
+	class VulkanTimerQuery : public TimerQuery
+	{
+	public:
+		VulkanTimerQuery(UINT32 deviceIdx);
+		~VulkanTimerQuery();
+
+		/** @copydoc TimerQuery::begin */
+		void begin() override;
+
+		/** @copydoc TimerQuery::end */
+		void end() override;
+
+		/** @copydoc TimerQuery::isReady */
+		bool isReady() const override;
+
+		/** @copydoc TimerQuery::getTimeMs */
+		float getTimeMs() override;
+
+	private:
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/BsVulkanVertexBuffer.h

@@ -0,0 +1,44 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsVertexBuffer.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/**	Vulkan implementation of a vertex buffer. */
+	class VulkanVertexBufferCore : public VertexBufferCore
+	{
+	public:
+		VulkanVertexBufferCore(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask);
+		~VulkanVertexBufferCore();
+
+		/** @copydoc VertexBufferCore::readData */
+		void readData(UINT32 offset, UINT32 length, void* dest) override;
+
+		/** @copydoc VertexBufferCore::writeData */
+		void writeData(UINT32 offset, UINT32 length, const void* source, 
+			BufferWriteType writeFlags = BufferWriteType::Normal) override;
+
+		/** @copydoc VertexBufferCore::copyData */
+		void copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset, UINT32 dstOffset, UINT32 length, 
+			bool discardWholeBuffer = false) override;
+
+	protected: 
+		/** @copydoc VertexBufferCore::map */
+		void* map(UINT32 offset, UINT32 length, GpuLockOptions options) override;
+
+		/** @copydoc VertexBufferCore::unmap */
+		void unmap(void) override;
+
+		/** @copydoc VertexBufferCore::initialize */
+		void initialize() override;
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Include/Win32/BsWin32RenderWindow.h

@@ -0,0 +1,153 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsRenderWindow.h"
+#include <windows.h>
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	class Win32RenderWindow;
+
+	/**	Contains various properties that describe a render window. */
+	class Win32RenderWindowProperties : public RenderWindowProperties
+	{
+	public:
+		Win32RenderWindowProperties(const RENDER_WINDOW_DESC& desc);
+		virtual ~Win32RenderWindowProperties() { }
+
+	private:
+		friend class Win32RenderWindowCore;
+		friend class Win32RenderWindow;
+	};
+
+	/**
+	 * Render window implementation for Windows and Vulkan.
+	 *
+	 * @note	Core thread only.
+	 */
+	class Win32RenderWindowCore : public RenderWindowCore
+	{
+	public:
+		Win32RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId);
+		~Win32RenderWindowCore();
+
+		/** @copydoc RenderWindowCore::move */
+		void move(INT32 left, INT32 top) override;
+
+		/** @copydoc RenderWindowCore::resize */
+		void resize(UINT32 width, UINT32 height) override;
+
+		/** @copydoc RenderWindowCore::setHidden */
+		void setHidden(bool hidden) override;
+
+		/** @copydoc RenderWindowCore::setActive */
+		void setActive(bool state) override;
+
+		/** @copydoc RenderWindowCore::minimize */
+		void minimize() override;
+
+		/** @copydoc RenderWindowCore::maximize */
+		void maximize() override;
+
+		/** @copydoc RenderWindowCore::restore */
+		void restore() override;
+
+		/** @copydoc RenderWindowCore::setFullscreen(UINT32, UINT32, float, UINT32) */
+		void setFullscreen(UINT32 width, UINT32 height, float refreshRate = 60.0f, UINT32 monitorIdx = 0) override;
+
+		/** @copydoc RenderWindowCore::setFullscreen(const VideoMode&) */
+		void setFullscreen(const VideoMode& videoMode) override;
+
+		/** @copydoc RenderWindowCore::setWindowed */
+		void setWindowed(UINT32 width, UINT32 height) override;
+
+		/** 
+		 * Copies the contents of a frame buffer into the pre-allocated buffer. 
+		 *
+		 * @param[out]	dst		Previously allocated buffer to read the contents into. Must be of valid size.
+		 * @param[in]	buffer	Frame buffer to read the contents from.
+		 */
+		void copyToMemory(PixelData &dst, FrameBuffer buffer);
+
+		/** @copydoc RenderWindowCore::swapBuffers */
+		void swapBuffers() override;
+
+		/** @copydoc RenderWindowCore::getCustomAttribute */
+		void getCustomAttribute(const String& name, void* pData) const override;
+
+		/** @copydoc RenderWindowCore::_windowMovedOrResized */
+		void _windowMovedOrResized() override;
+
+		/**	Returns internal window handle. */
+		HWND _getWindowHandle() const;
+	protected:
+		friend class Win32RenderWindow;
+
+		/** @copydoc CoreObjectCore::initialize */
+		void initialize() override;
+
+		/** @copydoc RenderWindowCore::getProperties */
+		const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
+
+		/** @copydoc RenderWindowCore::getSyncedProperties */
+		RenderWindowProperties& getSyncedProperties() override { return mSyncedProperties; }
+
+		/** @copydoc RenderWindowCore::syncProperties */
+		void syncProperties() override;
+
+	protected:
+		Win32Window* mWindow;
+
+		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/Include/Win32/BsWin32VideoModeInfo.h

@@ -0,0 +1,40 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsVulkanPrerequisites.h"
+#include "BsVideoModeInfo.h"
+
+namespace BansheeEngine
+{
+	/** @addtogroup Vulkan
+	 *  @{
+	 */
+
+	/** @copydoc VideoMode */
+	class Win32VideoMode : public VideoMode
+	{
+	public:
+		Win32VideoMode(UINT32 width, UINT32 height, float refreshRate, UINT32 outputIdx);
+
+	private:
+		friend class VulkanVideoOutputInfo;
+	};
+
+	/** @copydoc VideoOutputInfo */
+	class Win32VideoOutputInfo : public VideoOutputInfo
+	{
+	public:
+		Win32VideoOutputInfo(UINT32 outputIdx);
+		~Win32VideoOutputInfo();
+	};
+
+	/** @copydoc VideoModeInfo */
+	class Win32VideoModeInfo : public VideoModeInfo
+	{
+	public:
+		Win32VideoModeInfo();
+	};
+
+	/** @} */
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanCommandBuffer.cpp

@@ -0,0 +1,10 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanCommandBuffer.h"
+
+namespace BansheeEngine
+{
+	VulkanCommandBuffer::VulkanCommandBuffer(CommandBufferType type, UINT32 deviceIdx, UINT32 syncMask, bool secondary)
+		: CommandBuffer(type, syncMask, secondary)
+	{ }
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanCommandBufferManager.cpp

@@ -0,0 +1,16 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanCommandBufferManager.h"
+#include "BsVulkanCommandBuffer.h"
+
+namespace BansheeEngine
+{
+	SPtr<CommandBuffer> VulkanCommandBufferManager::create(CommandBufferType type, UINT32 deviceIdx, UINT32 syncMask,
+		bool secondary)
+	{
+		CommandBuffer* buffer = 
+			new (bs_alloc<VulkanCommandBuffer>()) VulkanCommandBuffer(type, deviceIdx, syncMask, secondary);
+
+		return bs_shared_ptr(buffer);
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanEventQuery.cpp

@@ -0,0 +1,29 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanEventQuery.h"
+#include "BsVulkanRenderAPI.h"
+#include "BsRenderStats.h"
+#include "BsException.h"
+
+namespace BansheeEngine
+{
+	VulkanEventQuery::VulkanEventQuery(UINT32 deviceIdx)
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
+	}
+
+	VulkanEventQuery::~VulkanEventQuery()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
+	}
+
+	void VulkanEventQuery::begin()
+	{
+		setActive(true);
+	}
+
+	bool VulkanEventQuery::isReady() const
+	{
+		return false;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanGLSLProgramFactory.cpp

@@ -0,0 +1,35 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanGLSLProgramFactory.h"
+#include "BsVulkanGpuProgram.h"
+
+namespace BansheeEngine
+{
+    const String VulkanGLSLProgramFactory::LANGUAGE_NAME = "glsl";
+
+    const String& VulkanGLSLProgramFactory::getLanguage(void) const
+    {
+        return LANGUAGE_NAME;
+    }
+
+	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));
+		gpuProg->_setThisPtr(gpuProg);
+
+		return gpuProg;
+    }
+
+	SPtr<GpuProgramCore> VulkanGLSLProgramFactory::create(GpuProgramType type, GpuDeviceFlags deviceMask)
+	{
+		GPU_PROGRAM_DESC desc;
+		desc.type = type;
+
+		SPtr<GpuProgramCore> gpuProg = bs_shared_ptr<VulkanGpuProgramCore>(new (bs_alloc<VulkanGpuProgramCore>())
+			VulkanGpuProgramCore(desc, deviceMask));
+		gpuProg->_setThisPtr(gpuProg);
+
+		return gpuProg;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuBuffer.cpp

@@ -0,0 +1,79 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanGpuBuffer.h"
+#include "BsRenderStats.h"
+#include "BsException.h"
+
+namespace BansheeEngine
+{
+	VulkanGpuBufferCore::VulkanGpuBufferCore(const GPU_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+		: GpuBufferCore(desc, deviceMask)
+	{
+		if (desc.type != GBT_STANDARD)
+			assert(desc.format == BF_UNKNOWN && "Format must be set to BF_UNKNOWN when using non-standard buffers");
+		else
+			assert(desc.elementSize == 0 && "No element size can be provided for standard buffer. Size is determined from format.");
+	}
+
+	VulkanGpuBufferCore::~VulkanGpuBufferCore()
+	{ 
+		clearBufferViews();
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuBuffer);
+	}
+
+	void VulkanGpuBufferCore::initialize()
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuBuffer);
+
+		GpuBufferCore::initialize();
+	}
+
+	void* VulkanGpuBufferCore::lock(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+#if BS_PROFILING_ENABLED
+		if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
+		{
+			BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_GpuBuffer);
+		}
+
+		if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD || options == GBL_WRITE_ONLY_NO_OVERWRITE)
+		{
+			BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_GpuBuffer);
+		}
+#endif
+
+		return nullptr;;
+	}
+
+	void VulkanGpuBufferCore::unlock()
+	{
+		
+	}
+
+	void VulkanGpuBufferCore::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_GpuBuffer);
+	}
+
+	void VulkanGpuBufferCore::writeData(UINT32 offset, UINT32 length, const void* pSource, BufferWriteType writeFlags)
+	{
+		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_GpuBuffer);
+	}
+
+	void VulkanGpuBufferCore::copyData(GpuBufferCore& srcBuffer, UINT32 srcOffset,
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+
+	}
+
+	GpuBufferView* VulkanGpuBufferCore::createView()
+	{
+		// Not used
+		return nullptr;
+	}
+
+	void VulkanGpuBufferCore::destroyView(GpuBufferView* view)
+	{
+		// Not used
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuParamBlockBuffer.cpp

@@ -0,0 +1,34 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanGpuParamBlockBuffer.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanGpuParamBlockBufferCore::VulkanGpuParamBlockBufferCore(UINT32 size, GpuParamBlockUsage usage,
+		GpuDeviceFlags deviceMask)
+		:GpuParamBlockBufferCore(size, usage, deviceMask)
+	{ }
+
+	VulkanGpuParamBlockBufferCore::~VulkanGpuParamBlockBufferCore()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuParamBuffer);
+	}
+
+	void VulkanGpuParamBlockBufferCore::initialize()
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuParamBuffer);
+
+		GpuParamBlockBufferCore::initialize();
+	}
+
+	void VulkanGpuParamBlockBufferCore::writeToGPU(const UINT8* data)
+	{
+		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_GpuParamBuffer);
+	}
+
+	void VulkanGpuParamBlockBufferCore::readFromGPU(UINT8* data) const
+	{
+		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_GpuParamBuffer);
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanGpuProgram.cpp

@@ -0,0 +1,37 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanGpuProgram.h"
+#include "BsGpuParams.h"
+#include "BsVulkanRenderAPI.h"
+#include "BsGpuProgramManager.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanGpuProgramCore::VulkanGpuProgramCore(const GPU_PROGRAM_DESC& desc, GpuDeviceFlags deviceMask)
+		: GpuProgramCore(desc, deviceMask)
+	{
+
+	}
+
+	VulkanGpuProgramCore::~VulkanGpuProgramCore()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_GpuProgram);
+	}
+
+	void VulkanGpuProgramCore::initialize()
+	{
+		if (!isSupported())
+		{
+			mIsCompiled = false;
+			mCompileError = "Specified program is not supported by the current render system.";
+
+			GpuProgramCore::initialize();
+			return;
+		}
+		
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_GpuProgram);
+
+		GpuProgramCore::initialize();
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanHardwareBuffer.cpp

@@ -0,0 +1,49 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanHardwareBuffer.h"
+#include "BsException.h"
+
+namespace BansheeEngine
+{
+	VulkanHardwareBuffer::VulkanHardwareBuffer(GpuBufferUsage usage, UINT32 elementCount, UINT32 elementSize,
+		bool useSystemMem, bool streamOut, bool randomGpuWrite, bool useCounter)
+		: HardwareBuffer(usage, useSystemMem), mElementCount(elementCount), mElementSize(elementSize)
+		, mRandomGpuWrite(randomGpuWrite), mUseCounter(useCounter)
+	{
+		
+	}
+
+	VulkanHardwareBuffer::~VulkanHardwareBuffer()
+	{
+
+	}
+
+	void* VulkanHardwareBuffer::map(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+		if (length > mSizeInBytes)
+			BS_EXCEPT(RenderingAPIException, "Provided length " + toString(length) + " larger than the buffer " + toString(mSizeInBytes) + ".");		
+
+		return nullptr;
+	}
+
+	void VulkanHardwareBuffer::unmap()
+	{
+
+	}
+
+	void VulkanHardwareBuffer::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+
+	}
+
+	void VulkanHardwareBuffer::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+		
+	}
+
+	void VulkanHardwareBuffer::writeData(UINT32 offset, UINT32 length, const void* pSource, BufferWriteType writeFlags)
+	{
+		
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanHardwareBufferManager.cpp

@@ -0,0 +1,55 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanHardwareBufferManager.h"
+#include "BsVulkanVertexBuffer.h"
+#include "BsVulkanIndexBuffer.h"
+#include "BsVulkanGpuBuffer.h"
+#include "BsVulkanGpuParamBlockBuffer.h"
+#include "BsGpuParamDesc.h"
+
+namespace BansheeEngine
+{
+	VulkanHardwareBufferCoreManager::VulkanHardwareBufferCoreManager()
+	{ }
+
+	SPtr<VertexBufferCore> VulkanHardwareBufferCoreManager::createVertexBufferInternal(const VERTEX_BUFFER_DESC& desc,
+		GpuDeviceFlags deviceMask)
+	{
+		SPtr<VulkanVertexBufferCore> ret = bs_shared_ptr_new<VulkanVertexBufferCore>(desc, deviceMask);
+		ret->_setThisPtr(ret);
+
+		return ret;
+	}
+
+	SPtr<IndexBufferCore> VulkanHardwareBufferCoreManager::createIndexBufferInternal(const INDEX_BUFFER_DESC& desc,
+		GpuDeviceFlags deviceMask)
+	{
+		SPtr<VulkanIndexBufferCore> ret = bs_shared_ptr_new<VulkanIndexBufferCore>( desc, deviceMask);
+		ret->_setThisPtr(ret);
+
+		return ret;
+	}
+
+	SPtr<GpuParamBlockBufferCore> VulkanHardwareBufferCoreManager::createGpuParamBlockBufferInternal(UINT32 size,
+		GpuParamBlockUsage usage, GpuDeviceFlags deviceMask)
+	{
+		VulkanGpuParamBlockBufferCore* paramBlockBuffer =
+			new (bs_alloc<VulkanGpuParamBlockBufferCore>()) VulkanGpuParamBlockBufferCore(size, usage, deviceMask);
+
+		SPtr<GpuParamBlockBufferCore> paramBlockBufferPtr = bs_shared_ptr<VulkanGpuParamBlockBufferCore>(paramBlockBuffer);
+		paramBlockBufferPtr->_setThisPtr(paramBlockBufferPtr);
+
+		return paramBlockBufferPtr;
+	}
+
+	SPtr<GpuBufferCore> VulkanHardwareBufferCoreManager::createGpuBufferInternal(const GPU_BUFFER_DESC& desc,
+		GpuDeviceFlags deviceMask)
+	{
+		VulkanGpuBufferCore* buffer = new (bs_alloc<VulkanGpuBufferCore>()) VulkanGpuBufferCore(desc, deviceMask);
+
+		SPtr<VulkanGpuBufferCore> bufferPtr = bs_shared_ptr<VulkanGpuBufferCore>(buffer);
+		bufferPtr->_setThisPtr(bufferPtr);
+
+		return bufferPtr;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanIndexBuffer.cpp

@@ -0,0 +1,63 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanIndexBuffer.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanIndexBufferCore::VulkanIndexBufferCore(const INDEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+		:IndexBufferCore(desc, deviceMask)
+	{
+		
+	}
+
+	VulkanIndexBufferCore::~VulkanIndexBufferCore()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_IndexBuffer);
+	}
+
+	void VulkanIndexBufferCore::initialize()
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_IndexBuffer);
+		IndexBufferCore::initialize();
+	}
+
+	void* VulkanIndexBufferCore::map(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+#if BS_PROFILING_ENABLED
+		if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
+		{
+			BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_IndexBuffer);
+		}
+
+		if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD 
+			|| options == GBL_WRITE_ONLY_NO_OVERWRITE)
+		{
+			BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_IndexBuffer);
+		}
+#endif
+
+		return nullptr;
+	}
+
+	void VulkanIndexBufferCore::unmap()
+	{
+
+	}
+
+	void VulkanIndexBufferCore::readData(UINT32 offset, UINT32 length, void* pDest)
+	{
+		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_IndexBuffer);
+	}
+
+	void VulkanIndexBufferCore::writeData(UINT32 offset, UINT32 length, const void* pSource, BufferWriteType writeFlags)
+	{
+		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_IndexBuffer);
+	}
+
+	void VulkanIndexBufferCore::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanMappings.cpp

@@ -0,0 +1,8 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanMappings.h"
+
+namespace BansheeEngine
+{
+	
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanOcclusionQuery.cpp

@@ -0,0 +1,38 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanOcclusionQuery.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanOcclusionQuery::VulkanOcclusionQuery(bool binary, UINT32 deviceIdx)
+		:OcclusionQuery(binary)
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
+	}
+
+	VulkanOcclusionQuery::~VulkanOcclusionQuery()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
+	}
+
+	void VulkanOcclusionQuery::begin()
+	{
+		setActive(true);
+	}
+
+	void VulkanOcclusionQuery::end()
+	{
+
+	}
+
+	bool VulkanOcclusionQuery::isReady() const
+	{
+		return false;
+	}
+
+	UINT32 VulkanOcclusionQuery::getNumSamples()
+	{
+		return 0;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanPlugin.cpp

@@ -0,0 +1,12 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanPrerequisites.h"
+#include "BsVulkanRenderAPIFactory.h"
+
+namespace BansheeEngine
+{
+	extern "C" const char* getPluginName()
+	{
+		return SystemName;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanQueryManager.cpp

@@ -0,0 +1,36 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanQueryManager.h"
+#include "BsVulkanEventQuery.h"
+#include "BsVulkanTimerQuery.h"
+#include "BsVulkanOcclusionQuery.h"
+
+namespace BansheeEngine
+{
+	SPtr<EventQuery> VulkanQueryManager::createEventQuery(UINT32 deviceIdx) const
+	{
+		SPtr<EventQuery> query = SPtr<VulkanEventQuery>(bs_new<VulkanEventQuery>(deviceIdx), 
+			&QueryManager::deleteEventQuery, StdAlloc<VulkanEventQuery>());
+		mEventQueries.push_back(query.get());
+
+		return query;
+	}
+
+	SPtr<TimerQuery> VulkanQueryManager::createTimerQuery(UINT32 deviceIdx) const
+	{
+		SPtr<TimerQuery> query = SPtr<VulkanTimerQuery>(bs_new<VulkanTimerQuery>(deviceIdx), 
+			&QueryManager::deleteTimerQuery, StdAlloc<VulkanTimerQuery>());
+		mTimerQueries.push_back(query.get());
+
+		return query;
+	}
+
+	SPtr<OcclusionQuery> VulkanQueryManager::createOcclusionQuery(bool binary, UINT32 deviceIdx) const
+	{
+		SPtr<OcclusionQuery> query = SPtr<VulkanOcclusionQuery>(bs_new<VulkanOcclusionQuery>(binary, deviceIdx),
+			&QueryManager::deleteOcclusionQuery, StdAlloc<VulkanOcclusionQuery>());
+		mOcclusionQueries.push_back(query.get());
+
+		return query;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderAPI.cpp

@@ -0,0 +1,191 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanRenderAPI.h"
+#include "BsCoreThread.h"
+#include "BsRenderStats.h"
+#include "BsGpuParamDesc.h"
+
+namespace BansheeEngine
+{
+	VulkanRenderAPI::VulkanRenderAPI()
+	{ }
+
+	VulkanRenderAPI::~VulkanRenderAPI()
+	{
+
+	}
+
+	const StringID& VulkanRenderAPI::getName() const
+	{
+		static StringID strName("VulkanRenderAPI");
+		return strName;
+	}
+
+	const String& VulkanRenderAPI::getShadingLanguageName() const
+	{
+		static String strName("glsl");
+		return strName;
+	}
+
+	void VulkanRenderAPI::initializePrepare()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		RenderAPICore::initializePrepare();
+	}
+
+	void VulkanRenderAPI::initializeFinalize(const SPtr<RenderWindowCore>& primaryWindow)
+	{
+		RenderAPICore::initializeFinalize(primaryWindow);
+	}
+
+    void VulkanRenderAPI::destroyCore()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		RenderAPICore::destroyCore();
+	}
+
+	void VulkanRenderAPI::setGraphicsPipeline(const SPtr<GpuPipelineStateCore>& pipelineState,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumPipelineStateChanges);
+	}
+
+	void VulkanRenderAPI::setComputePipeline(const SPtr<GpuProgramCore>& computeProgram,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumPipelineStateChanges);
+	}
+
+	void VulkanRenderAPI::setGpuParams(const SPtr<GpuParamsCore>& gpuParams, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumGpuParamBinds);
+	}
+
+	void VulkanRenderAPI::beginFrame(const SPtr<CommandBuffer>& commandBuffer)
+	{
+
+	}
+
+	void VulkanRenderAPI::endFrame(const SPtr<CommandBuffer>& commandBuffer)
+	{
+
+	}
+
+	void VulkanRenderAPI::setViewport(const Rect2& vp, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		
+	}
+
+	void VulkanRenderAPI::setVertexBuffers(UINT32 index, SPtr<VertexBufferCore>* buffers, UINT32 numBuffers,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumVertexBufferBinds);
+	}
+
+	void VulkanRenderAPI::setIndexBuffer(const SPtr<IndexBufferCore>& buffer, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumIndexBufferBinds);
+	}
+
+	void VulkanRenderAPI::setVertexDeclaration(const SPtr<VertexDeclarationCore>& vertexDeclaration,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		
+	}
+
+	void VulkanRenderAPI::setDrawOperation(DrawOperationType op, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		
+	}
+
+	void VulkanRenderAPI::draw(UINT32 vertexOffset, UINT32 vertexCount, UINT32 instanceCount,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		UINT32 primCount = 0;
+
+		BS_INC_RENDER_STAT(NumDrawCalls);
+		BS_ADD_RENDER_STAT(NumVertices, vertexCount);
+		BS_ADD_RENDER_STAT(NumPrimitives, primCount);
+	}
+
+	void VulkanRenderAPI::drawIndexed(UINT32 startIndex, UINT32 indexCount, UINT32 vertexOffset, UINT32 vertexCount,
+		UINT32 instanceCount, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		UINT32 primCount = 0;
+
+		BS_INC_RENDER_STAT(NumDrawCalls);
+		BS_ADD_RENDER_STAT(NumVertices, vertexCount);
+		BS_ADD_RENDER_STAT(NumPrimitives, primCount);
+	}
+
+	void VulkanRenderAPI::dispatchCompute(UINT32 numGroupsX, UINT32 numGroupsY, UINT32 numGroupsZ,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumComputeCalls);
+	}
+
+	void VulkanRenderAPI::setScissorRect(UINT32 left, UINT32 top, UINT32 right, UINT32 bottom,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		
+	}
+
+	void VulkanRenderAPI::setStencilRef(UINT32 value, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		
+	}
+
+	void VulkanRenderAPI::clearViewport(UINT32 buffers, const Color& color, float depth, UINT16 stencil, UINT8 targetMask,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumClears);
+	}
+
+	void VulkanRenderAPI::clearRenderTarget(UINT32 buffers, const Color& color, float depth, UINT16 stencil,
+		UINT8 targetMask, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumClears);
+	}
+
+	void VulkanRenderAPI::setRenderTarget(const SPtr<RenderTargetCore>& target, bool readOnlyDepthStencil,
+		const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumRenderTargetChanges);
+	}
+
+	void VulkanRenderAPI::swapBuffers(const SPtr<RenderTargetCore>& target, const SPtr<CommandBuffer>& commandBuffer)
+	{
+		BS_INC_RENDER_STAT(NumPresents);
+	}
+
+	void VulkanRenderAPI::addCommands(const SPtr<CommandBuffer>& commandBuffer, const SPtr<CommandBuffer>& secondary)
+	{
+
+	}
+
+	void VulkanRenderAPI::executeCommands(const SPtr<CommandBuffer>& commandBuffer)
+	{
+
+	}
+	
+	void VulkanRenderAPI::convertProjectionMatrix(const Matrix4& matrix, Matrix4& dest)
+	{
+
+	}
+
+	const RenderAPIInfo& VulkanRenderAPI::getAPIInfo() const
+	{
+		static RenderAPIInfo info(0.0f, 0.0f, 0.0f, 1.0f, VET_COLOR_ABGR, false, true, false, false);
+
+		return info;
+	}
+
+	GpuParamBlockDesc VulkanRenderAPI::generateParamBlockDesc(const String& name, Vector<GpuParamDataDesc>& params)
+	{
+		GpuParamBlockDesc block;
+		
+		return block;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderAPIFactory.cpp

@@ -0,0 +1,16 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanRenderAPIFactory.h"
+#include "BsRenderAPI.h"
+
+namespace BansheeEngine
+{
+	const char* SystemName = "BansheeVulkanRenderAPI";
+
+	void VulkanRenderAPIFactory::create()
+	{
+		RenderAPICore::startUp<VulkanRenderAPI>();
+	}
+
+	VulkanRenderAPIFactory::InitOnStart VulkanRenderAPIFactory::initOnStart;
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderTexture.cpp

@@ -0,0 +1,23 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanRenderTexture.h"
+
+namespace BansheeEngine
+{
+	VulkanRenderTextureCore::VulkanRenderTextureCore(const RENDER_TEXTURE_DESC_CORE& desc, GpuDeviceFlags deviceMask)
+		:RenderTextureCore(desc, deviceMask), mProperties(desc, false)
+	{
+		
+	}
+
+	void VulkanRenderTextureCore::getCustomAttribute(const String& name, void* data) const
+	{
+		
+	}
+
+	VulkanRenderTexture::VulkanRenderTexture(const RENDER_TEXTURE_DESC& desc)
+		:RenderTexture(desc), mProperties(desc, false)
+	{ 
+
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanRenderWindowManager.cpp

@@ -0,0 +1,41 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanRenderWindowManager.h"
+#include "Win32/BsWin32RenderWindow.h"
+
+namespace BansheeEngine
+{
+	VulkanRenderWindowManager::VulkanRenderWindowManager()
+	{ }
+
+	SPtr<RenderWindow> VulkanRenderWindowManager::createImpl(RENDER_WINDOW_DESC& desc, UINT32 windowId, const SPtr<RenderWindow>& parentWindow)
+	{
+		if(parentWindow != nullptr)
+		{
+			UINT64 hWnd;
+			parentWindow->getCustomAttribute("WINDOW", &hWnd);
+			desc.platformSpecific["parentWindowHandle"] = toString(hWnd);
+		}
+
+		// Create the window
+		Win32RenderWindow* renderWindow = new (bs_alloc<Win32RenderWindow>()) Win32RenderWindow(desc, windowId);
+		return bs_core_ptr<Win32RenderWindow>(renderWindow);
+	}
+
+	VulkanRenderWindowCoreManager::VulkanRenderWindowCoreManager()
+	{ }
+
+	SPtr<RenderWindowCore> VulkanRenderWindowCoreManager::createInternal(RENDER_WINDOW_DESC& desc, UINT32 windowId)
+	{
+		// Create the window
+		Win32RenderWindowCore* renderWindow =
+			new (bs_alloc<Win32RenderWindowCore>()) Win32RenderWindowCore(desc, windowId);
+
+		SPtr<Win32RenderWindowCore> renderWindowPtr = bs_shared_ptr<Win32RenderWindowCore>(renderWindow);
+		renderWindowPtr->_setThisPtr(renderWindowPtr);
+
+		windowCreated(renderWindow);
+
+		return renderWindowPtr;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanTexture.cpp

@@ -0,0 +1,59 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanTexture.h"
+#include "BsCoreThread.h"
+#include "BsException.h"
+#include "BsAsyncOp.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanTextureCore::VulkanTextureCore(const TEXTURE_DESC& desc, const SPtr<PixelData>& initialData,
+		GpuDeviceFlags deviceMask)
+		: TextureCore(desc, initialData, deviceMask)
+	{
+		
+	}
+
+	VulkanTextureCore::~VulkanTextureCore()
+	{ 
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Texture);
+	}
+
+	void VulkanTextureCore::initialize()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Texture);
+		TextureCore::initialize();
+	}
+
+	void VulkanTextureCore::copyImpl(UINT32 srcFace, UINT32 srcMipLevel, UINT32 destFace, UINT32 destMipLevel, const SPtr<TextureCore>& target)
+	{
+		
+	}
+
+	PixelData VulkanTextureCore::lockImpl(GpuLockOptions options, UINT32 mipLevel, UINT32 face)
+	{
+		PixelData lockedArea(1, 1, 1, mProperties.getFormat());
+	
+		// TODO - Increment read/write stat (do this for other buffers as well)
+
+		return lockedArea;
+	}
+
+	void VulkanTextureCore::unlockImpl()
+	{
+		
+	}
+
+	void VulkanTextureCore::readData(PixelData& dest, UINT32 mipLevel, UINT32 face)
+	{
+		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_GpuBuffer);
+	}
+
+	void VulkanTextureCore::writeData(const PixelData& src, UINT32 mipLevel, UINT32 face, bool discardWholeBuffer)
+	{
+		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_Texture);
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanTextureManager.cpp

@@ -0,0 +1,40 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanTextureManager.h"
+#include "BsVulkanTexture.h"
+#include "BsVulkanRenderTexture.h"
+
+namespace BansheeEngine
+{
+	SPtr<RenderTexture> VulkanTextureManager::createRenderTextureImpl(const RENDER_TEXTURE_DESC& desc)
+	{
+		VulkanRenderTexture* tex = new (bs_alloc<VulkanRenderTexture>()) VulkanRenderTexture(desc);
+
+		return bs_core_ptr<VulkanRenderTexture>(tex);
+	}
+
+	PixelFormat VulkanTextureManager::getNativeFormat(TextureType ttype, PixelFormat format, int usage, bool hwGamma)
+	{
+		return PF_R8G8B8A8;;
+	}
+
+	SPtr<TextureCore> VulkanTextureCoreManager::createTextureInternal(const TEXTURE_DESC& desc,
+		const SPtr<PixelData>& initialData, GpuDeviceFlags deviceMask)
+	{
+		VulkanTextureCore* tex = new (bs_alloc<VulkanTextureCore>()) VulkanTextureCore(desc, initialData, deviceMask);
+
+		SPtr<VulkanTextureCore> texPtr = bs_shared_ptr<VulkanTextureCore>(tex);
+		texPtr->_setThisPtr(texPtr);
+
+		return texPtr;
+	}
+
+	SPtr<RenderTextureCore> VulkanTextureCoreManager::createRenderTextureInternal(const RENDER_TEXTURE_DESC_CORE& desc,
+		GpuDeviceFlags deviceMask)
+	{
+		SPtr<VulkanRenderTextureCore> texPtr = bs_shared_ptr_new<VulkanRenderTextureCore>(desc, deviceMask);
+		texPtr->_setThisPtr(texPtr);
+
+		return texPtr;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanTimerQuery.cpp

@@ -0,0 +1,37 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanTimerQuery.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanTimerQuery::VulkanTimerQuery(UINT32 deviceIdx)
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query);
+	}
+
+	VulkanTimerQuery::~VulkanTimerQuery()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_Query);
+	}
+
+	void VulkanTimerQuery::begin()
+	{
+		setActive(true);
+	}
+
+	void VulkanTimerQuery::end()
+	{
+
+	}
+
+	bool VulkanTimerQuery::isReady() const
+	{
+		return false;
+	}
+
+	float VulkanTimerQuery::getTimeMs()
+	{
+		return 0.0f;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanVertexBuffer.cpp

@@ -0,0 +1,60 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsVulkanVertexBuffer.h"
+#include "BsRenderStats.h"
+
+namespace BansheeEngine
+{
+	VulkanVertexBufferCore::VulkanVertexBufferCore(const VERTEX_BUFFER_DESC& desc, GpuDeviceFlags deviceMask)
+		:VertexBufferCore(desc, deviceMask)
+	{ }
+
+	VulkanVertexBufferCore::~VulkanVertexBufferCore()
+	{
+		BS_INC_RENDER_STAT_CAT(ResDestroyed, RenderStatObject_VertexBuffer);
+	}
+
+	void* VulkanVertexBufferCore::map(UINT32 offset, UINT32 length, GpuLockOptions options)
+	{
+#if BS_PROFILING_ENABLED
+		if (options == GBL_READ_ONLY || options == GBL_READ_WRITE)
+		{
+			BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_VertexBuffer);
+		}
+
+		if (options == GBL_READ_WRITE || options == GBL_WRITE_ONLY || options == GBL_WRITE_ONLY_DISCARD || options == GBL_WRITE_ONLY_NO_OVERWRITE)
+		{
+			BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_VertexBuffer);
+		}
+#endif
+
+		return nullptr;
+	}
+
+	void VulkanVertexBufferCore::unmap()
+	{
+
+	}
+
+	void VulkanVertexBufferCore::readData(UINT32 offset, UINT32 length, void* dest)
+	{
+		BS_INC_RENDER_STAT_CAT(ResRead, RenderStatObject_VertexBuffer);
+	}
+
+	void VulkanVertexBufferCore::writeData(UINT32 offset, UINT32 length, const void* source, BufferWriteType writeFlags)
+	{
+		BS_INC_RENDER_STAT_CAT(ResWrite, RenderStatObject_VertexBuffer);
+	}
+
+	void VulkanVertexBufferCore::copyData(HardwareBuffer& srcBuffer, UINT32 srcOffset,
+		UINT32 dstOffset, UINT32 length, bool discardWholeBuffer)
+	{
+
+	}
+
+	void VulkanVertexBufferCore::initialize()
+	{
+		BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_VertexBuffer);
+		VertexBufferCore::initialize();
+	}
+}

Source/BansheeVulkanRenderAPI/Source/BsVulkanVideoModeInfo.cpp

@@ -0,0 +1,26 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "Win32/BsWin32VideoModeInfo.h"
+#include "BsException.h"
+
+namespace BansheeEngine
+{
+	Win32VideoModeInfo::Win32VideoModeInfo()
+	{
+
+	}
+
+	Win32VideoOutputInfo::Win32VideoOutputInfo( UINT32 outputIdx)
+	{
+		
+	}
+
+	Win32VideoOutputInfo::~Win32VideoOutputInfo()
+	{
+
+	}
+
+	Win32VideoMode::Win32VideoMode(UINT32 width, UINT32 height, float refreshRate, UINT32 outputIdx)
+		:VideoMode(width, height, refreshRate, outputIdx)
+	{ }
+}

Source/BansheeVulkanRenderAPI/Source/Win32/BsWin32RenderWindow.cpp

@@ -0,0 +1,267 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "Win32/BsWin32RenderWindow.h"
+#include "Win32/BsWin32Platform.h"
+#include "Win32/BsWin32Window.h"
+#include "BsCoreThread.h"
+#include "BsRenderStats.h"
+#include "BsRenderWindowManager.h"
+
+namespace BansheeEngine
+{
+	Win32RenderWindowProperties::Win32RenderWindowProperties(const RENDER_WINDOW_DESC& desc)
+		:RenderWindowProperties(desc)
+	{ }
+
+	Win32RenderWindowCore::Win32RenderWindowCore(const RENDER_WINDOW_DESC& desc, UINT32 windowId)
+		: RenderWindowCore(desc, windowId), mProperties(desc), mSyncedProperties(desc), mWindow(nullptr)
+	{ }
+
+	Win32RenderWindowCore::~Win32RenderWindowCore()
+	{ 
+		if (mWindow != nullptr)
+		{
+			bs_delete(mWindow);
+			mWindow = nullptr;
+		}
+	}
+
+	void Win32RenderWindowCore::initialize()
+	{
+		Win32RenderWindowProperties& props = mProperties;
+
+		WINDOW_DESC windowDesc;
+		windowDesc.border = mDesc.border;
+		windowDesc.enableDoubleClick = mDesc.enableDoubleClick;
+		windowDesc.fullscreen = mDesc.fullscreen;
+		windowDesc.width = mDesc.videoMode.getWidth();
+		windowDesc.height = mDesc.videoMode.getHeight();
+		windowDesc.hidden = mDesc.hidden || mDesc.hideUntilSwap;
+		windowDesc.left = mDesc.left;
+		windowDesc.top = mDesc.top;
+		windowDesc.outerDimensions = mDesc.outerDimensions;
+		windowDesc.title = mDesc.title;
+		windowDesc.toolWindow = mDesc.toolWindow;
+		windowDesc.creationParams = this;
+		windowDesc.modal = mDesc.modal;
+		windowDesc.wndProc = &Win32Platform::_win32WndProc;
+
+#ifdef BS_STATIC_LIB
+		windowDesc.module = GetModuleHandle(NULL);
+#else
+		windowDesc.module = GetModuleHandle("BansheeVulkanRenderAPI.dll");
+#endif
+
+		NameValuePairList::const_iterator opt;
+		opt = mDesc.platformSpecific.find("parentWindowHandle");
+		if (opt != mDesc.platformSpecific.end())
+			windowDesc.parent = (HWND)parseUINT64(opt->second);
+
+		opt = mDesc.platformSpecific.find("externalWindowHandle");
+		if (opt != mDesc.platformSpecific.end())
+			windowDesc.external = (HWND)parseUINT64(opt->second);
+		
+		mWindow = bs_new<Win32Window>(windowDesc);
+
+		{
+			ScopedSpinLock lock(mLock);
+			mSyncedProperties = props;
+		}
+
+		RenderWindowManager::instance().notifySyncDataDirty(this);
+		RenderWindowCore::initialize();
+	}
+
+	void Win32RenderWindowCore::swapBuffers()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+	}
+
+	void Win32RenderWindowCore::move(INT32 left, INT32 top)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		Win32RenderWindowProperties& props = mProperties;
+
+		if (!props.mIsFullScreen)
+		{
+			mWindow->move(left, top);
+
+			props.mTop = mWindow->getTop();
+			props.mLeft = mWindow->getLeft();
+
+			{
+				ScopedSpinLock lock(mLock);
+				mSyncedProperties.mTop = props.mTop;
+				mSyncedProperties.mLeft = props.mLeft;
+			}
+
+			RenderWindowManager::instance().notifySyncDataDirty(this);
+		}
+	}
+
+	void Win32RenderWindowCore::resize(UINT32 width, UINT32 height)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		Win32RenderWindowProperties& props = mProperties;
+
+		if (!props.mIsFullScreen)
+		{
+			mWindow->resize(width, height);
+
+			props.mWidth = mWindow->getWidth();
+			props.mHeight = mWindow->getHeight();
+
+			{
+				ScopedSpinLock lock(mLock);
+				mSyncedProperties.mWidth = props.mWidth;
+				mSyncedProperties.mHeight = props.mHeight;
+			}
+
+			RenderWindowManager::instance().notifySyncDataDirty(this);
+		}
+	}
+
+	void Win32RenderWindowCore::setActive(bool state)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->setActive(state);
+
+		RenderWindowCore::setActive(state);
+	}
+
+	void Win32RenderWindowCore::setHidden(bool hidden)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->setHidden(hidden);
+
+		RenderWindowCore::setHidden(hidden);
+	}
+
+	void Win32RenderWindowCore::minimize()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->minimize();
+	}
+
+	void Win32RenderWindowCore::maximize()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->maximize();
+	}
+
+	void Win32RenderWindowCore::restore()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		mWindow->restore();
+	}
+
+	void Win32RenderWindowCore::setFullscreen(UINT32 width, UINT32 height, float refreshRate, UINT32 monitorIdx)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+	}
+
+	void Win32RenderWindowCore::setFullscreen(const VideoMode& mode)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+	}
+
+	void Win32RenderWindowCore::setWindowed(UINT32 width, UINT32 height)
+	{
+		THROW_IF_NOT_CORE_THREAD;
+	}
+
+	HWND Win32RenderWindowCore::_getWindowHandle() const
+	{
+		return mWindow->getHWnd();
+	}
+
+	void Win32RenderWindowCore::getCustomAttribute(const String& name, void* pData) const
+	{
+		if(name == "WINDOW")
+		{
+			UINT64 *pWnd = (UINT64*)pData;
+			*pWnd = (UINT64)mWindow->getHWnd();
+			return;
+		}
+
+		RenderWindowCore::getCustomAttribute(name, pData);
+	}
+
+	void Win32RenderWindowCore::_windowMovedOrResized()
+	{
+		THROW_IF_NOT_CORE_THREAD;
+
+		if (!mWindow)
+			return;
+
+		mWindow->_windowMovedOrResized();
+
+		RenderWindowCore::_windowMovedOrResized();
+	}
+
+	void Win32RenderWindowCore::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;
+	}
+}

Source/BansheeVulkanRenderAPI/Source/Win32/BsWin32VideoModeInfo.cpp

@@ -0,0 +1,26 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "Win32/BsWin32VideoModeInfo.h"
+#include "BsException.h"
+
+namespace BansheeEngine
+{
+	Win32VideoModeInfo::Win32VideoModeInfo()
+	{
+
+	}
+
+	Win32VideoOutputInfo::Win32VideoOutputInfo( UINT32 outputIdx)
+	{
+		
+	}
+
+	Win32VideoOutputInfo::~Win32VideoOutputInfo()
+	{
+
+	}
+
+	Win32VideoMode::Win32VideoMode(UINT32 width, UINT32 height, float refreshRate, UINT32 outputIdx)
+		:VideoMode(width, height, refreshRate, outputIdx)
+	{ }
+}

Source/CMake/Modules/FindVulkan.cmake

@@ -0,0 +1,44 @@
+# Find Vulkan installation
+#
+# This module defines
+#  Vulkan_INCLUDE_DIRS
+#  Vulkan_LIBRARIES_DEBUG
+#  Vulkan_LIBRARIES_OPTIMIZED
+#  Vulkan_LIBRARY_DIRS
+#  Vulkan_FOUND
+
+# TODO: Set default install paths for mac/unix
+# TODO: Don't hardcode the version (instead use regex or GLOB to match latest)
+set(Vulkan_INSTALL_DIRS "C:/VulkanSDK/1.0.17.0" CACHE PATH "")
+set(Vulkan_INCLUDE_SEARCH_DIRS "${Vulkan_INSTALL_DIRS}/Include")
+
+if(BS_64BIT)
+	set(Vulkan_LIBRARY_SEARCH_DIRS "${Vulkan_INSTALL_DIRS}/Bin")
+else()
+	set(Vulkan_LIBRARY_SEARCH_DIRS "${Vulkan_INSTALL_DIRS}/Bin32")
+endif()
+
+message(STATUS "Looking for Vulkan installation...")
+find_path(Vulkan_INCLUDE_DIR vulkan/vulkan.h PATHS ${Vulkan_INCLUDE_SEARCH_DIRS})
+
+find_library(Vulkan_LIBRARY_OPTIMIZED NAMES vulkan-1 PATHS ${Vulkan_LIBRARY_SEARCH_DIRS})
+find_library(Vulkan_LIBRARY_DEBUG NAMES vulkan-1 PATHS ${Vulkan_LIBRARY_SEARCH_DIRS})
+
+if(Vulkan_INCLUDE_DIR AND Vulkan_LIBRARY_OPTIMIZED AND Vulkan_LIBRARY_DEBUG)
+	set(Vulkan_FOUND TRUE)
+endif()
+
+if(NOT Vulkan_FOUND)
+	if(Vulkan_FIND_REQUIRED)
+		message(FATAL_ERROR "Cannot find Vulkan installation. Try modifying the Vulkan_INSTALL_DIRS path.")
+	else()
+		message(WARNING "Cannot find Vulkan installation. Try modifying the Vulkan_INSTALL_DIRS path.")
+	endif()
+else()
+	message(STATUS "...Vulkan OK.")
+endif()
+
+mark_as_advanced(Vulkan_INSTALL_DIRS Vulkan_INCLUDE_DIR Vulkan_LIBRARY_OPTIMIZED Vulkan_LIBRARY_DEBUG)
+set(Vulkan_INCLUDE_DIRS ${Vulkan_INCLUDE_DIR})
+set(Vulkan_LIBRARIES_OPTIMIZED ${Vulkan_LIBRARY_OPTIMIZED})
+set(Vulkan_LIBRARIES_DEBUG ${Vulkan_LIBRARY_DEBUG})

Source/CMake/Modules/Findglslang.cmake

@@ -0,0 +1,42 @@
+# Find glslang
+#
+# This module defines
+#  glslang_INCLUDE_DIRS
+#  glslang_LIBRARIES_DEBUG
+#  glslang_LIBRARIES_OPTIMIZED
+#  glslang_LIBRARY_DIRS
+#  glslang_FOUND
+
+set(glslang_INSTALL_DIRS ${PROJECT_SOURCE_DIR}/../Dependencies/glslang CACHE PATH "")
+set(glslang_INCLUDE_SEARCH_DIRS "${glslang_INSTALL_DIRS}/include")
+
+if(BS_64BIT)
+	set(glslang_LIBRARY_SEARCH_DIRS "${glslang_INSTALL_DIRS}/lib/x64")
+else()
+	set(glslang_LIBRARY_SEARCH_DIRS "${glslang_INSTALL_DIRS}/lib/x86")
+endif()
+
+message(STATUS "Looking for glslang installation...")
+find_path(glslang_INCLUDE_DIR Public/ShaderLang.h PATHS ${glslang_INCLUDE_SEARCH_DIRS})
+
+find_library(glslang_LIBRARY_OPTIMIZED NAMES glslang HLSL OSDependent OGLCompiler PATHS ${glslang_LIBRARY_SEARCH_DIRS})
+find_library(glslang_LIBRARY_DEBUG NAMES glslangd HLSLd OSDependentd OGLCompilerd PATHS ${glslang_LIBRARY_SEARCH_DIRS})
+
+if(glslang_INCLUDE_DIR AND glslang_LIBRARY_OPTIMIZED AND glslang_LIBRARY_DEBUG)
+	set(glslang_FOUND TRUE)
+endif()
+
+if(NOT glslang_FOUND)
+	if(glslang_FIND_REQUIRED)
+		message(FATAL_ERROR "Cannot find glslang installation. Try modifying the glslang_INSTALL_DIRS path.")
+	else()
+		message(WARNING "Cannot find glslang installation. Try modifying the glslang_INSTALL_DIRS path.")
+	endif()
+else()
+	message(STATUS "...glslang OK.")
+endif()
+
+mark_as_advanced(glslang_INSTALL_DIRS glslang_INCLUDE_DIR glslang_LIBRARY_OPTIMIZED glslang_LIBRARY_DEBUG)
+set(glslang_INCLUDE_DIRS ${glslang_INCLUDE_DIR})
+set(glslang_LIBRARIES_OPTIMIZED ${glslang_LIBRARY_OPTIMIZED})
+set(glslang_LIBRARIES_DEBUG ${glslang_LIBRARY_DEBUG})

Source/CMakeLists.txt

@@ -34,10 +34,10 @@ set_property(CACHE INPUT_MODULE PROPERTY STRINGS OIS)
 
 if(WIN32)
 set(RENDER_API_MODULE "DirectX 11" CACHE STRING "Render API to use.")
-set_property(CACHE RENDER_API_MODULE PROPERTY STRINGS "DirectX 11" "OpenGL")
+set_property(CACHE RENDER_API_MODULE PROPERTY STRINGS "DirectX 11" "OpenGL" "Vulkan")
 else()
 set(RENDER_API_MODULE "OpenGL" CACHE STRING "Render API to use.")
-set_property(CACHE RENDER_API_MODULE PROPERTY STRINGS "OpenGL")
+set_property(CACHE RENDER_API_MODULE PROPERTY STRINGS "OpenGL" "Vulkan")
 endif()
 
 set(RENDERER_MODULE "RenderBeast" CACHE STRING "Renderer backend to use.")
@@ -53,8 +53,8 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/Modules/")
 
 # Global compile & linker flags
 ## Compiler-agnostic settings
-### Target at least C++11
-set(CMAKE_CXX_STANDARD 11)
+### Target at least C++14
+set(CMAKE_CXX_STANDARD 14)
 ## Compiler-specific settings
 if(MSVC)
 	# Linker
@@ -165,9 +165,21 @@ function(add_library_per_config_multi target_name lib_name file_name release_nam
 	target_link_libraries(${target_name} PRIVATE ${lib_name})	
 endfunction()
 
+function(add_package_library target_name lib_name)
+	add_library(${lib_name} STATIC IMPORTED)
+
+	set_target_properties(${lib_name} PROPERTIES IMPORTED_LOCATION_DEBUG "${${lib_name}_LIBRARIES_DEBUG}")
+	set_target_properties(${lib_name} PROPERTIES IMPORTED_LOCATION_OPTIMIZEDDEBUG "${${lib_name}_LIBRARIES_DEBUG}")
+	set_target_properties(${lib_name} PROPERTIES IMPORTED_LOCATION_RELEASE "${${lib_name}_LIBRARIES_OPTIMIZED}")	
+
+	target_link_libraries(${target_name} PRIVATE ${lib_name})	
+endfunction()
+
 function(add_engine_dependencies target_name)
 	if(RENDER_API_MODULE MATCHES "DirectX 11")
 		add_dependencies(${target_name} BansheeD3D11RenderAPI)
+	elseif(RENDER_API_MODULE MATCHES "Vulkan")
+		add_dependencies(${target_name} BansheeVulkanRenderAPI)
 	else()
 		add_dependencies(${target_name} BansheeGLRenderAPI)
 	endif()
@@ -198,11 +210,14 @@ endif()
 if(INCLUDE_ALL_IN_WORKFLOW AND MSVC)
 	add_subdirectory(BansheeD3D11RenderAPI)
 	add_subdirectory(BansheeGLRenderAPI)
+	add_subdirectory(BansheeVulkanRenderAPI)
 	add_subdirectory(BansheeFMOD)
 	add_subdirectory(BansheeOpenAudio)
 else() # Otherwise include only chosen ones
 	if(RENDER_API_MODULE MATCHES "DirectX 11")
 		add_subdirectory(BansheeD3D11RenderAPI)
+	elseif(RENDER_API_MODULE MATCHES "Vulkan")
+		add_subdirectory(BansheeVulkanRenderAPI)
 	else()
 		add_subdirectory(BansheeGLRenderAPI)
 	endif()
@@ -226,7 +241,7 @@ add_subdirectory(BansheeSL)
 ## Script interop
 add_subdirectory(SBansheeEngine)
 
-if(BUILD_EDITOR OR MSVC)
+if(BUILD_EDITOR OR (INCLUDE_ALL_IN_WORKFLOW AND MSVC))
 	add_subdirectory(SBansheeEditor)
 endif()
 
@@ -234,7 +249,7 @@ endif()
 add_subdirectory(Game)
 add_subdirectory(ExampleProject)
 
-if(BUILD_EDITOR OR MSVC)
+if(BUILD_EDITOR OR (INCLUDE_ALL_IN_WORKFLOW AND MSVC))
 	add_subdirectory(BansheeEditorExec)
 endif()
 
@@ -259,6 +274,8 @@ endif()
 ## Set names of libraries used in the config file
 if(RENDER_API_MODULE MATCHES "DirectX 11")
 	set(RENDER_API_MODULE_LIB BansheeD3D11RenderAPI)
+elseif(RENDER_API_MODULE MATCHES "Vulkan")
+	set(RENDER_API_MODULE_LIB BansheeVulkanRenderAPI)
 else()
 	set(RENDER_API_MODULE_LIB BansheeGLRenderAPI)
 endif()