save commitvkChess

24 files changed, 249 insertions, 151 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5c0644f..a508186 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,6 +37,7 @@ if (NOT TARGET vkh_static)
 endif()
 
 FIND_PACKAGE(Vulkan REQUIRED)
+#FIND_PACKAGE(GLI REQUIRED)
 #FIND_PACKAGE(GLFW3)
 
 FILE(GLOB SOURCES "src/*.cpp")
@@ -57,10 +58,12 @@ FUNCTION (setup_lib LibName)
 			${CMAKE_CURRENT_SOURCE_DIR}/include
 			${CMAKE_CURRENT_SOURCE_DIR}/src
 			${Vulkan_INCLUDE_DIRS}
+			#${GLI_INCLUDE_DIR}
 	)
 	TARGET_LINK_LIBRARIES(${LibName}
 		${Vulkan_LIBRARIES}
 		vkh_static
+		#${GLI_LIBRARY_DIR}
 		#${GLFW3_LIBRARY}
 	)
 	INSTALL(TARGETS ${LibName}
@@ -76,3 +79,4 @@ setup_lib ("${PROJECT_NAME}_static")
 ADD_LIBRARY("${PROJECT_NAME}_shared" SHARED ${SOURCES})
 SET_PROPERTY(TARGET "${PROJECT_NAME}_static" PROPERTY POSITION_INDEPENDENT_CODE ON)
 setup_lib ("${PROJECT_NAME}_shared")
+
diff --git a/cmake/FindGLI.cmake b/cmake/FindGLI.cmake
new file mode 100644
index 0000000..de80e4b
--- /dev/null
+++ b/cmake/FindGLI.cmake
@@ -0,0 +1,12 @@
+if(NOT GLI_PACKAGE_DIR)
+	message("ERROR: GLI_PACKAGE_DIR requires to be set")
+endif(NOT GLI_PACKAGE_DIR)
+
+set(GLI_INCLUDE_DIR ${GLI_PACKAGE_DIR})
+set(GLI_LIBRARY_DIR )
+
+include_directories(${GLI_INCLUDE_DIR})
+
+if(GLI_PACKAGE_DIR AND GLI_INCLUDE_DIR)
+	set(GLI_FOUND "YES")
+endif(GLI_PACKAGE_DIR AND GLI_INCLUDE_DIR)
diff --git a/include/vke.h b/include/vke.h
index 25ed5a5..cf1feaa 100644
--- a/include/vke.h
+++ b/include/vke.h
@@ -31,7 +31,7 @@
 
 
 
-namespace vks {
+namespace vke {
     typedef class  VkEngine*		ptrVkEngine;
     typedef class  VulkanSwapChain* ptrSwapchain;
     typedef struct VulkanDevice*	ptrVkDev;
diff --git a/src/VkEngine.cpp b/src/VkEngine.cpp
index 32156fa..ea05a49 100644
--- a/src/VkEngine.cpp
+++ b/src/VkEngine.cpp
@@ -121,7 +121,7 @@ std::array<bmchar, 255> parsebmFont(const std::string& fileName)
     return fontChars;
 }
 
-std::vector<const char*> vks::VkEngine::args;
+std::vector<const char*> vke::VkEngine::args;
 
 VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject, size_t location, int32_t msgCode, const char * pLayerPrefix, const char * pMsg, void * pUserData)
 {
@@ -146,7 +146,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL debugMessageCallback(VkDebugReportFlagsEXT flags,
     return VK_FALSE;
 }
 
-std::string vks::VkEngine::getWindowTitle()
+std::string vke::VkEngine::getWindowTitle()
 {
     std::string device(this->device->properties.deviceName);
     std::string windowTitle;
@@ -155,21 +155,21 @@ std::string vks::VkEngine::getWindowTitle()
 }
 
 static void onkey_callback (GLFWwindow* window, int key, int scanCode, int action ,int mods){
-    vks::VkEngine* e = (vks::VkEngine*)glfwGetWindowUserPointer(window);
+    vke::VkEngine* e = (vke::VkEngine*)glfwGetWindowUserPointer(window);
     if (action == GLFW_PRESS)
         e->keyDown(key);
     else
         e->keyUp(key);
 }
 static void char_callback (GLFWwindow* window, uint32_t c){
-    vks::VkEngine* e = (vks::VkEngine*)glfwGetWindowUserPointer(window);
+    vke::VkEngine* e = (vke::VkEngine*)glfwGetWindowUserPointer(window);
 }
 static void mouse_move_callback(GLFWwindow* window, double x, double y){
-    vks::VkEngine* e = (vks::VkEngine*)glfwGetWindowUserPointer(window);
+    vke::VkEngine* e = (vke::VkEngine*)glfwGetWindowUserPointer(window);
     e->handleMouseMove((int32_t)x, (int32_t)y);
 }
 static void mouse_button_callback(GLFWwindow* window, int but, int state, int modif){
-    vks::VkEngine* e = (vks::VkEngine*)glfwGetWindowUserPointer(window);
+    vke::VkEngine* e = (vke::VkEngine*)glfwGetWindowUserPointer(window);
     if (state == GLFW_PRESS){
         e->mouseButtons[but] = true;
         e->handleMouseButtonDown(but);
@@ -179,7 +179,7 @@ static void mouse_button_callback(GLFWwindow* window, int but, int state, int mo
     }
 }
 
-vks::VkEngine::VkEngine (uint32_t _width, uint32_t _height,
+vke::VkEngine::VkEngine (uint32_t _width, uint32_t _height,
                     VkPhysicalDeviceType preferedGPU)
 {
     width = _width;
@@ -241,7 +241,7 @@ vks::VkEngine::VkEngine (uint32_t _width, uint32_t _height,
     VK_CHECK_RESULT(vkEnumeratePhysicalDevices(instance, &phyCount, physicalDevices.data()));
 
     for (uint i=0; i<phyCount; i++){
-        phyInfos = vks::vkPhyInfo(physicalDevices[i], surface);
+        phyInfos = vke::vkPhyInfo(physicalDevices[i], surface);
         if (phyInfos.properties.deviceType == preferedGPU)
             break;
     }
@@ -249,7 +249,7 @@ vks::VkEngine::VkEngine (uint32_t _width, uint32_t _height,
 }
 
 
-vks::VkEngine::~VkEngine()
+vke::VkEngine::~VkEngine()
 {
     sharedUBOs.matrices.destroy();
     sharedUBOs.params.destroy();
@@ -270,15 +270,15 @@ vks::VkEngine::~VkEngine()
     vkDestroyInstance (instance, VK_NULL_HANDLE);
 }
 
-void vks::VkEngine::start () {
+void vke::VkEngine::start () {
     std::vector<const char*> devLayers;
 
-#if DEBUG
-    if (settings.validation)
-        devLayers.push_back ("VK_LAYER_LUNARG_standard_validation");
-#endif
+//#if DEBUG
+//    if (settings.validation)
+//        devLayers.push_back ("VK_LAYER_KHRONOS_validation");
+//#endif
 
-    device  = new vks::VulkanDevice (phyInfos, devLayers);
+    device  = new vke::VulkanDevice (phyInfos, devLayers);
 
     swapChain = new VulkanSwapChain (this, false);
     swapChain->create (width, height);
@@ -321,9 +321,9 @@ void vks::VkEngine::start () {
     }
 }
 
-void vks::VkEngine::prepare(){}
+void vke::VkEngine::prepare(){}
 
-void vks::VkEngine::prepareFrame()
+void vke::VkEngine::prepareFrame()
 {
     VkResult err = swapChain->acquireNextImage (device->dev);
     if ((err == VK_ERROR_OUT_OF_DATE_KHR) || (err == VK_SUBOPTIMAL_KHR)) {
@@ -333,20 +333,22 @@ void vks::VkEngine::prepareFrame()
     }
 }
 
-void vks::VkEngine::createInstance (const std::string& app_name, std::vector<const char*>& extentions) {
+void vke::VkEngine::createInstance (const std::string& app_name, std::vector<const char*>& extentions) {
     VkApplicationInfo   infos = {VK_STRUCTURE_TYPE_APPLICATION_INFO};
                         infos.pApplicationName  = app_name.c_str();
                         infos.applicationVersion= 1;
                         infos.pEngineName       = ENGINE_NAME;
                         infos.engineVersion     = ENGINE_VERSION;
-                        infos.apiVersion        = VK_API_VERSION_1_0;
+                        infos.apiVersion        = VK_API_VERSION_1_1;
 
 
     std::vector<const char*> enabledLayers;
 
 #if DEBUG
     if (settings.validation)
-        enabledLayers.push_back ("VK_LAYER_LUNARG_standard_validation");
+        enabledLayers.push_back ("VK_LAYER_KHRONOS_validation");
+    enabledLayers.push_back ("VK_LAYER_RENDERDOC_Capture");
+
 #endif
 
     VkInstanceCreateInfo inst_info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
@@ -361,7 +363,7 @@ void vks::VkEngine::createInstance (const std::string& app_name, std::vector<con
 }
 
 
-//void vks::VkEngine::handleEvent(const xcb_generic_event_t *event)
+//void vke::VkEngine::handleEvent(const xcb_generic_event_t *event)
 //{
 //    switch (event->response_type & 0x7f)
 //    {
@@ -487,11 +489,11 @@ void vks::VkEngine::createInstance (const std::string& app_name, std::vector<con
 //}
 
 
-void vks::VkEngine::viewChanged() {
+void vke::VkEngine::viewChanged() {
     updateUniformBuffers();
 }
 
-void vks::VkEngine::prepareUniformBuffers()
+void vke::VkEngine::prepareUniformBuffers()
 {
     // Objact vertex shader uniform buffer
     sharedUBOs.matrices.create(device,
@@ -512,7 +514,7 @@ void vks::VkEngine::prepareUniformBuffers()
     updateUniformBuffers();
     updateParams();
 }
-void vks::VkEngine::updateUniformBuffers()
+void vke::VkEngine::updateUniformBuffers()
 {
     // 3D object
     mvpMatrices.projection = camera.matrices.perspective;
@@ -521,13 +523,13 @@ void vks::VkEngine::updateUniformBuffers()
     mvpMatrices.camPos = camera.position * -1.0f;
     sharedUBOs.matrices.copyTo (&mvpMatrices, sizeof(mvpMatrices));
 }
-void vks::VkEngine::updateParams()
+void vke::VkEngine::updateParams()
 {
     lightingParams.lightDir = glm::vec4(-10.0f, 150.f, -10.f, 1.0f);
     sharedUBOs.params.copyTo(&lightingParams, sizeof(lightingParams));
 }
 
-void vks::VkEngine::windowResize()
+void vke::VkEngine::windowResize()
 {
     if (!prepared)
         return;
@@ -545,7 +547,7 @@ void vks::VkEngine::windowResize()
     prepared = true;
 }
 
-void vks::VkEngine::keyDown(uint32_t key) {
+void vke::VkEngine::keyDown(uint32_t key) {
     switch (key) {
     case GLFW_KEY_ESCAPE :
         glfwSetWindowShouldClose(window, GLFW_TRUE);
@@ -553,10 +555,10 @@ void vks::VkEngine::keyDown(uint32_t key) {
     }
 
 }
-void vks::VkEngine::keyUp(uint32_t key) {
+void vke::VkEngine::keyUp(uint32_t key) {
     keyPressed (key);
 }
-void vks::VkEngine::keyPressed(uint32_t key) {
+void vke::VkEngine::keyPressed(uint32_t key) {
     switch (key) {
     case GLFW_KEY_F1:
         if (lightingParams.exposure > 0.1f) {
@@ -588,7 +590,7 @@ void vks::VkEngine::keyPressed(uint32_t key) {
         break;
     }
 }
-void vks::VkEngine::handleMouseMove(int32_t x, int32_t y)
+void vke::VkEngine::handleMouseMove(int32_t x, int32_t y)
 {
     int32_t dx = (int32_t)mousePos.x - x;
     int32_t dy = (int32_t)mousePos.y - y;
@@ -610,6 +612,6 @@ void vks::VkEngine::handleMouseMove(int32_t x, int32_t y)
     }
     mousePos = glm::vec2((float)x, (float)y);
 }
-void vks::VkEngine::handleMouseButtonDown(int buttonIndex) {}
-void vks::VkEngine::handleMouseButtonUp(int buttonIndex) {}
+void vke::VkEngine::handleMouseButtonDown(int buttonIndex) {}
+void vke::VkEngine::handleMouseButtonUp(int buttonIndex) {}
 
diff --git a/src/VkEngine.h b/src/VkEngine.h
index 7a5e5e2..dacb34b 100644
--- a/src/VkEngine.h
+++ b/src/VkEngine.h
@@ -31,7 +31,7 @@ struct bmchar {
 };
 std::array<bmchar, 255> parsebmFont(const std::string& fileName);
 
-namespace vks {
+namespace vke {
 
     class VkEngine
     {
@@ -51,7 +51,7 @@ namespace vks {
 
         void createInstance (const std::string& app_name, std::vector<const char*>& extentions);
     protected:
-        vks::vkPhyInfo      phyInfos;
+        vke::vkPhyInfo      phyInfos;
         GLFWwindow*         window;
 
         ptrSwapchain        swapChain;
@@ -85,8 +85,8 @@ namespace vks {
         } settings;
 
         struct UniformBuffers {
-            vks::Buffer matrices;
-            vks::Buffer params;
+            vke::Buffer matrices;
+            vke::Buffer params;
         } sharedUBOs;
 
         struct MVPMatrices {
diff --git a/src/VulkanAndroid.cpp b/src/VulkanAndroid.cpp
index aba260a..eff20ca 100644
--- a/src/VulkanAndroid.cpp
+++ b/src/VulkanAndroid.cpp
@@ -119,11 +119,11 @@ PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
 PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
 
-int32_t vks::android::screenDensity;
+int32_t vke::android::screenDensity;
 
 void *libVulkan;
 
-namespace vks
+namespace vke
 {
 	namespace android
 	{
@@ -289,7 +289,7 @@ namespace vks
 			// Screen density
 			AConfiguration* config = AConfiguration_new();
 			AConfiguration_fromAssetManager(config, androidApp->activity->assetManager);
-			vks::android::screenDensity = AConfiguration_getDensity(config);
+			vke::android::screenDensity = AConfiguration_getDensity(config);
 			AConfiguration_delete(config);
 		}
 	}
diff --git a/src/VulkanAndroid.h b/src/VulkanAndroid.h
index 372b36e..d518ba9 100644
--- a/src/VulkanAndroid.h
+++ b/src/VulkanAndroid.h
@@ -152,7 +152,7 @@ extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
 extern PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR;
 extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
 
-namespace vks
+namespace vke
 {
 	namespace android
 	{
diff --git a/src/VulkanBuffer.hpp b/src/VulkanBuffer.hpp
index b4fd06f..79927cf 100644
--- a/src/VulkanBuffer.hpp
+++ b/src/VulkanBuffer.hpp
@@ -15,7 +15,7 @@
 #include "VulkanDevice.hpp"
 #include "resource.hpp"
 
-namespace vks
+namespace vke
 {
     struct Buffer : public Resource
     {
diff --git a/src/VulkanDevice.cpp b/src/VulkanDevice.cpp
index 3b47253..484f8e5 100644
--- a/src/VulkanDevice.cpp
+++ b/src/VulkanDevice.cpp
@@ -1,6 +1,6 @@
 #include "VulkanDevice.hpp"
 
-vks::VulkanDevice::VulkanDevice(vkPhyInfo phyInfos, const std::vector<const char*>& devLayers)
+vke::VulkanDevice::VulkanDevice(vkPhyInfo phyInfos, const std::vector<const char*>& devLayers)
 {
     phy = phyInfos.phy;
 
@@ -52,7 +52,7 @@ vks::VulkanDevice::VulkanDevice(vkPhyInfo phyInfos, const std::vector<const char
     delete[] buffer;
 }
 
-vks::VulkanDevice::~VulkanDevice()
+vke::VulkanDevice::~VulkanDevice()
 {
     if (pipelineCache){
         if (savePLCache){
@@ -74,7 +74,7 @@ vks::VulkanDevice::~VulkanDevice()
         vkDestroyDevice(dev, nullptr);
 }
 
-uint32_t vks::VulkanDevice::getMemoryType(uint32_t typeBits, VkMemoryPropertyFlags properties, VkBool32 *memTypeFound)
+uint32_t vke::VulkanDevice::getMemoryType(uint32_t typeBits, VkMemoryPropertyFlags properties, VkBool32 *memTypeFound)
 {
     for (uint32_t i = 0; i < memoryProperties.memoryTypeCount; i++) {
         if ((typeBits & 1) == 1) {
@@ -96,7 +96,7 @@ uint32_t vks::VulkanDevice::getMemoryType(uint32_t typeBits, VkMemoryPropertyFla
     }
 }
 
-VkFormat vks::VulkanDevice::getSuitableDepthFormat () {
+VkFormat vke::VulkanDevice::getSuitableDepthFormat () {
     std::vector<VkFormat> depthFormats = { VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D16_UNORM };
     for (auto& format : depthFormats) {
         VkFormatProperties formatProps;
@@ -108,7 +108,7 @@ VkFormat vks::VulkanDevice::getSuitableDepthFormat () {
     exit(-1);
 }
 
-uint32_t vks::VulkanDevice::getQueueFamilyIndex(VkQueueFlagBits queueFlags)
+uint32_t vke::VulkanDevice::getQueueFamilyIndex(VkQueueFlagBits queueFlags)
 {
     // Dedicated queue for compute
     // Try to find a queue family index that supports compute but not graphics
@@ -134,7 +134,7 @@ uint32_t vks::VulkanDevice::getQueueFamilyIndex(VkQueueFlagBits queueFlags)
 }
 
 
-VkCommandPool vks::VulkanDevice::createCommandPool(uint32_t queueFamilyIndex, VkCommandPoolCreateFlags createFlags)
+VkCommandPool vke::VulkanDevice::createCommandPool(uint32_t queueFamilyIndex, VkCommandPoolCreateFlags createFlags)
 {
     VkCommandPoolCreateInfo cmdPoolInfo = {};
     cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
@@ -145,7 +145,7 @@ VkCommandPool vks::VulkanDevice::createCommandPool(uint32_t queueFamilyIndex, Vk
     return cmdPool;
 }
 
-VkCommandBuffer vks::VulkanDevice::createCommandBuffer(VkCommandBufferLevel level, bool begin)
+VkCommandBuffer vke::VulkanDevice::createCommandBuffer(VkCommandBufferLevel level, bool begin, bool oneTime)
 {
     VkCommandBufferAllocateInfo cmdBufAllocateInfo{};
     cmdBufAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@@ -153,6 +153,7 @@ VkCommandBuffer vks::VulkanDevice::createCommandBuffer(VkCommandBufferLevel leve
     cmdBufAllocateInfo.level = level;
     cmdBufAllocateInfo.commandBufferCount = 1;
 
+
     VkCommandBuffer cmdBuffer;
     VK_CHECK_RESULT(vkAllocateCommandBuffers(dev, &cmdBufAllocateInfo, &cmdBuffer));
 
@@ -160,13 +161,14 @@ VkCommandBuffer vks::VulkanDevice::createCommandBuffer(VkCommandBufferLevel leve
     if (begin) {
         VkCommandBufferBeginInfo cmdBufInfo{};
         cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        cmdBufInfo.flags = oneTime ? VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT : 0;
         VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
     }
 
     return cmdBuffer;
 }
 
-void vks::VulkanDevice::flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueue queue, bool free)
+void vke::VulkanDevice::flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueue queue, bool free)
 {
     VK_CHECK_RESULT(vkEndCommandBuffer(commandBuffer));
 
@@ -192,23 +194,23 @@ void vks::VulkanDevice::flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueu
         vkFreeCommandBuffers(dev, commandPool, 1, &commandBuffer);
     }
 }
-VkSemaphore vks::VulkanDevice::createSemaphore ()
+VkSemaphore vke::VulkanDevice::createSemaphore ()
 {
     VkSemaphore sema = VK_NULL_HANDLE;
     VkSemaphoreCreateInfo semaphoreCreateInfo {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
     VK_CHECK_RESULT(vkCreateSemaphore (dev, &semaphoreCreateInfo, nullptr, &sema));
     return sema;
 }
-VkFence vks::VulkanDevice::createFence (bool signaled) {
+VkFence vke::VulkanDevice::createFence (bool signaled) {
     VkFence fence = VK_NULL_HANDLE;
     VkFenceCreateInfo fenceCreateInfo {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, VK_NULL_HANDLE,
-                signaled ? VK_FENCE_CREATE_SIGNALED_BIT : 0};
+                signaled ? VK_FENCE_CREATE_SIGNALED_BIT : (VkFenceCreateFlags)0};
     VK_CHECK_RESULT(vkCreateFence (dev, &fenceCreateInfo, nullptr, &fence));
     return fence;
 }
-void vks::VulkanDevice::destroyFence (VkFence fence) {
+void vke::VulkanDevice::destroyFence (VkFence fence) {
     vkDestroyFence (dev, fence, VK_NULL_HANDLE);
 }
-void vks::VulkanDevice::destroySemaphore (VkSemaphore semaphore) {
+void vke::VulkanDevice::destroySemaphore (VkSemaphore semaphore) {
     vkDestroySemaphore (dev, semaphore, VK_NULL_HANDLE);
 }
diff --git a/src/VulkanDevice.hpp b/src/VulkanDevice.hpp
index fa9f5f4..d61152d 100644
--- a/src/VulkanDevice.hpp
+++ b/src/VulkanDevice.hpp
@@ -14,7 +14,7 @@
 
 //#include "VulkanBuffer.hpp"
 
-namespace vks
+namespace vke
 {
     struct vkPhyInfo{
         VkPhysicalDevice                    phy;
@@ -141,7 +141,7 @@ namespace vks
 
         VkCommandPool createCommandPool(uint32_t queueFamilyIndex,
                                         VkCommandPoolCreateFlags createFlags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
-        VkCommandBuffer createCommandBuffer(VkCommandBufferLevel level, bool begin = false);
+        VkCommandBuffer createCommandBuffer(VkCommandBufferLevel level, bool begin = false, bool oneTime = false);
 
         void flushCommandBuffer(VkCommandBuffer commandBuffer, VkQueue queue, bool free = true);
         VkSemaphore createSemaphore ();
diff --git a/src/VulkanSwapChain.cpp b/src/VulkanSwapChain.cpp
index 2ae5451..bdac6d2 100644
--- a/src/VulkanSwapChain.cpp
+++ b/src/VulkanSwapChain.cpp
@@ -13,7 +13,7 @@
 #include "VulkanSwapChain.hpp"
 #include "VkEngine.h"
 
-vks::VulkanSwapChain::VulkanSwapChain(ptrVkEngine _vke, bool vsync) {
+vke::VulkanSwapChain::VulkanSwapChain(ptrVkEngine _vke, bool vsync) {
     vke = _vke;
     GET_INSTANCE_PROC_ADDR(vke->instance, GetPhysicalDeviceSurfaceSupportKHR);
     GET_INSTANCE_PROC_ADDR(vke->instance, GetPhysicalDeviceSurfaceCapabilitiesKHR);
@@ -136,7 +136,7 @@ vks::VulkanSwapChain::VulkanSwapChain(ptrVkEngine _vke, bool vsync) {
     presentInfo = {VK_STRUCTURE_TYPE_PRESENT_INFO_KHR};
     presentInfo.swapchainCount = 1;
 }
-vks::VulkanSwapChain::~VulkanSwapChain()
+vke::VulkanSwapChain::~VulkanSwapChain()
 {
     vke->device->destroySemaphore(presentCompleteSemaphore);
 
@@ -149,7 +149,7 @@ vks::VulkanSwapChain::~VulkanSwapChain()
     swapChain = VK_NULL_HANDLE;
 }
 
-void vks::VulkanSwapChain::create(uint32_t& width, uint32_t& height)
+void vke::VulkanSwapChain::create(uint32_t& width, uint32_t& height)
 {
     vkDeviceWaitIdle (vke->device->dev);
 
diff --git a/src/VulkanSwapChain.hpp b/src/VulkanSwapChain.hpp
index 966d68c..ddb5f0f 100644
--- a/src/VulkanSwapChain.hpp
+++ b/src/VulkanSwapChain.hpp
@@ -12,7 +12,7 @@
 
 #include "vke.h"
 #include "rendertarget.hpp"
-namespace vks {
+namespace vke {
 
     typedef struct _SwapChainBuffers {
         VkImage image;
diff --git a/src/VulkanTexture.hpp b/src/VulkanTexture.hpp
index 6b2bef8..1b7cec0 100644
--- a/src/VulkanTexture.hpp
+++ b/src/VulkanTexture.hpp
@@ -26,14 +26,14 @@
 #include <android/asset_manager.h>
 #endif
 
-namespace vks
+namespace vke
 {
     class Texture2D : public Texture {
     public:
         void loadFromFile(
             std::string filename,
             VkFormat format,
-            vks::VulkanDevice *_device,
+            vke::VulkanDevice *_device,
             VkQueue copyQueue,
             VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
             VkImageLayout imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
@@ -79,7 +79,7 @@ namespace vks
     public:
         void buildFromImages(const std::vector<std::string>& mapDic, uint32_t textureSize,
                              VkFormat _format,
-                             vks::VulkanDevice *_device,
+                             vke::VulkanDevice *_device,
                              VkQueue copyQueue,
                              VkImageUsageFlags _imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
                              VkImageLayout _imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL){
@@ -173,7 +173,7 @@ namespace vks
         void loadFromFile(
             std::string filename,
             VkFormat format,
-            vks::VulkanDevice *_device,
+            vke::VulkanDevice *_device,
             VkImageUsageFlags imageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT,
             VkImageLayout _imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
         {
@@ -207,7 +207,7 @@ namespace vks
 
             imageLayout = _imageLayout;
 
-            vks::Buffer stagingBuffer;
+            vke::Buffer stagingBuffer;
             stagingBuffer.create (device,
                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
diff --git a/src/VulkanglTFModel.hpp b/src/VulkanglTFModel.hpp
index 453c2d5..362e68a 100644
--- a/src/VulkanglTFModel.hpp
+++ b/src/VulkanglTFModel.hpp
@@ -1,4 +1,4 @@
-/*
+/*
 * Vulkan glTF model and texture loading class based on tinyglTF (https://github.com/syoyo/tinygltf)
 *
 * Copyright (C) 2018 by Sascha Willems - www.saschawillems.de
@@ -101,24 +101,24 @@ namespace vkglTF
             glm::vec2 uv;
         };
 
-        vks::VulkanDevice*  device;
+        vke::VulkanDevice*  device;
 
         //vertices list are kept for meshLoading only (usefull for bullet lowpoly meshes without texture or material
         //their are cleared for normal loading
         std::vector<uint32_t>       indices;
         std::vector<Vertex>         vertices;
-        std::vector<vks::Texture>   textures;
+        std::vector<vke::Texture>   textures;
         std::vector<Material>       materials;
         std::map<std::string, int>  materialsNames;
         std::vector<uint32_t>       instances;//TODO:should store part idx and count
         std::vector<InstanceData>   instanceDatas;
 
-        vks::Buffer     vbo;
-        vks::Buffer     ibo;
-        vks::Buffer     vboInstances;
-        vks::Buffer     uboMaterials;
+        vke::Buffer     vbo;
+        vke::Buffer     ibo;
+        vke::Buffer     vboInstances;
+        vke::Buffer     uboMaterials;
 
-        vks::Texture*   texAtlas        = NULL;//array of all textuures used by model
+        vke::Texture*   texAtlas        = NULL;//array of all textuures used by model
         VkDescriptorSet descriptorSet   = VK_NULL_HANDLE;//atlas sampler and materials ubo, defined by pbr renderer
 
         std::vector<Primitive> primitives;
@@ -135,7 +135,7 @@ namespace vkglTF
                 delete (texAtlas);
             }
 
-            for (vks::Texture texture : textures)
+            for (vke::Texture texture : textures)
                 texture.destroy();
         }
 
@@ -165,9 +165,8 @@ namespace vkglTF
             localNodeMatrix = parentMatrix * localNodeMatrix;
 
             // Parent node with children
-            if (node.children.size() > 0)
-                for (uint i = 0; i < node.children.size(); i++)
-                    loadNode(model.nodes[node.children[i]], localNodeMatrix, model, indexBuffer, vertexBuffer, globalscale);
+            for (uint i = 0; i < node.children.size(); i++)
+                loadNode(model.nodes[node.children[i]], localNodeMatrix, model, indexBuffer, vertexBuffer, globalscale);
 
             // Node contains mesh data
             if (node.mesh > -1) {
@@ -276,7 +275,7 @@ namespace vkglTF
             }
         }
 
-        void loadImages(tinygltf::Model &gltfModel, vks::VulkanDevice *device, VkQueue copyQueue, bool loadOnly = false)
+        void loadImages(tinygltf::Model &gltfModel, vke::VulkanDevice *device, VkQueue copyQueue, bool loadOnly = false)
         {
             for (tinygltf::Image &gltfimage : gltfModel.images) {
                 std::cout << "gltf image loading: " << gltfimage.name << std::endl << std::flush;
@@ -317,7 +316,7 @@ namespace vkglTF
                 uint32_t mipLevels = loadOnly ? 1 :
                             static_cast<uint32_t>(floor(log2(std::max(gltfimage.width, gltfimage.height))) + 1.0);
 
-                vks::Texture texture;
+                vke::Texture texture;
 
                 texture.create(device,
                        VK_IMAGE_TYPE_2D,VK_FORMAT_R8G8B8A8_UNORM, gltfimage.width, gltfimage.height,
@@ -394,7 +393,7 @@ namespace vkglTF
             }
         }
 
-        void loadFromFile(std::string filename, vks::VulkanDevice* _device,
+        void loadFromFile(std::string filename, vke::VulkanDevice* _device,
                           bool instancedRendering = false, float scale = 1.0f, bool meshOnly = false)
         {
             device = _device;//should be set in CTOR
@@ -422,8 +421,8 @@ namespace vkglTF
                 if (!meshOnly) {
                     loadImages(gltfModel, device, device->queue, instancedRendering);
                     if (instancedRendering){
-                        texAtlas = new vks::Texture(device, device->queue, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, textures, textureSize, textureSize);
-                        for (vks::Texture texture : textures){
+                        texAtlas = new vke::Texture(device, device->queue, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM, textures, textureSize, textureSize);
+                        for (vke::Texture texture : textures){
                             texture.destroy();
                         }
                         textures.clear();
@@ -453,7 +452,7 @@ namespace vkglTF
 
             assert((vertexBufferSize > 0) && (indexBufferSize > 0));
 
-            vks::Buffer vertexStaging, indexStaging;
+            vke::Buffer vertexStaging, indexStaging;
             vertexStaging.create (device,
                 VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
@@ -528,7 +527,7 @@ namespace vkglTF
             std::map<std::string, int>::iterator it = materialsNames.find(_name);
             return it == materialsNames.end() ? -1 : it->second;
         }
-        void allocateDescriptorSet (vks::ShadingContext* shadingCtx) {
+        void allocateDescriptorSet (vke::ShadingContext* shadingCtx) {
             descriptorSet = shadingCtx->allocateDescriptorSet(1);
 
             shadingCtx->updateDescriptorSet (descriptorSet,
diff --git a/src/pbrrenderer2.cpp b/src/pbrrenderer2.cpp
index 2161c75..7671f5b 100644
--- a/src/pbrrenderer2.cpp
+++ b/src/pbrrenderer2.cpp
@@ -2,6 +2,7 @@
 
 pbrRenderer::pbrRenderer () : vkRenderer()
 {
+    showOverlay = false;
 }
 
 pbrRenderer::~pbrRenderer() {
@@ -31,7 +32,7 @@ void pbrRenderer::prepareModels() {
 }
 
 void pbrRenderer::configurePipelineLayout () {
-    shadingCtx = new vks::ShadingContext (device, 3);
+    shadingCtx = new vke::ShadingContext (device, 3);
 
     shadingCtx->addDescriptorSetLayout(
         {//scene
@@ -251,6 +252,8 @@ void pbrRenderer::draw(VkCommandBuffer cmdBuff) {
     vkCmdBindPipeline(cmdBuff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.pbr);
     models[0].buildCommandBuffer (cmdBuff, pipelineLayout);
 
+    if (!showOverlay)
+        return;
     //full screen quad
     fullScreenTex.setImageLayout(cmdBuff, VK_IMAGE_ASPECT_COLOR_BIT,
                                  VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
@@ -528,7 +531,7 @@ void pbrRenderer::generateCubemaps()
 
     for (uint32_t target = 0; target < PREFILTEREDENV + 1; target++) {
 
-        vks::TextureCubeMap cubemap;
+        vke::TextureCubeMap cubemap;
 
         auto tStart = std::chrono::high_resolution_clock::now();
 
diff --git a/src/pbrrenderer2.h b/src/pbrrenderer2.h
index b6a5f80..c8073c4 100644
--- a/src/pbrrenderer2.h
+++ b/src/pbrrenderer2.h
@@ -6,7 +6,7 @@
 #include "VulkanglTFModel.hpp"
 
 
-class pbrRenderer : public vks::vkRenderer
+class pbrRenderer : public vke::vkRenderer
 {
     void generateBRDFLUT();
     void generateCubemaps();
@@ -25,13 +25,14 @@ public:
 
     VkDescriptorSet         dsScene;
 
-    vks::Texture            fullScreenTex;
+    vke::Texture            fullScreenTex;
+    bool                    showOverlay;
 
     struct Textures {
-        vks::TextureCubeMap environmentCube;
-        vks::Texture2D      lutBrdf;
-        vks::TextureCubeMap irradianceCube;
-        vks::TextureCubeMap prefilteredCube;
+        vke::TextureCubeMap environmentCube;
+        vke::Texture2D      lutBrdf;
+        vke::TextureCubeMap irradianceCube;
+        vke::TextureCubeMap prefilteredCube;
     } textures;
 
     vkglTF::Model               skybox;
diff --git a/src/rendertarget.cpp b/src/rendertarget.cpp
index b226dc7..cee04da 100644
--- a/src/rendertarget.cpp
+++ b/src/rendertarget.cpp
@@ -4,12 +4,12 @@
 #include "VulkanSwapChain.hpp"
 
 
-vks::RenderTarget::RenderTarget(ptrVkDev _device, VkSampleCountFlagBits _samples) {
+vke::RenderTarget::RenderTarget(ptrVkDev _device, VkSampleCountFlagBits _samples) {
     device = _device;
     samples = _samples;
 }
 
-vks::RenderTarget::~RenderTarget () {
+vke::RenderTarget::~RenderTarget () {
     if (swapChain)
         swapChain->boundRenderTargets.erase(std::remove(swapChain->boundRenderTargets.begin(),
                 swapChain->boundRenderTargets.end(), this), swapChain->boundRenderTargets.end());
@@ -24,21 +24,21 @@ vks::RenderTarget::~RenderTarget () {
 }
 
 /** @brief destroy texture objects */
-void vks::RenderTarget::cleanupAttachments () {
+void vke::RenderTarget::cleanupAttachments () {
     for(uint i=0; i<attachments.size(); i++)
         if (i!=presentableAttachment)
             attachments[i].destroy();
     attachments.clear();
 }
 
-void vks::RenderTarget::createDefaultOffscreenTarget (uint32_t _width, uint32_t _height, VkFormat _colorFormat, VkFormat _depthFormat) {
+void vke::RenderTarget::createDefaultOffscreenTarget (uint32_t _width, uint32_t _height, VkFormat _colorFormat, VkFormat _depthFormat) {
     width   = _width;
     height  = _height;
 
     createAttachments (swapChain->infos.imageFormat, swapChain->depthFormat);
 
 }
-void vks::RenderTarget::createDefaultPresentableTarget (ptrSwapchain _swapChain) {
+void vke::RenderTarget::createDefaultPresentableTarget (ptrSwapchain _swapChain) {
     swapChain = _swapChain;
     swapChain->boundRenderTargets.push_back (this);
 
@@ -50,7 +50,7 @@ void vks::RenderTarget::createDefaultPresentableTarget (ptrSwapchain _swapChain)
     createFrameBuffers();
 }
 
-void vks::RenderTarget::updateSize () {
+void vke::RenderTarget::updateSize () {
     for (uint32_t i = 0; i < frameBuffers.size(); i++)
         vkDestroyFramebuffer(swapChain->vke->device->dev, frameBuffers[i], nullptr);
 
@@ -62,19 +62,19 @@ void vks::RenderTarget::updateSize () {
     createAttachments (swapChain->infos.imageFormat, swapChain->depthFormat);
 }
 
-void vks::RenderTarget::createAttachments (VkFormat _colorFormat, VkFormat _depthFormat) {
+void vke::RenderTarget::createAttachments (VkFormat _colorFormat, VkFormat _depthFormat) {
     if (samples > VK_SAMPLE_COUNT_1_BIT) {
         attachments.resize(3);
         presentableAttachment = 2;
 
-        attachments[0] = vks::Texture(device, VK_IMAGE_TYPE_2D, _colorFormat,
+        attachments[0] = vke::Texture(device, VK_IMAGE_TYPE_2D, _colorFormat,
                                       width, height,
                                       VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
                                       VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_TILING_OPTIMAL, 1, 1, 0,
                                       samples);
         attachments[0].createView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT,1,1);
 
-        attachments[1] = vks::Texture(device, VK_IMAGE_TYPE_2D, _depthFormat,
+        attachments[1] = vke::Texture(device, VK_IMAGE_TYPE_2D, _depthFormat,
                                       width, height,
                                       VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
                                       VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_TILING_OPTIMAL, 1, 1, 0,
@@ -83,14 +83,14 @@ void vks::RenderTarget::createAttachments (VkFormat _colorFormat, VkFormat _dept
     }else {
         attachments.resize(2);
         presentableAttachment = 0;
-        attachments[1] = vks::Texture(device, VK_IMAGE_TYPE_2D, _depthFormat,
+        attachments[1] = vke::Texture(device, VK_IMAGE_TYPE_2D, _depthFormat,
                                       width, height,
                                       VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
         attachments[1].createView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT);
     }
 }
 
-void vks::RenderTarget::createFrameBuffers()
+void vke::RenderTarget::createFrameBuffers()
 {
     std::vector<VkImageView> views;
     views.resize(attachments.size());
@@ -120,7 +120,7 @@ void vks::RenderTarget::createFrameBuffers()
     }
 }
 
-void vks::RenderTarget::createDefaultRenderPass () {
+void vke::RenderTarget::createDefaultRenderPass () {
     VkAttachmentDescription rpAttachments[] = {
         {0, //color
             attachments[0].infos.format, samples,
diff --git a/src/rendertarget.hpp b/src/rendertarget.hpp
index 6f56e7d..b08f2de 100644
--- a/src/rendertarget.hpp
+++ b/src/rendertarget.hpp
@@ -3,7 +3,7 @@
 #include "vke.h"
 #include "texture.hpp"
 
-namespace vks {
+namespace vke {
     enum AttachmentType {ColorAttach, DepthAttach, ResolveAttach};
 
     struct AttachmentDef {
@@ -22,7 +22,7 @@ namespace vks {
         uint32_t                    height;
         VkSampleCountFlagBits       samples;
         std::vector<AttachmentDef>  attachmentDefs;
-        std::vector<vks::Texture>   attachments;
+        std::vector<vke::Texture>   attachments;
         int                         presentableAttachment = -1;
 
         ptrSwapchain    			swapChain   = nullptr;
diff --git a/src/resource.hpp b/src/resource.hpp
index ba198b2..c8acaf1 100644
--- a/src/resource.hpp
+++ b/src/resource.hpp
@@ -2,7 +2,7 @@
 
 #include "vke.h"
 
-namespace vks {
+namespace vke {
     struct Resource
     {
         ptrVkDev                device;
diff --git a/src/shadingcontext.hpp b/src/shadingcontext.hpp
index ed7880e..128d9da 100644
--- a/src/shadingcontext.hpp
+++ b/src/shadingcontext.hpp
@@ -2,7 +2,7 @@
 
 #include "VkEngine.h"
 
-namespace vks {
+namespace vke {
     struct BindingSlot {
         uint layoutIdx;
         uint descriptorIdx;
@@ -12,7 +12,7 @@ namespace vks {
     //should be thread safe with dedicate desc and cmd pools
     class ShadingContext
     {
-        vks::VulkanDevice*					device;
+        vke::VulkanDevice*					device;
         VkDescriptorPool					descriptorPool;
         VkCommandPool                       cmdPool;//?
 
@@ -24,7 +24,7 @@ namespace vks {
     public:
         std::vector<VkDescriptorSetLayout>	layouts;
 
-        ShadingContext(vks::VulkanDevice* _device, uint32_t maxDescriptorSet = 1) {
+        ShadingContext(vke::VulkanDevice* _device, uint32_t maxDescriptorSet = 1) {
             device = _device;
             maxSets = maxDescriptorSet;
         }
diff --git a/src/texture.cpp b/src/texture.cpp
index 68101fc..e11cf07 100644
--- a/src/texture.cpp
+++ b/src/texture.cpp
@@ -3,7 +3,7 @@
 #include "VulkanBuffer.hpp"
 #include "stb_image.h"
 
-namespace vks
+namespace vke
 {
     void Texture::create (ptrVkDev _device,
                     VkImageType imageType, VkFormat format, uint32_t width, uint32_t height,
@@ -73,7 +73,13 @@ namespace vks
                VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | _usage,
                VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_IMAGE_TILING_OPTIMAL, mipLevels, texArray.size());
 
-        VkCommandBuffer blitCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+        VkCommandBuffer blitCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true, true);
+
+        setImageLayout(blitCmd,
+                VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
+                VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                {VK_IMAGE_ASPECT_COLOR_BIT,0,(uint)texArray.size(),0,1},
+                VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
         //imageLayout = _imageLayout;
         for (uint l = 0; l < texArray.size(); l++) {
@@ -89,24 +95,25 @@ namespace vks
 
             VkImageSubresourceRange mipSubRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, l, 1};
 
-            inTex->setImageLayout(blitCmd, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+            inTex->setImageLayout(blitCmd,
+                    VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+                    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                     {VK_IMAGE_ASPECT_COLOR_BIT,0,1,0,1},
                     VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
-            // Transiton current array level to transfer dest
-            setImageLayout(blitCmd, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                    mipSubRange,
-                    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 
             vkCmdBlitImage(blitCmd, inTex->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &firstMipBlit, VK_FILTER_LINEAR);
 
-            setImageLayout(blitCmd, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, mipSubRange,
-                                    VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
-
             /*setImageLayout(blitCmd, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                     mipSubRange,
                     VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);*/
         }
-        //device->flushCommandBuffer(blitCmd, copyQueue, true);
+
+        setImageLayout(blitCmd,
+                       VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+                       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                       {VK_IMAGE_ASPECT_COLOR_BIT,0,(uint)texArray.size(),0,1},
+                       VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
+
         buildMipmaps(copyQueue, blitCmd);
 
         device->flushCommandBuffer(blitCmd, copyQueue, true);
@@ -157,6 +164,9 @@ namespace vks
     {
         // Create an image barrier object
         VkImageMemoryBarrier imageMemoryBarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
+        imageMemoryBarrier.pNext = VK_NULL_HANDLE;
+        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
         imageMemoryBarrier.oldLayout = oldImageLayout;
         imageMemoryBarrier.newLayout = newImageLayout;
         imageMemoryBarrier.image = image;
@@ -280,6 +290,49 @@ namespace vks
         setImageLayout(cmdbuffer, oldImageLayout, newImageLayout, {aspectMask,0,1,0,1}, srcStageMask, dstStageMask);
     }
 
+    void Texture::setImageLayout(
+        VkCommandBuffer cmdbuffer,
+        VkImageAspectFlags aspectMask,
+        VkAccessFlags srcAccessMask,
+        VkAccessFlags dstAccessMask,
+        VkImageLayout oldImageLayout,
+        VkImageLayout newImageLayout,
+        VkPipelineStageFlags srcStageMask,
+        VkPipelineStageFlags dstStageMask)
+    {
+        setImageLayout(cmdbuffer, srcAccessMask, dstAccessMask,  oldImageLayout, newImageLayout, {aspectMask,0,1,0,1}, srcStageMask, dstStageMask);
+    }
+    void Texture::setImageLayout(
+            VkCommandBuffer cmdbuffer,
+            VkAccessFlags srcAccessMask,
+            VkAccessFlags dstAccessMask,
+            VkImageLayout oldImageLayout,
+            VkImageLayout newImageLayout,
+            VkImageSubresourceRange subresourceRange,
+            VkPipelineStageFlags srcStageMask,
+            VkPipelineStageFlags dstStageMask){
+
+        VkImageMemoryBarrier imageMemoryBarrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
+        imageMemoryBarrier.pNext = VK_NULL_HANDLE;
+        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+        imageMemoryBarrier.srcAccessMask = srcAccessMask;
+        imageMemoryBarrier.dstAccessMask = dstAccessMask;
+        imageMemoryBarrier.oldLayout = oldImageLayout;
+        imageMemoryBarrier.newLayout = newImageLayout;
+        imageMemoryBarrier.image = image;
+        imageMemoryBarrier.subresourceRange = subresourceRange;
+
+        vkCmdPipelineBarrier(
+            cmdbuffer,
+            srcStageMask,
+            dstStageMask,
+            0,
+            0, nullptr,
+            0, nullptr,
+            1, &imageMemoryBarrier);
+    }
+
     void Texture::copyTo (VkQueue copyQueue, unsigned char* buffer, VkDeviceSize bufferSize) {
         Buffer stagingBuffer;
         stagingBuffer.create (device, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
@@ -288,9 +341,10 @@ namespace vks
 
         descriptor.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 
-        VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
+        VkCommandBuffer copyCmd = device->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true, true);
 
         setImageLayout (copyCmd, VK_IMAGE_ASPECT_COLOR_BIT,
+                       VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                        VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 
@@ -301,6 +355,7 @@ namespace vks
         vkCmdCopyBufferToImage(copyCmd, stagingBuffer.buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &bufferCopyRegion);
 
         setImageLayout(copyCmd, VK_IMAGE_ASPECT_COLOR_BIT,
+                       VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                        VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
 
diff --git a/src/texture.hpp b/src/texture.hpp
index 819f1c2..103dbff 100644
--- a/src/texture.hpp
+++ b/src/texture.hpp
@@ -3,7 +3,7 @@
 #include "vke.h"
 #include "resource.hpp"
 
-namespace vks
+namespace vke
 {
     struct Texture : public Resource {
         VkImage             image       = VK_NULL_HANDLE;
@@ -63,6 +63,26 @@ namespace vks
             VkPipelineStageFlags srcStageMask,
             VkPipelineStageFlags dstStageMask);
 
+        void setImageLayout(
+                VkCommandBuffer cmdbuffer,
+                VkImageAspectFlags aspectMask,
+                VkAccessFlags srcAccessMask,
+                VkAccessFlags dstAccessMask,
+                VkImageLayout oldImageLayout,
+                VkImageLayout newImageLayout,
+                VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+
+        void setImageLayout(
+                VkCommandBuffer cmdbuffer,
+                VkAccessFlags srcAccessMask,
+                VkAccessFlags dstAccessMask,
+                VkImageLayout oldImageLayout,
+                VkImageLayout newImageLayout,
+                VkImageSubresourceRange subresourceRange,
+                VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+
         void copyTo (VkQueue copyQueue, unsigned char* buffer, VkDeviceSize bufferSize);
         void createView (VkImageViewType viewType, VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                          uint32_t levelCount = 1, uint32_t layerCount = 1, VkComponentMapping components =
diff --git a/src/vkrenderer.cpp b/src/vkrenderer.cpp
index ec72c61..72da990 100644
--- a/src/vkrenderer.cpp
+++ b/src/vkrenderer.cpp
@@ -3,9 +3,9 @@
 
 const VkPipelineStageFlags stageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 
-vks::vkRenderer::vkRenderer () {}
+vke::vkRenderer::vkRenderer () {}
 
-void vks::vkRenderer::create(ptrVkDev _device, vks::RenderTarget *_renderTarget,
+void vke::vkRenderer::create(ptrVkDev _device, vke::RenderTarget *_renderTarget,
                    VkEngine::UniformBuffers& _sharedUbos) {
     renderTarget= _renderTarget;
     device      = _device;
@@ -13,13 +13,13 @@ void vks::vkRenderer::create(ptrVkDev _device, vks::RenderTarget *_renderTarget,
 
     prepare();
 }
-vks::vkRenderer::~vkRenderer()
+vke::vkRenderer::~vkRenderer()
 {
     if (prepared)
         destroy();
 }
 
-void vks::vkRenderer::destroy() {
+void vke::vkRenderer::destroy() {
     prepared = false;
 
     freeRessources();
@@ -40,7 +40,7 @@ void vks::vkRenderer::destroy() {
     pipelineLayout  = VK_NULL_HANDLE;
     commandPool     = VK_NULL_HANDLE;
 }
-void vks::vkRenderer::prepare() {
+void vke::vkRenderer::prepare() {
     fences.resize (renderTarget->swapChain->imageCount);
     for (uint i=0; i<renderTarget->swapChain->imageCount; i++)
         fences[i] = device->createFence(true);
@@ -76,13 +76,13 @@ void vks::vkRenderer::prepare() {
     prepared = true;
 }
 
-void vks::vkRenderer::prepareRendering()
+void vke::vkRenderer::prepareRendering()
 {
 
 }
 
-void vks::vkRenderer::configurePipelineLayout () {
-    shadingCtx = new vks::ShadingContext (device);
+void vke::vkRenderer::configurePipelineLayout () {
+    shadingCtx = new vke::ShadingContext (device);
 
     shadingCtx->addDescriptorSetLayout({{ 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_VERTEX_BIT, nullptr }});
 
@@ -90,7 +90,7 @@ void vks::vkRenderer::configurePipelineLayout () {
 
 }
 //place here specific renderer resources
-void vks::vkRenderer::loadRessources() {
+void vke::vkRenderer::loadRessources() {
     vertexBuff.create (device,
         VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
@@ -99,17 +99,17 @@ void vks::vkRenderer::loadRessources() {
     vertexBuff.map();
 }
 //and free here
-void vks::vkRenderer::freeRessources() {
+void vke::vkRenderer::freeRessources() {
     vertexBuff.unmap();
     vertexBuff.destroy();
 }
-void vks::vkRenderer::prepareDescriptors()
+void vke::vkRenderer::prepareDescriptors()
 {
     descriptorSet = shadingCtx->allocateDescriptorSet(0);
 
     shadingCtx->updateDescriptorSet (descriptorSet,{{0,0,&sharedUBOs.matrices}});
 }
-void vks::vkRenderer::preparePipeline()
+void vke::vkRenderer::preparePipeline()
 {
     VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = {VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
     inputAssemblyStateCI.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
@@ -204,7 +204,7 @@ void vks::vkRenderer::preparePipeline()
     for (auto shaderStage : shaderStages)
         vkDestroyShaderModule(device->dev, shaderStage.module, nullptr);
 }
-void vks::vkRenderer::draw(VkCommandBuffer cmdBuff) {
+void vke::vkRenderer::draw(VkCommandBuffer cmdBuff) {
     VkDeviceSize offsets[1] = { 0 };
 
     vkCmdBindPipeline (cmdBuff, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
@@ -212,7 +212,7 @@ void vks::vkRenderer::draw(VkCommandBuffer cmdBuff) {
     vkCmdBindVertexBuffers (cmdBuff, 0, 1, &vertexBuff.buffer, offsets);
     vkCmdDraw (cmdBuff,  vertexCount, 1, 0, 0);
 }
-void vks::vkRenderer::rebuildCommandBuffer () {
+void vke::vkRenderer::rebuildCommandBuffer () {
     prepared = false;
     vkDeviceWaitIdle(device->dev);
     vkFreeCommandBuffers(device->dev, commandPool, cmdBuffers.size(), cmdBuffers.data());
@@ -227,7 +227,7 @@ void vks::vkRenderer::rebuildCommandBuffer () {
     buildCommandBuffer();
     vkDeviceWaitIdle(device->dev);
 }
-void vks::vkRenderer::buildCommandBuffer (){
+void vke::vkRenderer::buildCommandBuffer (){
     prepared = false;
 
     VkCommandBufferBeginInfo cmdBufInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
@@ -272,7 +272,7 @@ void vks::vkRenderer::buildCommandBuffer (){
     prepared = true;
 }
 
-void vks::vkRenderer::submit (VkQueue queue, VkSemaphore* waitSemaphore, uint32_t waitSemaphoreCount) {
+void vke::vkRenderer::submit (VkQueue queue, VkSemaphore* waitSemaphore, uint32_t waitSemaphoreCount) {
     if (!prepared)
         return;
     submitInfo.pCommandBuffers		= &cmdBuffers[renderTarget->swapChain->currentBuffer];
@@ -284,19 +284,19 @@ void vks::vkRenderer::submit (VkQueue queue, VkSemaphore* waitSemaphore, uint32_
 
     VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, fences[renderTarget->swapChain->currentBuffer]));
 }
-void vks::vkRenderer::clear(){
+void vke::vkRenderer::clear(){
     vertices.clear();
     vertexCount = 0;
 }
 
-void vks::vkRenderer::flush(){
+void vke::vkRenderer::flush(){
     VK_CHECK_RESULT(vkWaitForFences(device->dev, 1, &fences[renderTarget->swapChain->currentBuffer], VK_TRUE, DRAW_FENCE_TIMEOUT));
     memcpy(vertexBuff.mapped, vertices.data(), vertices.size() * sizeof(float));
     vertexCount = vertices.size() / 6;
     buildCommandBuffer();
 }
 
-void vks::vkRenderer::drawLine(const glm::vec3& from, const glm::vec3& to,
+void vke::vkRenderer::drawLine(const glm::vec3& from, const glm::vec3& to,
                           const glm::vec3& fromColor, const glm::vec3& toColor)
 {
     vertices.push_back(from.x);
@@ -316,7 +316,7 @@ void vks::vkRenderer::drawLine(const glm::vec3& from, const glm::vec3& to,
     vertices.push_back(toColor.z);
 }
 
-void vks::vkRenderer::drawLine(const glm::vec3& from, const glm::vec3& to, const glm::vec3& color)
+void vke::vkRenderer::drawLine(const glm::vec3& from, const glm::vec3& to, const glm::vec3& color)
 {
     drawLine(from,to,color,color);
 }
diff --git a/src/vkrenderer.h b/src/vkrenderer.h
index d1c7aec..e44c218 100644
--- a/src/vkrenderer.h
+++ b/src/vkrenderer.h
@@ -5,7 +5,7 @@
 
 #define DRAW_FENCE_TIMEOUT 99900000
 
-namespace vks {
+namespace vke {
 
     class vkRenderer
     {
@@ -13,11 +13,11 @@ namespace vks {
 
         bool prepared = false;
 
-        vks::VulkanDevice*          device;
-        vks::RenderTarget*          renderTarget;
-        vks::VkEngine::UniformBuffers sharedUBOs;
+        vke::VulkanDevice*          device;
+        vke::RenderTarget*          renderTarget;
+        vke::VkEngine::UniformBuffers sharedUBOs;
 
-        vks::ShadingContext*        shadingCtx;
+        vke::ShadingContext*        shadingCtx;
 
         VkCommandPool               commandPool = VK_NULL_HANDLE;
         std::vector<VkCommandBuffer>cmdBuffers;
@@ -31,7 +31,7 @@ namespace vks {
         VkPipelineLayout        pipelineLayout  = VK_NULL_HANDLE;
 
         std::vector<float>	vertices;
-        vks::Buffer			vertexBuff;
+        vke::Buffer			vertexBuff;
         uint32_t			vBufferSize = 10000 * sizeof(float) * 6;
 
         virtual void prepare();
@@ -50,7 +50,7 @@ namespace vks {
         vkRenderer ();
         virtual ~vkRenderer();
 
-        virtual void create (ptrVkDev _device, vks::RenderTarget* _renderTarget,
+        virtual void create (ptrVkDev _device, vke::RenderTarget* _renderTarget,
                                                VkEngine::UniformBuffers& _sharedUbos);
         virtual void destroy();