Changed folder structure and refactored CMakeLists.txt file.

Project/Tutorials/01/Tutorial01.cpp

@@ -0,0 +1,284 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <vector>
+#include "Tutorial01.h"
+#include "VulkanFunctions.h"
+
+namespace ApiWithoutSecrets {
+
+  Tutorial01::Tutorial01() :
+    VulkanLibrary(),
+    Vulkan() {
+  }
+
+  bool Tutorial01::OnWindowSizeChanged() {
+    return true;
+  }
+
+  bool Tutorial01::Draw() {
+    return true;
+  }
+
+  bool Tutorial01::PrepareVulkan() {
+    if( !LoadVulkanLibrary() ) {
+      return false;
+    }
+    if( !LoadExportedEntryPoints() ) {
+      return false;
+    }
+    if( !LoadGlobalLevelEntryPoints() ) {
+      return false;
+    }
+    if( !CreateInstance() ) {
+      return false;
+    }
+    if( !LoadInstanceLevelEntryPoints() ) {
+      return false;
+    }
+    if( !CreateDevice() ) {
+      return false;
+    }
+    if( !LoadDeviceLevelEntryPoints() ) {
+      return false;
+    }
+    if( !GetDeviceQueue() ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial01::LoadVulkanLibrary() {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    VulkanLibrary = LoadLibrary( "vulkan-1.dll" );
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+    VulkanLibrary = dlopen( "libvulkan.so.1", RTLD_NOW );
+#endif
+
+    if( VulkanLibrary == nullptr ) {
+      std::cout << "Could not load Vulkan library!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial01::LoadExportedEntryPoints() {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    #define LoadProcAddress GetProcAddress
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+    #define LoadProcAddress dlsym
+#endif
+
+#define VK_EXPORTED_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)LoadProcAddress( VulkanLibrary, #fun )) ) {                \
+      std::cout << "Could not load exported function: " << #fun << "!" << std::endl;  \
+      return false;                                                                   \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial01::LoadGlobalLevelEntryPoints() {
+#define VK_GLOBAL_LEVEL_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( nullptr, #fun )) ) {                    \
+      std::cout << "Could not load global level function: " << #fun << "!" << std::endl;  \
+      return false;                                                                       \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial01::CreateInstance() {
+    VkApplicationInfo application_info = {
+      VK_STRUCTURE_TYPE_APPLICATION_INFO,             // VkStructureType            sType
+      nullptr,                                        // const void                *pNext
+      "API without Secrets: Introduction to Vulkan",  // const char                *pApplicationName
+      VK_MAKE_VERSION( 1, 0, 0 ),                     // uint32_t                   applicationVersion
+      "Vulkan Tutorial by Intel",                     // const char                *pEngineName
+      VK_MAKE_VERSION( 1, 0, 0 ),                     // uint32_t                   engineVersion
+      VK_MAKE_VERSION( 1, 0, 0 )                      // uint32_t                   apiVersion
+    };
+
+    VkInstanceCreateInfo instance_create_info = {
+      VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,         // VkStructureType            sType
+      nullptr,                                        // const void*                pNext
+      0,                                              // VkInstanceCreateFlags      flags
+      &application_info,                              // const VkApplicationInfo   *pApplicationInfo
+      0,                                              // uint32_t                   enabledLayerCount
+      nullptr,                                        // const char * const        *ppEnabledLayerNames
+      0,                                              // uint32_t                   enabledExtensionCount
+      nullptr                                         // const char * const        *ppEnabledExtensionNames
+    };
+
+    if( vkCreateInstance( &instance_create_info, nullptr, &Vulkan.Instance ) != VK_SUCCESS ) {
+      std::cout << "Could not create Vulkan instance!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial01::LoadInstanceLevelEntryPoints() {
+#define VK_INSTANCE_LEVEL_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( Vulkan.Instance, #fun )) ) {              \
+      std::cout << "Could not load instance level function: " << #fun << "!" << std::endl;  \
+      return false;                                                                         \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial01::CreateDevice() {
+    uint32_t num_devices = 0;
+    if( (vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, nullptr ) != VK_SUCCESS) ||
+        (num_devices == 0) ) {
+      std::cout << "Error occurred during physical devices enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkPhysicalDevice> physical_devices( num_devices );
+    if( vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, &physical_devices[0] ) != VK_SUCCESS ) {
+      std::cout << "Error occurred during physical devices enumeration!" << std::endl;
+      return false;
+    }
+
+    VkPhysicalDevice selected_physical_device = VK_NULL_HANDLE;
+    uint32_t selected_queue_family_index = UINT32_MAX;
+    for( uint32_t i = 0; i < num_devices; ++i ) {
+      if( CheckPhysicalDeviceProperties( physical_devices[i], selected_queue_family_index ) ) {
+        selected_physical_device = physical_devices[i];
+        break;
+      }
+    }
+    if( selected_physical_device == VK_NULL_HANDLE ) {
+      std::cout << "Could not select physical device based on the chosen properties!" << std::endl;
+      return false;
+    }
+
+    std::vector<float> queue_priorities = { 1.0f };
+
+    VkDeviceQueueCreateInfo queue_create_info = {
+      VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,     // VkStructureType              sType
+      nullptr,                                        // const void                  *pNext
+      0,                                              // VkDeviceQueueCreateFlags     flags
+      selected_queue_family_index,                    // uint32_t                     queueFamilyIndex
+      static_cast<uint32_t>(queue_priorities.size()), // uint32_t                     queueCount
+      &queue_priorities[0]                            // const float                 *pQueuePriorities
+    };
+
+    VkDeviceCreateInfo device_create_info = {
+      VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,           // VkStructureType                    sType
+      nullptr,                                        // const void                        *pNext
+      0,                                              // VkDeviceCreateFlags                flags
+      1,                                              // uint32_t                           queueCreateInfoCount
+      &queue_create_info,                             // const VkDeviceQueueCreateInfo     *pQueueCreateInfos
+      0,                                              // uint32_t                           enabledLayerCount
+      nullptr,                                        // const char * const                *ppEnabledLayerNames
+      0,                                              // uint32_t                           enabledExtensionCount
+      nullptr,                                        // const char * const                *ppEnabledExtensionNames
+      nullptr                                         // const VkPhysicalDeviceFeatures    *pEnabledFeatures
+    };
+
+    if( vkCreateDevice( selected_physical_device, &device_create_info, nullptr, &Vulkan.Device ) != VK_SUCCESS ) {
+      std::cout << "Could not create Vulkan device!" << std::endl;
+      return false;
+    }
+
+    Vulkan.QueueFamilyIndex = selected_queue_family_index;
+    return true;
+  }
+
+  bool Tutorial01::CheckPhysicalDeviceProperties( VkPhysicalDevice physical_device, uint32_t &queue_family_index ) {
+    VkPhysicalDeviceProperties device_properties;
+    VkPhysicalDeviceFeatures   device_features;
+
+    vkGetPhysicalDeviceProperties( physical_device, &device_properties );
+    vkGetPhysicalDeviceFeatures( physical_device, &device_features );
+
+    uint32_t major_version = VK_VERSION_MAJOR( device_properties.apiVersion );
+    uint32_t minor_version = VK_VERSION_MINOR( device_properties.apiVersion );
+    uint32_t patch_version = VK_VERSION_PATCH( device_properties.apiVersion );
+
+    if( (major_version < 1) ||
+        (device_properties.limits.maxImageDimension2D < 4096) ) {
+      std::cout << "Physical device " << physical_device << " doesn't support required parameters!" << std::endl;
+      return false;
+    }
+
+    uint32_t queue_families_count = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
+    if( queue_families_count == 0 ) {
+      std::cout << "Physical device " << physical_device << " doesn't have any queue families!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkQueueFamilyProperties> queue_family_properties( queue_families_count );
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, &queue_family_properties[0] );
+    for( uint32_t i = 0; i < queue_families_count; ++i ) {
+      if( (queue_family_properties[i].queueCount > 0) &&
+          (queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) ) {
+        queue_family_index = i;
+        std::cout << "Selected device: " << device_properties.deviceName << std::endl;
+        return true;
+      }
+    }
+
+    std::cout << "Could not find queue family with required properties on physical device " << physical_device << "!" << std::endl;
+    return false;
+  }
+
+  bool Tutorial01::LoadDeviceLevelEntryPoints() {
+#define VK_DEVICE_LEVEL_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)vkGetDeviceProcAddr( Vulkan.Device, #fun )) ) {                \
+      std::cout << "Could not load device level function: " << #fun << "!" << std::endl;  \
+      return false;                                                                       \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial01::GetDeviceQueue() {
+    vkGetDeviceQueue( Vulkan.Device, Vulkan.QueueFamilyIndex, 0, &Vulkan.Queue );
+    return true;
+  }
+
+  Tutorial01::~Tutorial01() {
+    if( Vulkan.Device != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( Vulkan.Device );
+      vkDestroyDevice( Vulkan.Device, nullptr );
+    }
+
+    if( Vulkan.Instance != VK_NULL_HANDLE ) {
+      vkDestroyInstance( Vulkan.Instance, nullptr );
+    }
+
+    if( VulkanLibrary ) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+      FreeLibrary( VulkanLibrary );
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+      dlclose( VulkanLibrary );
+#endif
+    }
+  }
+
+} // namespace ApiWithoutSecrets

Project/Tutorials/01/Tutorial01.h

@@ -0,0 +1,76 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_01_HEADER)
+#define TUTORIAL_01_HEADER
+
+#include "vulkan.h"
+#include "OperatingSystem.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // VulkanTutorial01Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial01Parameters {
+    VkInstance  Instance;
+    VkDevice    Device;
+    uint32_t    QueueFamilyIndex;
+    VkQueue     Queue;
+
+    VulkanTutorial01Parameters() :
+      Instance( VK_NULL_HANDLE ),
+      Device( VK_NULL_HANDLE ),
+      QueueFamilyIndex( 0 ),
+      Queue( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial01                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial01 : public OS::TutorialBase {
+  public:
+    Tutorial01();
+    ~Tutorial01();
+
+    bool OnWindowSizeChanged() override;
+    bool Draw() override;
+
+    bool PrepareVulkan();
+
+  private:
+    OS::LibraryHandle           VulkanLibrary;
+    VulkanTutorial01Parameters  Vulkan;
+
+    bool LoadVulkanLibrary();
+    bool LoadExportedEntryPoints();
+    bool LoadGlobalLevelEntryPoints();
+    bool CreateInstance();
+    bool LoadInstanceLevelEntryPoints();
+    bool CreateDevice();
+    bool CheckPhysicalDeviceProperties( VkPhysicalDevice physical_device, uint32_t &queue_family_index );
+    bool LoadDeviceLevelEntryPoints();
+    bool GetDeviceQueue();
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_01_HEADER

Project/Tutorials/01/main.cpp

@@ -0,0 +1,39 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial01.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial01 tutorial01;
+
+  // Window creation
+  if( !window.Create( "01 - The Beginning" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial01.PrepareVulkan() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial01 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorials/02/Tutorial02.cpp

@@ -0,0 +1,870 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial02.h"
+#include "VulkanFunctions.h"
+
+namespace ApiWithoutSecrets {
+
+  Tutorial02::Tutorial02() :
+    VulkanLibrary(),
+    Window(),
+    Vulkan() {
+  }
+
+  bool Tutorial02::PrepareVulkan( OS::WindowParameters parameters ) {
+    Window = parameters;
+
+    if( !LoadVulkanLibrary() ) {
+      return false;
+    }
+    if( !LoadExportedEntryPoints() ) {
+      return false;
+    }
+    if( !LoadGlobalLevelEntryPoints() ) {
+      return false;
+    }
+    if( !CreateInstance() ) {
+      return false;
+    }
+    if( !LoadInstanceLevelEntryPoints() ) {
+      return false;
+    }
+    if( !CreatePresentationSurface() ) {
+      return false;
+    }
+    if( !CreateDevice() ) {
+      return false;
+    }
+    if( !LoadDeviceLevelEntryPoints() ) {
+      return false;
+    }
+    if( !GetDeviceQueue() ) {
+      return false;
+    }
+    if( !CreateSemaphores() ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial02::LoadVulkanLibrary() {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    VulkanLibrary = LoadLibrary( "vulkan-1.dll" );
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+    VulkanLibrary = dlopen( "libvulkan.so.1", RTLD_NOW );
+#endif
+
+    if( VulkanLibrary == nullptr ) {
+      std::cout << "Could not load Vulkan library!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial02::LoadExportedEntryPoints() {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    #define LoadProcAddress GetProcAddress
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+    #define LoadProcAddress dlsym
+#endif
+
+#define VK_EXPORTED_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)LoadProcAddress( VulkanLibrary, #fun )) ) {                \
+      std::cout << "Could not load exported function: " << #fun << "!" << std::endl;  \
+      return false;                                                                   \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial02::LoadGlobalLevelEntryPoints() {
+#define VK_GLOBAL_LEVEL_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( nullptr, #fun )) ) {                    \
+      std::cout << "Could not load global level function: " << #fun << "!" << std::endl;  \
+      return false;                                                                       \
+    }
+
+#include "ListOfFunctions.inl"
+
+      return true;
+  }
+
+  bool Tutorial02::CreateInstance() {
+    uint32_t extensions_count = 0;
+    if( (vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, nullptr ) != VK_SUCCESS) ||
+        (extensions_count == 0) ) {
+      std::cout << "Error occurred during instance extensions enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkExtensionProperties> available_extensions( extensions_count );
+    if( vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
+      std::cout << "Error occurred during instance extensions enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<const char*> extensions = {
+      VK_KHR_SURFACE_EXTENSION_NAME,
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+      VK_KHR_WIN32_SURFACE_EXTENSION_NAME
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+      VK_KHR_XCB_SURFACE_EXTENSION_NAME
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+      VK_KHR_XLIB_SURFACE_EXTENSION_NAME
+#endif
+    };
+
+    for( size_t i = 0; i < extensions.size(); ++i ) {
+      if( !CheckExtensionAvailability( extensions[i], available_extensions ) ) {
+        std::cout << "Could not find instance extension named \"" << extensions[i] << "\"!" << std::endl;
+        return false;
+      }
+    }
+
+    VkApplicationInfo application_info = {
+      VK_STRUCTURE_TYPE_APPLICATION_INFO,             // VkStructureType            sType
+      nullptr,                                        // const void                *pNext
+      "API without Secrets: Introduction to Vulkan",  // const char                *pApplicationName
+      VK_MAKE_VERSION( 1, 0, 0 ),                     // uint32_t                   applicationVersion
+      "Vulkan Tutorial by Intel",                     // const char                *pEngineName
+      VK_MAKE_VERSION( 1, 0, 0 ),                     // uint32_t                   engineVersion
+      VK_MAKE_VERSION( 1, 0, 0 )                      // uint32_t                   apiVersion
+    };
+
+    VkInstanceCreateInfo instance_create_info = {
+      VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,         // VkStructureType            sType
+      nullptr,                                        // const void                *pNext
+      0,                                              // VkInstanceCreateFlags      flags
+      &application_info,                              // const VkApplicationInfo   *pApplicationInfo
+      0,                                              // uint32_t                   enabledLayerCount
+      nullptr,                                        // const char * const        *ppEnabledLayerNames
+      static_cast<uint32_t>(extensions.size()),       // uint32_t                   enabledExtensionCount
+      &extensions[0]                                  // const char * const        *ppEnabledExtensionNames
+    };
+
+    if( vkCreateInstance( &instance_create_info, nullptr, &Vulkan.Instance ) != VK_SUCCESS ) {
+      std::cout << "Could not create Vulkan instance!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial02::CheckExtensionAvailability( const char *extension_name, const std::vector<VkExtensionProperties> &available_extensions ) {
+    for( size_t i = 0; i < available_extensions.size(); ++i ) {
+      if( strcmp( available_extensions[i].extensionName, extension_name ) == 0 ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool Tutorial02::LoadInstanceLevelEntryPoints() {
+#define VK_INSTANCE_LEVEL_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( Vulkan.Instance, #fun )) ) {              \
+      std::cout << "Could not load instance level function: " << #fun << "!" << std::endl;  \
+      return false;                                                                         \
+    }
+
+#include "ListOfFunctions.inl"
+
+      return true;
+  }
+
+  bool Tutorial02::CreatePresentationSurface() {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    VkWin32SurfaceCreateInfoKHR surface_create_info = {
+      VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,  // VkStructureType                  sType
+      nullptr,                                          // const void                      *pNext
+      0,                                                // VkWin32SurfaceCreateFlagsKHR     flags
+      Window.Instance,                                  // HINSTANCE                        hinstance
+      Window.Handle                                     // HWND                             hwnd
+    };
+
+    if( vkCreateWin32SurfaceKHR( Vulkan.Instance, &surface_create_info, nullptr, &Vulkan.PresentationSurface ) == VK_SUCCESS ) {
+      return true;
+    }
+
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+    VkXcbSurfaceCreateInfoKHR surface_create_info = {
+      VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,    // VkStructureType                  sType
+      nullptr,                                          // const void                      *pNext
+      0,                                                // VkXcbSurfaceCreateFlagsKHR       flags
+      Window.Connection,                                // xcb_connection_t*                connection
+      Window.Handle                                     // xcb_window_t                     window
+    };
+
+    if( vkCreateXcbSurfaceKHR( Vulkan.Instance, &surface_create_info, nullptr, &Vulkan.PresentationSurface ) == VK_SUCCESS ) {
+      return true;
+    }
+
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+    VkXlibSurfaceCreateInfoKHR surface_create_info = {
+      VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,   // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkXlibSurfaceCreateFlagsKHR    flags
+      Window.DisplayPtr,                                // Display                       *dpy
+      Window.Handle                                     // Window                         window
+    };
+    if( vkCreateXlibSurfaceKHR( Vulkan.Instance, &surface_create_info, nullptr, &Vulkan.PresentationSurface ) == VK_SUCCESS ) {
+      return true;
+    }
+
+#endif
+
+    std::cout << "Could not create presentation surface!" << std::endl;
+    return false;
+  }
+
+  bool Tutorial02::CreateDevice() {
+    uint32_t num_devices = 0;
+    if( (vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, nullptr ) != VK_SUCCESS) ||
+        (num_devices == 0) ) {
+      std::cout << "Error occurred during physical devices enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkPhysicalDevice> physical_devices( num_devices );
+    if( vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, &physical_devices[0] ) != VK_SUCCESS ) {
+      std::cout << "Error occurred during physical devices enumeration!" << std::endl;
+      return false;
+    }
+
+    uint32_t selected_graphics_queue_family_index = UINT32_MAX;
+    uint32_t selected_present_queue_family_index = UINT32_MAX;
+
+    for( uint32_t i = 0; i < num_devices; ++i ) {
+      if( CheckPhysicalDeviceProperties( physical_devices[i], selected_graphics_queue_family_index, selected_present_queue_family_index ) ) {
+        Vulkan.PhysicalDevice = physical_devices[i];
+        break;
+      }
+    }
+    if( Vulkan.PhysicalDevice == VK_NULL_HANDLE ) {
+      std::cout << "Could not select physical device based on the chosen properties!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkDeviceQueueCreateInfo> queue_create_infos;
+    std::vector<float> queue_priorities = { 1.0f };
+
+    queue_create_infos.push_back( {
+      VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,       // VkStructureType              sType
+      nullptr,                                          // const void                  *pNext
+      0,                                                // VkDeviceQueueCreateFlags     flags
+      selected_graphics_queue_family_index,             // uint32_t                     queueFamilyIndex
+      static_cast<uint32_t>(queue_priorities.size()),   // uint32_t                     queueCount
+      &queue_priorities[0]                              // const float                 *pQueuePriorities
+    } );
+
+    if( selected_graphics_queue_family_index != selected_present_queue_family_index ) {
+      queue_create_infos.push_back( {
+        VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,     // VkStructureType              sType
+        nullptr,                                        // const void                  *pNext
+        0,                                              // VkDeviceQueueCreateFlags     flags
+        selected_present_queue_family_index,            // uint32_t                     queueFamilyIndex
+        static_cast<uint32_t>(queue_priorities.size()), // uint32_t                     queueCount
+        &queue_priorities[0]                            // const float                 *pQueuePriorities
+      } );
+    }
+
+    std::vector<const char*> extensions = {
+      VK_KHR_SWAPCHAIN_EXTENSION_NAME
+    };
+
+    VkDeviceCreateInfo device_create_info = {
+      VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,             // VkStructureType                    sType
+      nullptr,                                          // const void                        *pNext
+      0,                                                // VkDeviceCreateFlags                flags
+      static_cast<uint32_t>(queue_create_infos.size()), // uint32_t                           queueCreateInfoCount
+      &queue_create_infos[0],                           // const VkDeviceQueueCreateInfo     *pQueueCreateInfos
+      0,                                                // uint32_t                           enabledLayerCount
+      nullptr,                                          // const char * const                *ppEnabledLayerNames
+      static_cast<uint32_t>(extensions.size()),         // uint32_t                           enabledExtensionCount
+      &extensions[0],                                   // const char * const                *ppEnabledExtensionNames
+      nullptr                                           // const VkPhysicalDeviceFeatures    *pEnabledFeatures
+    };
+
+    if( vkCreateDevice( Vulkan.PhysicalDevice, &device_create_info, nullptr, &Vulkan.Device ) != VK_SUCCESS ) {
+      std::cout << "Could not create Vulkan device!" << std::endl;
+      return false;
+    }
+
+    Vulkan.GraphicsQueueFamilyIndex = selected_graphics_queue_family_index;
+    Vulkan.PresentQueueFamilyIndex = selected_present_queue_family_index;
+    return true;
+  }
+
+  bool Tutorial02::CheckPhysicalDeviceProperties( VkPhysicalDevice physical_device, uint32_t &selected_graphics_queue_family_index, uint32_t &selected_present_queue_family_index ) {
+    uint32_t extensions_count = 0;
+    if( (vkEnumerateDeviceExtensionProperties( physical_device, nullptr, &extensions_count, nullptr ) != VK_SUCCESS) ||
+        (extensions_count == 0) ) {
+      std::cout << "Error occurred during physical device " << physical_device << " extensions enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkExtensionProperties> available_extensions( extensions_count );
+    if( vkEnumerateDeviceExtensionProperties( physical_device, nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
+      std::cout << "Error occurred during physical device " << physical_device << " extensions enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<const char*> device_extensions = {
+      VK_KHR_SWAPCHAIN_EXTENSION_NAME
+    };
+
+    for( size_t i = 0; i < device_extensions.size(); ++i ) {
+      if( !CheckExtensionAvailability( device_extensions[i], available_extensions ) ) {
+        std::cout << "Physical device " << physical_device << " doesn't support extension named \"" << device_extensions[i] << "\"!" << std::endl;
+        return false;
+      }
+    }
+
+    VkPhysicalDeviceProperties device_properties;
+    VkPhysicalDeviceFeatures   device_features;
+
+    vkGetPhysicalDeviceProperties( physical_device, &device_properties );
+    vkGetPhysicalDeviceFeatures( physical_device, &device_features );
+
+    uint32_t major_version = VK_VERSION_MAJOR( device_properties.apiVersion );
+
+    if( (major_version < 1) ||
+        (device_properties.limits.maxImageDimension2D < 4096) ) {
+      std::cout << "Physical device " << physical_device << " doesn't support required parameters!" << std::endl;
+      return false;
+    }
+
+    uint32_t queue_families_count = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
+    if( queue_families_count == 0 ) {
+      std::cout << "Physical device " << physical_device << " doesn't have any queue families!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkQueueFamilyProperties>  queue_family_properties( queue_families_count );
+    std::vector<VkBool32>                 queue_present_support( queue_families_count );
+
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, &queue_family_properties[0] );
+
+    uint32_t graphics_queue_family_index = UINT32_MAX;
+    uint32_t present_queue_family_index = UINT32_MAX;
+
+    for( uint32_t i = 0; i < queue_families_count; ++i ) {
+      vkGetPhysicalDeviceSurfaceSupportKHR( physical_device, i, Vulkan.PresentationSurface, &queue_present_support[i] );
+
+      if( (queue_family_properties[i].queueCount > 0) &&
+          (queue_family_properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) ) {
+        // Select first queue that supports graphics
+        if( graphics_queue_family_index == UINT32_MAX ) {
+          graphics_queue_family_index = i;
+        }
+
+        // If there is queue that supports both graphics and present - prefer it
+        if( queue_present_support[i] ) {
+          selected_graphics_queue_family_index = i;
+          selected_present_queue_family_index = i;
+          return true;
+        }
+      }
+    }
+
+    // We don't have queue that supports both graphics and present so we have to use separate queues
+    for( uint32_t i = 0; i < queue_families_count; ++i ) {
+      if( queue_present_support[i] ) {
+        present_queue_family_index = i;
+        break;
+      }
+    }
+
+    // If this device doesn't support queues with graphics and present capabilities don't use it
+    if( (graphics_queue_family_index == UINT32_MAX) ||
+        (present_queue_family_index == UINT32_MAX) ) {
+      std::cout << "Could not find queue family with required properties on physical device " << physical_device << "!" << std::endl;
+      return false;
+    }
+
+    selected_graphics_queue_family_index = graphics_queue_family_index;
+    selected_present_queue_family_index = present_queue_family_index;
+    return true;
+  }
+
+  bool Tutorial02::LoadDeviceLevelEntryPoints() {
+#define VK_DEVICE_LEVEL_FUNCTION( fun )                                                   \
+    if( !(fun = (PFN_##fun)vkGetDeviceProcAddr( Vulkan.Device, #fun )) ) {                \
+      std::cout << "Could not load device level function: " << #fun << "!" << std::endl;  \
+      return false;                                                                       \
+    }
+
+#include "ListOfFunctions.inl"
+
+      return true;
+  }
+
+  bool Tutorial02::GetDeviceQueue() {
+    vkGetDeviceQueue( Vulkan.Device, Vulkan.GraphicsQueueFamilyIndex, 0, &Vulkan.GraphicsQueue );
+    vkGetDeviceQueue( Vulkan.Device, Vulkan.PresentQueueFamilyIndex, 0, &Vulkan.PresentQueue );
+    return true;
+  }
+
+  bool Tutorial02::CreateSemaphores() {
+    VkSemaphoreCreateInfo semaphore_create_info = {
+      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,      // VkStructureType          sType
+      nullptr,                                      // const void*              pNext
+      0                                             // VkSemaphoreCreateFlags   flags
+    };
+
+    if( (vkCreateSemaphore( Vulkan.Device, &semaphore_create_info, nullptr, &Vulkan.ImageAvailableSemaphore ) != VK_SUCCESS) ||
+        (vkCreateSemaphore( Vulkan.Device, &semaphore_create_info, nullptr, &Vulkan.RenderingFinishedSemaphore ) != VK_SUCCESS) ) {
+      std::cout << "Could not create semaphores!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial02::CreateSwapChain() {
+    CanRender = false;
+
+    if( Vulkan.Device != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( Vulkan.Device );
+    }
+
+    VkSurfaceCapabilitiesKHR surface_capabilities;
+    if( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &surface_capabilities ) != VK_SUCCESS ) {
+      std::cout << "Could not check presentation surface capabilities!" << std::endl;
+      return false;
+    }
+
+    uint32_t formats_count;
+    if( (vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, nullptr ) != VK_SUCCESS) ||
+        (formats_count == 0) ) {
+      std::cout << "Error occurred during presentation surface formats enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkSurfaceFormatKHR> surface_formats( formats_count );
+    if( vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, &surface_formats[0] ) != VK_SUCCESS ) {
+      std::cout << "Error occurred during presentation surface formats enumeration!" << std::endl;
+      return false;
+    }
+
+    uint32_t present_modes_count;
+    if( (vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, nullptr ) != VK_SUCCESS) ||
+        (present_modes_count == 0) ) {
+      std::cout << "Error occurred during presentation surface present modes enumeration!" << std::endl;
+      return false;
+    }
+
+    std::vector<VkPresentModeKHR> present_modes( present_modes_count );
+    if( vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, &present_modes[0] ) != VK_SUCCESS ) {
+      std::cout << "Error occurred during presentation surface present modes enumeration!" << std::endl;
+      return false;
+    }
+
+    uint32_t                      desired_number_of_images = GetSwapChainNumImages( surface_capabilities );
+    VkSurfaceFormatKHR            desired_format = GetSwapChainFormat( surface_formats );
+    VkExtent2D                    desired_extent = GetSwapChainExtent( surface_capabilities );
+    VkImageUsageFlags             desired_usage = GetSwapChainUsageFlags( surface_capabilities );
+    VkSurfaceTransformFlagBitsKHR desired_transform = GetSwapChainTransform( surface_capabilities );
+    VkPresentModeKHR              desired_present_mode = GetSwapChainPresentMode( present_modes );
+    VkSwapchainKHR                old_swap_chain = Vulkan.SwapChain;
+
+    if( static_cast<int>(desired_usage) == -1 ) {
+      return false;
+    }
+    if( static_cast<int>(desired_present_mode) == -1 ) {
+      return false;
+    }
+    if( (desired_extent.width == 0) || (desired_extent.height == 0) ) {
+      // Current surface size is (0, 0) so we can't create a swap chain and render anything (CanRender == false)
+      // But we don't wont to kill the application as this situation may occur i.e. when window gets minimized
+      return true;
+    }
+
+    VkSwapchainCreateInfoKHR swap_chain_create_info = {
+      VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,  // VkStructureType                sType
+      nullptr,                                      // const void                    *pNext
+      0,                                            // VkSwapchainCreateFlagsKHR      flags
+      Vulkan.PresentationSurface,                   // VkSurfaceKHR                   surface
+      desired_number_of_images,                     // uint32_t                       minImageCount
+      desired_format.format,                        // VkFormat                       imageFormat
+      desired_format.colorSpace,                    // VkColorSpaceKHR                imageColorSpace
+      desired_extent,                               // VkExtent2D                     imageExtent
+      1,                                            // uint32_t                       imageArrayLayers
+      desired_usage,                                // VkImageUsageFlags              imageUsage
+      VK_SHARING_MODE_EXCLUSIVE,                    // VkSharingMode                  imageSharingMode
+      0,                                            // uint32_t                       queueFamilyIndexCount
+      nullptr,                                      // const uint32_t                *pQueueFamilyIndices
+      desired_transform,                            // VkSurfaceTransformFlagBitsKHR  preTransform
+      VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,            // VkCompositeAlphaFlagBitsKHR    compositeAlpha
+      desired_present_mode,                         // VkPresentModeKHR               presentMode
+      VK_TRUE,                                      // VkBool32                       clipped
+      old_swap_chain                                // VkSwapchainKHR                 oldSwapchain
+    };
+
+    if( vkCreateSwapchainKHR( Vulkan.Device, &swap_chain_create_info, nullptr, &Vulkan.SwapChain ) != VK_SUCCESS ) {
+      std::cout << "Could not create swap chain!" << std::endl;
+      return false;
+    }
+    if( old_swap_chain != VK_NULL_HANDLE ) {
+      vkDestroySwapchainKHR( Vulkan.Device, old_swap_chain, nullptr );
+    }
+
+    CanRender = true;
+
+    return true;
+  }
+
+  uint32_t Tutorial02::GetSwapChainNumImages( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
+    // Set of images defined in a swap chain may not always be available for application to render to:
+    // One may be displayed and one may wait in a queue to be presented
+    // If application wants to use more images at the same time it must ask for more images
+    uint32_t image_count = surface_capabilities.minImageCount + 1;
+    if( (surface_capabilities.maxImageCount > 0) &&
+        (image_count > surface_capabilities.maxImageCount) ) {
+      image_count = surface_capabilities.maxImageCount;
+    }
+    return image_count;
+  }
+
+  VkSurfaceFormatKHR Tutorial02::GetSwapChainFormat( std::vector<VkSurfaceFormatKHR> &surface_formats ) {
+    // If the list contains only one entry with undefined format
+    // it means that there are no preferred surface formats and any can be chosen
+    if( (surface_formats.size() == 1) &&
+        (surface_formats[0].format == VK_FORMAT_UNDEFINED) ) {
+      return{ VK_FORMAT_R8G8B8A8_UNORM, VK_COLORSPACE_SRGB_NONLINEAR_KHR };
+    }
+
+    // Check if list contains most widely used R8 G8 B8 A8 format
+    // with nonlinear color space
+    for( VkSurfaceFormatKHR &surface_format : surface_formats ) {
+      if( surface_format.format == VK_FORMAT_R8G8B8A8_UNORM ) {
+        return surface_format;
+      }
+    }
+
+    // Return the first format from the list
+    return surface_formats[0];
+  }
+
+  VkExtent2D Tutorial02::GetSwapChainExtent( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
+    // Special value of surface extent is width == height == -1
+    // If this is so we define the size by ourselves but it must fit within defined confines
+    if( surface_capabilities.currentExtent.width == -1 ) {
+      VkExtent2D swap_chain_extent = { 640, 480 };
+      if( swap_chain_extent.width < surface_capabilities.minImageExtent.width ) {
+        swap_chain_extent.width = surface_capabilities.minImageExtent.width;
+      }
+      if( swap_chain_extent.height < surface_capabilities.minImageExtent.height ) {
+        swap_chain_extent.height = surface_capabilities.minImageExtent.height;
+      }
+      if( swap_chain_extent.width > surface_capabilities.maxImageExtent.width ) {
+        swap_chain_extent.width = surface_capabilities.maxImageExtent.width;
+      }
+      if( swap_chain_extent.height > surface_capabilities.maxImageExtent.height ) {
+        swap_chain_extent.height = surface_capabilities.maxImageExtent.height;
+      }
+      return swap_chain_extent;
+    }
+
+    // Most of the cases we define size of the swap_chain images equal to current window's size
+    return surface_capabilities.currentExtent;
+  }
+
+  VkImageUsageFlags Tutorial02::GetSwapChainUsageFlags( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
+    // Color attachment flag must always be supported
+    // We can define other usage flags but we always need to check if they are supported
+    if( surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT ) {
+      return VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+    }
+    std::cout << "VK_IMAGE_USAGE_TRANSFER_DST image usage is not supported by the swap chain!" << std::endl
+      << "Supported swap chain's image usages include:" << std::endl
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT              ? "    VK_IMAGE_USAGE_TRANSFER_SRC\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT              ? "    VK_IMAGE_USAGE_TRANSFER_DST\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT                   ? "    VK_IMAGE_USAGE_SAMPLED\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_STORAGE_BIT                   ? "    VK_IMAGE_USAGE_STORAGE\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT          ? "    VK_IMAGE_USAGE_COLOR_ATTACHMENT\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT  ? "    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT      ? "    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT\n" : "")
+      << (surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT          ? "    VK_IMAGE_USAGE_INPUT_ATTACHMENT" : "")
+      << std::endl;
+    return static_cast<VkImageUsageFlags>(-1);
+  }
+
+  VkSurfaceTransformFlagBitsKHR Tutorial02::GetSwapChainTransform( VkSurfaceCapabilitiesKHR &surface_capabilities ) {
+    // Sometimes images must be transformed before they are presented (i.e. due to device's orienation
+    // being other than default orientation)
+    // If the specified transform is other than current transform, presentation engine will transform image
+    // during presentation operation; this operation may hit performance on some platforms
+    // Here we don't want any transformations to occur so if the identity transform is supported use it
+    // otherwise just use the same transform as current transform
+    if( surface_capabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ) {
+      return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+    } else {
+      return surface_capabilities.currentTransform;
+    }
+  }
+
+  VkPresentModeKHR Tutorial02::GetSwapChainPresentMode( std::vector<VkPresentModeKHR> &present_modes ) {
+    // FIFO present mode is always available
+    // MAILBOX is the lowest latency V-Sync enabled mode (something like triple-buffering) so use it if available
+    for( VkPresentModeKHR &present_mode : present_modes ) {
+      if( present_mode == VK_PRESENT_MODE_MAILBOX_KHR ) {
+        return present_mode;
+      }
+    }
+    for( VkPresentModeKHR &present_mode : present_modes ) {
+      if( present_mode == VK_PRESENT_MODE_FIFO_KHR ) {
+        return present_mode;
+      }
+    }
+    std::cout << "FIFO present mode is not supported by the swap chain!" << std::endl;
+    return static_cast<VkPresentModeKHR>(-1);
+  }
+
+  bool Tutorial02::OnWindowSizeChanged() {
+    Clear();
+
+    if( !CreateSwapChain() ) {
+      return false;
+    }
+    if( !CreateCommandBuffers() ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial02::CreateCommandBuffers() {
+    VkCommandPoolCreateInfo cmd_pool_create_info = {
+      VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,     // VkStructureType              sType
+      nullptr,                                        // const void*                  pNext
+      0,                                              // VkCommandPoolCreateFlags     flags
+      Vulkan.PresentQueueFamilyIndex                  // uint32_t                     queueFamilyIndex
+    };
+
+    if( vkCreateCommandPool( Vulkan.Device, &cmd_pool_create_info, nullptr, &Vulkan.PresentQueueCmdPool ) != VK_SUCCESS ) {
+      std::cout << "Could not create a command pool!" << std::endl;
+      return false;
+    }
+
+    uint32_t image_count = 0;
+    if( (vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain, &image_count, nullptr ) != VK_SUCCESS) ||
+        (image_count == 0) ) {
+      std::cout << "Could not get the number of swap chain images!" << std::endl;
+      return false;
+    }
+
+    Vulkan.PresentQueueCmdBuffers.resize( image_count );
+
+    VkCommandBufferAllocateInfo cmd_buffer_allocate_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType              sType
+      nullptr,                                        // const void*                  pNext
+      Vulkan.PresentQueueCmdPool,                     // VkCommandPool                commandPool
+      VK_COMMAND_BUFFER_LEVEL_PRIMARY,                // VkCommandBufferLevel         level
+      image_count                                     // uint32_t                     bufferCount
+    };
+    if( vkAllocateCommandBuffers( Vulkan.Device, &cmd_buffer_allocate_info, &Vulkan.PresentQueueCmdBuffers[0] ) != VK_SUCCESS ) {
+      std::cout << "Could not allocate command buffers!" << std::endl;
+      return false;
+    }
+
+    if( !RecordCommandBuffers() ) {
+      std::cout << "Could not record command buffers!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial02::RecordCommandBuffers() {
+    uint32_t image_count = static_cast<uint32_t>(Vulkan.PresentQueueCmdBuffers.size());
+
+    std::vector<VkImage> swap_chain_images( image_count );
+    if( vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain, &image_count, &swap_chain_images[0] ) != VK_SUCCESS ) {
+      std::cout << "Could not get swap chain images!" << std::endl;
+      return false;
+    }
+
+    VkCommandBufferBeginInfo cmd_buffer_begin_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,  // VkStructureType                        sType
+      nullptr,                                      // const void                            *pNext
+      VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, // VkCommandBufferUsageFlags              flags
+      nullptr                                       // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
+    };
+
+    VkClearColorValue clear_color = {
+      { 1.0f, 0.8f, 0.4f, 0.0f }
+    };
+
+    VkImageSubresourceRange image_subresource_range = {
+      VK_IMAGE_ASPECT_COLOR_BIT,                    // VkImageAspectFlags                     aspectMask
+      0,                                            // uint32_t                               baseMipLevel
+      1,                                            // uint32_t                               levelCount
+      0,                                            // uint32_t                               baseArrayLayer
+      1                                             // uint32_t                               layerCount
+    };
+
+    for( uint32_t i = 0; i < image_count; ++i ) {
+      VkImageMemoryBarrier barrier_from_present_to_clear = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType                        sType
+        nullptr,                                    // const void                            *pNext
+        VK_ACCESS_MEMORY_READ_BIT,                  // VkAccessFlags                          srcAccessMask
+        VK_ACCESS_TRANSFER_WRITE_BIT,               // VkAccessFlags                          dstAccessMask
+        VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout                          oldLayout
+        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,       // VkImageLayout                          newLayout
+        VK_QUEUE_FAMILY_IGNORED,                    // uint32_t                               srcQueueFamilyIndex
+        VK_QUEUE_FAMILY_IGNORED,                    // uint32_t                               dstQueueFamilyIndex
+        swap_chain_images[i],                       // VkImage                                image
+        image_subresource_range                     // VkImageSubresourceRange                subresourceRange
+      };
+
+      VkImageMemoryBarrier barrier_from_clear_to_present = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType                        sType
+        nullptr,                                    // const void                            *pNext
+        VK_ACCESS_TRANSFER_WRITE_BIT,               // VkAccessFlags                          srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                  // VkAccessFlags                          dstAccessMask
+        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,       // VkImageLayout                          oldLayout
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,            // VkImageLayout                          newLayout
+        VK_QUEUE_FAMILY_IGNORED,                    // uint32_t                               srcQueueFamilyIndex
+        VK_QUEUE_FAMILY_IGNORED,                    // uint32_t                               dstQueueFamilyIndex
+        swap_chain_images[i],                       // VkImage                                image
+        image_subresource_range                     // VkImageSubresourceRange                subresourceRange
+      };
+
+      vkBeginCommandBuffer( Vulkan.PresentQueueCmdBuffers[i], &cmd_buffer_begin_info );
+      vkCmdPipelineBarrier( Vulkan.PresentQueueCmdBuffers[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_clear );
+
+      vkCmdClearColorImage( Vulkan.PresentQueueCmdBuffers[i], swap_chain_images[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &image_subresource_range );
+
+      vkCmdPipelineBarrier( Vulkan.PresentQueueCmdBuffers[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_clear_to_present );
+      if( vkEndCommandBuffer( Vulkan.PresentQueueCmdBuffers[i] ) != VK_SUCCESS ) {
+        std::cout << "Could not record command buffers!" << std::endl;
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  void Tutorial02::Clear() {
+    if( Vulkan.Device != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( Vulkan.Device );
+
+      if( (Vulkan.PresentQueueCmdBuffers.size() > 0) && (Vulkan.PresentQueueCmdBuffers[0] != VK_NULL_HANDLE) ) {
+        vkFreeCommandBuffers( Vulkan.Device, Vulkan.PresentQueueCmdPool, static_cast<uint32_t>(Vulkan.PresentQueueCmdBuffers.size()), &Vulkan.PresentQueueCmdBuffers[0] );
+        Vulkan.PresentQueueCmdBuffers.clear();
+      }
+
+      if( Vulkan.PresentQueueCmdPool != VK_NULL_HANDLE ) {
+        vkDestroyCommandPool( Vulkan.Device, Vulkan.PresentQueueCmdPool, nullptr );
+        Vulkan.PresentQueueCmdPool = VK_NULL_HANDLE;
+      }
+    }
+  }
+
+  bool Tutorial02::Draw() {
+    uint32_t image_index;
+    VkResult result = vkAcquireNextImageKHR( Vulkan.Device, Vulkan.SwapChain, UINT64_MAX, Vulkan.ImageAvailableSemaphore, VK_NULL_HANDLE, &image_index );
+    switch( result ) {
+      case VK_SUCCESS:
+      case VK_SUBOPTIMAL_KHR:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during swap chain image acquisition!" << std::endl;
+        return false;
+    }
+
+    VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+    VkSubmitInfo submit_info = {
+      VK_STRUCTURE_TYPE_SUBMIT_INFO,                // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      1,                                            // uint32_t                     waitSemaphoreCount
+      &Vulkan.ImageAvailableSemaphore,              // const VkSemaphore           *pWaitSemaphores
+      &wait_dst_stage_mask,                         // const VkPipelineStageFlags  *pWaitDstStageMask;
+      1,                                            // uint32_t                     commandBufferCount
+      &Vulkan.PresentQueueCmdBuffers[image_index],  // const VkCommandBuffer       *pCommandBuffers
+      1,                                            // uint32_t                     signalSemaphoreCount
+      &Vulkan.RenderingFinishedSemaphore            // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( Vulkan.PresentQueue, 1, &submit_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    VkPresentInfoKHR present_info = {
+      VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,           // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      1,                                            // uint32_t                     waitSemaphoreCount
+      &Vulkan.RenderingFinishedSemaphore,           // const VkSemaphore           *pWaitSemaphores
+      1,                                            // uint32_t                     swapchainCount
+      &Vulkan.SwapChain,                            // const VkSwapchainKHR        *pSwapchains
+      &image_index,                                 // const uint32_t              *pImageIndices
+      nullptr                                       // VkResult                    *pResults
+    };
+    result = vkQueuePresentKHR( Vulkan.PresentQueue, &present_info );
+
+    switch( result ) {
+      case VK_SUCCESS:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+      case VK_SUBOPTIMAL_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during image presentation!" << std::endl;
+        return false;
+    }
+
+    return true;
+  }
+
+  Tutorial02::~Tutorial02() {
+    Clear();
+
+    if( Vulkan.Device != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( Vulkan.Device );
+
+      if( Vulkan.ImageAvailableSemaphore != VK_NULL_HANDLE ) {
+        vkDestroySemaphore( Vulkan.Device, Vulkan.ImageAvailableSemaphore, nullptr );
+      }
+      if( Vulkan.RenderingFinishedSemaphore != VK_NULL_HANDLE ) {
+        vkDestroySemaphore( Vulkan.Device, Vulkan.RenderingFinishedSemaphore, nullptr );
+      }
+      if( Vulkan.SwapChain != VK_NULL_HANDLE ) {
+        vkDestroySwapchainKHR( Vulkan.Device, Vulkan.SwapChain, nullptr );
+      }
+      vkDestroyDevice( Vulkan.Device, nullptr );
+    }
+
+    if( Vulkan.PresentationSurface != VK_NULL_HANDLE ) {
+      vkDestroySurfaceKHR( Vulkan.Instance, Vulkan.PresentationSurface, nullptr );
+    }
+
+    if( Vulkan.Instance != VK_NULL_HANDLE ) {
+      vkDestroyInstance( Vulkan.Instance, nullptr );
+    }
+
+    if( VulkanLibrary ) {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+      FreeLibrary( VulkanLibrary );
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+      dlclose( VulkanLibrary );
+#endif
+    }
+  }
+
+} // namespace ApiWithoutSecrets

Project/Tutorials/02/Tutorial02.h

@@ -0,0 +1,107 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_02_HEADER)
+#define TUTORIAL_02_HEADER
+
+#include <vector>
+#include "vulkan.h"
+#include "OperatingSystem.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // VulkanTutorial02Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial02Parameters {
+    VkInstance                    Instance;
+    VkPhysicalDevice              PhysicalDevice;
+    VkDevice                      Device;
+    VkQueue                       GraphicsQueue;
+    VkQueue                       PresentQueue;
+    uint32_t                      GraphicsQueueFamilyIndex;
+    uint32_t                      PresentQueueFamilyIndex;
+    VkSurfaceKHR                  PresentationSurface;
+    VkSwapchainKHR                SwapChain;
+    std::vector<VkCommandBuffer>  PresentQueueCmdBuffers;
+    VkCommandPool                 PresentQueueCmdPool;
+    VkSemaphore                   ImageAvailableSemaphore;
+    VkSemaphore                   RenderingFinishedSemaphore;
+
+    VulkanTutorial02Parameters() :
+      Instance( VK_NULL_HANDLE ),
+      PhysicalDevice( VK_NULL_HANDLE ),
+      Device( VK_NULL_HANDLE ),
+      GraphicsQueue( VK_NULL_HANDLE ),
+      PresentQueue( VK_NULL_HANDLE ),
+      GraphicsQueueFamilyIndex( 0 ),
+      PresentQueueFamilyIndex( 0 ),
+      PresentationSurface( VK_NULL_HANDLE ),
+      SwapChain( VK_NULL_HANDLE ),
+      PresentQueueCmdBuffers( 0 ),
+      PresentQueueCmdPool( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial02                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial02 : public OS::TutorialBase {
+  public:
+    Tutorial02();
+    ~Tutorial02();
+
+    bool PrepareVulkan( OS::WindowParameters parameters );
+    bool CreateSwapChain();
+    bool OnWindowSizeChanged() override;
+    bool CreateCommandBuffers();
+    bool Draw() override;
+
+  private:
+    OS::LibraryHandle           VulkanLibrary;
+    OS::WindowParameters        Window;
+    VulkanTutorial02Parameters  Vulkan;
+
+    bool                          LoadVulkanLibrary();
+    bool                          LoadExportedEntryPoints();
+    bool                          LoadGlobalLevelEntryPoints();
+    bool                          CreateInstance();
+    bool                          LoadInstanceLevelEntryPoints();
+    bool                          CreatePresentationSurface();
+    bool                          CreateDevice();
+    bool                          CheckPhysicalDeviceProperties( VkPhysicalDevice physical_device, uint32_t &graphics_queue_family_index, uint32_t &present_queue_family_index );
+    bool                          LoadDeviceLevelEntryPoints();
+    bool                          GetDeviceQueue();
+    bool                          CreateSemaphores();
+    bool                          RecordCommandBuffers();
+    void                          Clear();
+
+    bool                          CheckExtensionAvailability( const char *extension_name, const std::vector<VkExtensionProperties> &available_extensions );
+    uint32_t                      GetSwapChainNumImages( VkSurfaceCapabilitiesKHR &surface_capabilities );
+    VkSurfaceFormatKHR            GetSwapChainFormat( std::vector<VkSurfaceFormatKHR> &surface_formats );
+    VkExtent2D                    GetSwapChainExtent( VkSurfaceCapabilitiesKHR &surface_capabilities );
+    VkImageUsageFlags             GetSwapChainUsageFlags( VkSurfaceCapabilitiesKHR &surface_capabilities );
+    VkSurfaceTransformFlagBitsKHR GetSwapChainTransform( VkSurfaceCapabilitiesKHR &surface_capabilities );
+    VkPresentModeKHR              GetSwapChainPresentMode( std::vector<VkPresentModeKHR> &present_modes );
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_02_HEADER

Project/Tutorials/02/main.cpp

@@ -0,0 +1,45 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial02.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial02 tutorial02;
+
+  // Window creation
+  if( !window.Create( "02 - Swap chain" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial02.PrepareVulkan( window.GetParameters() ) ) {
+    return -1;
+  }
+  if( !tutorial02.CreateSwapChain() ) {
+    return -1;
+  }
+  if( !tutorial02.CreateCommandBuffers() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial02 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorials/03/Data/frag.spv.txt

@@ -0,0 +1,35 @@
+Tutorial03/Data03/shader.frag
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked fragment stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 14
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 9
+                              ExecutionMode 4 OriginLowerLeft
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 9  "out_Color"
+                              Decorate 9(out_Color) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Output 7(fvec4)
+    9(out_Color):      8(ptr) Variable Output
+              10:    6(float) Constant 0
+              11:    6(float) Constant 1053609165
+              12:    6(float) Constant 1065353216
+              13:    7(fvec4) ConstantComposite 10 11 12 12
+         4(main):           2 Function None 3
+               5:             Label
+                              Store 9(out_Color) 13
+                              Return
+                              FunctionEnd

Project/Tutorials/03/Data/shader.frag

@@ -0,0 +1,17 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(location = 0) out vec4 out_Color;
+
+void main() {
+  out_Color = vec4( 0.0, 0.4, 1.0, 1.0 );
+}

Project/Tutorials/03/Data/shader.vert

@@ -0,0 +1,21 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+out gl_PerVertex
+{
+  vec4 gl_Position;
+};
+
+void main() {
+    vec2 pos[3] = vec2[3]( vec2(-0.7, 0.7), vec2(0.7, 0.7), vec2(0.0, -0.7) );
+    gl_Position = vec4( pos[gl_VertexIndex], 0.0, 1.0 );
+}

Project/Tutorials/03/Data/vert.spv.txt

@@ -0,0 +1,65 @@
+Tutorial03/Data03/shader.vert
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked vertex stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 38
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 23 27
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 12  "pos"
+                              Name 21  "gl_PerVertex"
+                              MemberName 21(gl_PerVertex) 0  "gl_Position"
+                              Name 23  ""
+                              Name 27  "gl_VertexIndex"
+                              MemberDecorate 21(gl_PerVertex) 0 BuiltIn Position
+                              Decorate 21(gl_PerVertex) Block
+                              Decorate 27(gl_VertexIndex) BuiltIn VertexIndex
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 2
+               8:             TypeInt 32 0
+               9:      8(int) Constant 3
+              10:             TypeArray 7(fvec2) 9
+              11:             TypePointer Function 10
+              13:    6(float) Constant 3207803699
+              14:    6(float) Constant 1060320051
+              15:    7(fvec2) ConstantComposite 13 14
+              16:    7(fvec2) ConstantComposite 14 14
+              17:    6(float) Constant 0
+              18:    7(fvec2) ConstantComposite 17 13
+              19:          10 ConstantComposite 15 16 18
+              20:             TypeVector 6(float) 4
+21(gl_PerVertex):             TypeStruct 20(fvec4)
+              22:             TypePointer Output 21(gl_PerVertex)
+              23:     22(ptr) Variable Output
+              24:             TypeInt 32 1
+              25:     24(int) Constant 0
+              26:             TypePointer Input 24(int)
+27(gl_VertexIndex):     26(ptr) Variable Input
+              29:             TypePointer Function 7(fvec2)
+              32:    6(float) Constant 1065353216
+              36:             TypePointer Output 20(fvec4)
+         4(main):           2 Function None 3
+               5:             Label
+         12(pos):     11(ptr) Variable Function
+                              Store 12(pos) 19
+              28:     24(int) Load 27(gl_VertexIndex)
+              30:     29(ptr) AccessChain 12(pos) 28
+              31:    7(fvec2) Load 30
+              33:    6(float) CompositeExtract 31 0
+              34:    6(float) CompositeExtract 31 1
+              35:   20(fvec4) CompositeConstruct 33 34 17 32
+              37:     36(ptr) AccessChain 23 25
+                              Store 37 35
+                              Return
+                              FunctionEnd

Project/Tutorials/03/Tutorial03.cpp

@@ -0,0 +1,596 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial03.h"
+#include "VulkanFunctions.h"
+
+namespace ApiWithoutSecrets {
+
+  Tutorial03::Tutorial03() :
+    Vulkan() {
+  }
+
+  bool Tutorial03::CreateRenderPass() {
+    VkAttachmentDescription attachment_descriptions[] = {
+      {
+        0,                                          // VkAttachmentDescriptionFlags   flags
+        GetSwapChain().Format,                      // VkFormat                       format
+        VK_SAMPLE_COUNT_1_BIT,                      // VkSampleCountFlagBits          samples
+        VK_ATTACHMENT_LOAD_OP_CLEAR,                // VkAttachmentLoadOp             loadOp
+        VK_ATTACHMENT_STORE_OP_STORE,               // VkAttachmentStoreOp            storeOp
+        VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp             stencilLoadOp
+        VK_ATTACHMENT_STORE_OP_DONT_CARE,           // VkAttachmentStoreOp            stencilStoreOp
+        VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout                  initialLayout;
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR             // VkImageLayout                  finalLayout
+      }
+    };
+
+    VkAttachmentReference color_attachment_references[] = {
+      {
+        0,                                          // uint32_t                       attachment
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL    // VkImageLayout                  layout
+      }
+    };
+
+    VkSubpassDescription subpass_descriptions[] = {
+      {
+        0,                                          // VkSubpassDescriptionFlags      flags
+        VK_PIPELINE_BIND_POINT_GRAPHICS,            // VkPipelineBindPoint            pipelineBindPoint
+        0,                                          // uint32_t                       inputAttachmentCount
+        nullptr,                                    // const VkAttachmentReference   *pInputAttachments
+        1,                                          // uint32_t                       colorAttachmentCount
+        color_attachment_references,                // const VkAttachmentReference   *pColorAttachments
+        nullptr,                                    // const VkAttachmentReference   *pResolveAttachments
+        nullptr,                                    // const VkAttachmentReference   *pDepthStencilAttachment
+        0,                                          // uint32_t                       preserveAttachmentCount
+        nullptr                                     // const uint32_t*                pPreserveAttachments
+      }
+    };
+
+    VkRenderPassCreateInfo render_pass_create_info = {
+      VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,    // VkStructureType                sType
+      nullptr,                                      // const void                    *pNext
+      0,                                            // VkRenderPassCreateFlags        flags
+      1,                                            // uint32_t                       attachmentCount
+      attachment_descriptions,                      // const VkAttachmentDescription *pAttachments
+      1,                                            // uint32_t                       subpassCount
+      subpass_descriptions,                         // const VkSubpassDescription    *pSubpasses
+      0,                                            // uint32_t                       dependencyCount
+      nullptr                                       // const VkSubpassDependency     *pDependencies
+    };
+
+    if( vkCreateRenderPass( GetDevice(), &render_pass_create_info, nullptr, &Vulkan.RenderPass ) != VK_SUCCESS ) {
+      std::cout << "Could not create render pass!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial03::CreateFramebuffers() {
+    const std::vector<ImageParameters> &swap_chain_images = GetSwapChain().Images;
+    Vulkan.Framebuffers.resize( swap_chain_images.size() );
+
+    for( size_t i = 0; i < swap_chain_images.size(); ++i ) {
+      VkFramebufferCreateInfo framebuffer_create_info = {
+        VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,  // VkStructureType                sType
+        nullptr,                                    // const void                    *pNext
+        0,                                          // VkFramebufferCreateFlags       flags
+        Vulkan.RenderPass,                          // VkRenderPass                   renderPass
+        1,                                          // uint32_t                       attachmentCount
+        &swap_chain_images[i].View,                 // const VkImageView             *pAttachments
+        300,                                        // uint32_t                       width
+        300,                                        // uint32_t                       height
+        1                                           // uint32_t                       layers
+      };
+
+      if( vkCreateFramebuffer( GetDevice(), &framebuffer_create_info, nullptr, &Vulkan.Framebuffers[i] ) != VK_SUCCESS ) {
+        std::cout << "Could not create a framebuffer!" << std::endl;
+        return false;
+      }
+    }
+    return true;
+  }
+
+  Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> Tutorial03::CreateShaderModule( const char* filename ) {
+    const std::vector<char> code = Tools::GetBinaryFileContents( filename );
+    if( code.size() == 0 ) {
+      return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>();
+    }
+
+    VkShaderModuleCreateInfo shader_module_create_info = {
+      VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,    // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      0,                                              // VkShaderModuleCreateFlags      flags
+      code.size(),                                    // size_t                         codeSize
+      reinterpret_cast<const uint32_t*>(&code[0])     // const uint32_t                *pCode
+    };
+
+    VkShaderModule shader_module;
+    if( vkCreateShaderModule( GetDevice(), &shader_module_create_info, nullptr, &shader_module ) != VK_SUCCESS ) {
+      std::cout << "Could not create shader module from a \"" << filename << "\" file!" << std::endl;
+      return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>();
+    }
+
+    return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>( shader_module, vkDestroyShaderModule, GetDevice() );
+  }
+
+  Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> Tutorial03::CreatePipelineLayout() {
+    VkPipelineLayoutCreateInfo layout_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,  // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      0,                                              // VkPipelineLayoutCreateFlags    flags
+      0,                                              // uint32_t                       setLayoutCount
+      nullptr,                                        // const VkDescriptorSetLayout   *pSetLayouts
+      0,                                              // uint32_t                       pushConstantRangeCount
+      nullptr                                         // const VkPushConstantRange     *pPushConstantRanges
+    };
+
+    VkPipelineLayout pipeline_layout;
+    if( vkCreatePipelineLayout( GetDevice(), &layout_create_info, nullptr, &pipeline_layout ) != VK_SUCCESS ) {
+      std::cout << "Could not create pipeline layout!" << std::endl;
+      return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>();
+    }
+
+    return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>( pipeline_layout, vkDestroyPipelineLayout, GetDevice() );
+  }
+
+  bool Tutorial03::CreatePipeline() {
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> vertex_shader_module = CreateShaderModule( "Data/Tutorials/03/vert.spv" );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> fragment_shader_module = CreateShaderModule( "Data/Tutorials/03/frag.spv" );
+
+    if( !vertex_shader_module || !fragment_shader_module ) {
+      return false;
+    }
+
+    std::vector<VkPipelineShaderStageCreateInfo> shader_stage_create_infos = {
+      // Vertex shader
+      {
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,        // VkStructureType                                sType
+        nullptr,                                                    // const void                                    *pNext
+        0,                                                          // VkPipelineShaderStageCreateFlags               flags
+        VK_SHADER_STAGE_VERTEX_BIT,                                 // VkShaderStageFlagBits                          stage
+        vertex_shader_module.Get(),                                 // VkShaderModule                                 module
+        "main",                                                     // const char                                    *pName
+        nullptr                                                     // const VkSpecializationInfo                    *pSpecializationInfo
+      },
+      // Fragment shader
+      {
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,        // VkStructureType                                sType
+        nullptr,                                                    // const void                                    *pNext
+        0,                                                          // VkPipelineShaderStageCreateFlags               flags
+        VK_SHADER_STAGE_FRAGMENT_BIT,                               // VkShaderStageFlagBits                          stage
+        fragment_shader_module.Get(),                               // VkShaderModule                                 module
+        "main",                                                     // const char                                    *pName
+        nullptr                                                     // const VkSpecializationInfo                    *pSpecializationInfo
+      }
+    };
+
+    VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,    // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineVertexInputStateCreateFlags          flags;
+      0,                                                            // uint32_t                                       vertexBindingDescriptionCount
+      nullptr,                                                      // const VkVertexInputBindingDescription         *pVertexBindingDescriptions
+      0,                                                            // uint32_t                                       vertexAttributeDescriptionCount
+      nullptr                                                       // const VkVertexInputAttributeDescription       *pVertexAttributeDescriptions
+    };
+
+    VkPipelineInputAssemblyStateCreateInfo input_assembly_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,  // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineInputAssemblyStateCreateFlags        flags
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                          // VkPrimitiveTopology                            topology
+      VK_FALSE                                                      // VkBool32                                       primitiveRestartEnable
+    };
+
+    VkViewport viewport = {
+      0.0f,                                                         // float                                          x
+      0.0f,                                                         // float                                          y
+      300.0f,                                                       // float                                          width
+      300.0f,                                                       // float                                          height
+      0.0f,                                                         // float                                          minDepth
+      1.0f                                                          // float                                          maxDepth
+    };
+
+    VkRect2D scissor = {
+      {                                                             // VkOffset2D                                     offset
+        0,                                                            // int32_t                                        x
+        0                                                             // int32_t                                        y
+      },
+      {                                                             // VkExtent2D                                     extent
+        300,                                                          // int32_t                                        width
+        300                                                           // int32_t                                        height
+      }
+    };
+
+    VkPipelineViewportStateCreateInfo viewport_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,        // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineViewportStateCreateFlags             flags
+      1,                                                            // uint32_t                                       viewportCount
+      &viewport,                                                    // const VkViewport                              *pViewports
+      1,                                                            // uint32_t                                       scissorCount
+      &scissor                                                      // const VkRect2D                                *pScissors
+    };
+
+    VkPipelineRasterizationStateCreateInfo rasterization_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,   // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineRasterizationStateCreateFlags        flags
+      VK_FALSE,                                                     // VkBool32                                       depthClampEnable
+      VK_FALSE,                                                     // VkBool32                                       rasterizerDiscardEnable
+      VK_POLYGON_MODE_FILL,                                         // VkPolygonMode                                  polygonMode
+      VK_CULL_MODE_BACK_BIT,                                        // VkCullModeFlags                                cullMode
+      VK_FRONT_FACE_COUNTER_CLOCKWISE,                              // VkFrontFace                                    frontFace
+      VK_FALSE,                                                     // VkBool32                                       depthBiasEnable
+      0.0f,                                                         // float                                          depthBiasConstantFactor
+      0.0f,                                                         // float                                          depthBiasClamp
+      0.0f,                                                         // float                                          depthBiasSlopeFactor
+      1.0f                                                          // float                                          lineWidth
+    };
+
+    VkPipelineMultisampleStateCreateInfo multisample_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,     // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineMultisampleStateCreateFlags          flags
+      VK_SAMPLE_COUNT_1_BIT,                                        // VkSampleCountFlagBits                          rasterizationSamples
+      VK_FALSE,                                                     // VkBool32                                       sampleShadingEnable
+      1.0f,                                                         // float                                          minSampleShading
+      nullptr,                                                      // const VkSampleMask                            *pSampleMask
+      VK_FALSE,                                                     // VkBool32                                       alphaToCoverageEnable
+      VK_FALSE                                                      // VkBool32                                       alphaToOneEnable
+    };
+
+    VkPipelineColorBlendAttachmentState color_blend_attachment_state = {
+      VK_FALSE,                                                     // VkBool32                                       blendEnable
+      VK_BLEND_FACTOR_ONE,                                          // VkBlendFactor                                  srcColorBlendFactor
+      VK_BLEND_FACTOR_ZERO,                                         // VkBlendFactor                                  dstColorBlendFactor
+      VK_BLEND_OP_ADD,                                              // VkBlendOp                                      colorBlendOp
+      VK_BLEND_FACTOR_ONE,                                          // VkBlendFactor                                  srcAlphaBlendFactor
+      VK_BLEND_FACTOR_ZERO,                                         // VkBlendFactor                                  dstAlphaBlendFactor
+      VK_BLEND_OP_ADD,                                              // VkBlendOp                                      alphaBlendOp
+      VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |         // VkColorComponentFlags                          colorWriteMask
+      VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
+    };
+
+    VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,     // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineColorBlendStateCreateFlags           flags
+      VK_FALSE,                                                     // VkBool32                                       logicOpEnable
+      VK_LOGIC_OP_COPY,                                             // VkLogicOp                                      logicOp
+      1,                                                            // uint32_t                                       attachmentCount
+      &color_blend_attachment_state,                                // const VkPipelineColorBlendAttachmentState     *pAttachments
+      { 0.0f, 0.0f, 0.0f, 0.0f }                                    // float                                          blendConstants[4]
+    };
+
+    Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> pipeline_layout = CreatePipelineLayout();
+    if( !pipeline_layout ) {
+      return false;
+    }
+
+    VkGraphicsPipelineCreateInfo pipeline_create_info = {
+      VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,              // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineCreateFlags                          flags
+      static_cast<uint32_t>(shader_stage_create_infos.size()),      // uint32_t                                       stageCount
+      &shader_stage_create_infos[0],                                // const VkPipelineShaderStageCreateInfo         *pStages
+      &vertex_input_state_create_info,                              // const VkPipelineVertexInputStateCreateInfo    *pVertexInputState;
+      &input_assembly_state_create_info,                            // const VkPipelineInputAssemblyStateCreateInfo  *pInputAssemblyState
+      nullptr,                                                      // const VkPipelineTessellationStateCreateInfo   *pTessellationState
+      &viewport_state_create_info,                                  // const VkPipelineViewportStateCreateInfo       *pViewportState
+      &rasterization_state_create_info,                             // const VkPipelineRasterizationStateCreateInfo  *pRasterizationState
+      &multisample_state_create_info,                               // const VkPipelineMultisampleStateCreateInfo    *pMultisampleState
+      nullptr,                                                      // const VkPipelineDepthStencilStateCreateInfo   *pDepthStencilState
+      &color_blend_state_create_info,                               // const VkPipelineColorBlendStateCreateInfo     *pColorBlendState
+      nullptr,                                                      // const VkPipelineDynamicStateCreateInfo        *pDynamicState
+      pipeline_layout.Get(),                                        // VkPipelineLayout                               layout
+      Vulkan.RenderPass,                                            // VkRenderPass                                   renderPass
+      0,                                                            // uint32_t                                       subpass
+      VK_NULL_HANDLE,                                               // VkPipeline                                     basePipelineHandle
+      -1                                                            // int32_t                                        basePipelineIndex
+    };
+
+    if( vkCreateGraphicsPipelines( GetDevice(), VK_NULL_HANDLE, 1, &pipeline_create_info, nullptr, &Vulkan.GraphicsPipeline ) != VK_SUCCESS ) {
+      std::cout << "Could not create graphics pipeline!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial03::CreateSemaphores() {
+    VkSemaphoreCreateInfo semaphore_create_info = {
+      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,      // VkStructureType          sType
+      nullptr,                                      // const void*              pNext
+      0                                             // VkSemaphoreCreateFlags   flags
+    };
+
+    if( (vkCreateSemaphore( GetDevice(), &semaphore_create_info, nullptr, &Vulkan.ImageAvailableSemaphore ) != VK_SUCCESS) ||
+        (vkCreateSemaphore( GetDevice(), &semaphore_create_info, nullptr, &Vulkan.RenderingFinishedSemaphore ) != VK_SUCCESS) ) {
+      std::cout << "Could not create semaphores!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial03::CreateCommandBuffers() {
+    if( !CreateCommandPool( GetGraphicsQueue().FamilyIndex, &Vulkan.GraphicsCommandPool ) ) {
+      std::cout << "Could not create command pool!" << std::endl;
+      return false;
+    }
+
+    uint32_t image_count = static_cast<uint32_t>(GetSwapChain().Images.size());
+    Vulkan.GraphicsCommandBuffers.resize( image_count, VK_NULL_HANDLE );
+
+    if( !AllocateCommandBuffers( Vulkan.GraphicsCommandPool, image_count, &Vulkan.GraphicsCommandBuffers[0] ) ) {
+      std::cout << "Could not allocate command buffers!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial03::CreateCommandPool( uint32_t queue_family_index, VkCommandPool *pool ) {
+    VkCommandPoolCreateInfo cmd_pool_create_info = {
+      VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,     // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      0,                                              // VkCommandPoolCreateFlags       flags
+      queue_family_index                              // uint32_t                       queueFamilyIndex
+    };
+
+    if( vkCreateCommandPool( GetDevice(), &cmd_pool_create_info, nullptr, pool ) != VK_SUCCESS ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial03::AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers ) {
+    VkCommandBufferAllocateInfo command_buffer_allocate_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      pool,                                           // VkCommandPool                  commandPool
+      VK_COMMAND_BUFFER_LEVEL_PRIMARY,                // VkCommandBufferLevel           level
+      count                                           // uint32_t                       bufferCount
+    };
+
+    if( vkAllocateCommandBuffers( GetDevice(), &command_buffer_allocate_info, command_buffers ) != VK_SUCCESS ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial03::RecordCommandBuffers() {
+    VkCommandBufferBeginInfo graphics_commandd_buffer_begin_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                        sType
+      nullptr,                                        // const void                            *pNext
+      VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,   // VkCommandBufferUsageFlags              flags
+      nullptr                                         // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
+    };
+
+    VkImageSubresourceRange image_subresource_range = {
+      VK_IMAGE_ASPECT_COLOR_BIT,                      // VkImageAspectFlags             aspectMask
+      0,                                              // uint32_t                       baseMipLevel
+      1,                                              // uint32_t                       levelCount
+      0,                                              // uint32_t                       baseArrayLayer
+      1                                               // uint32_t                       layerCount
+    };
+
+    VkClearValue clear_value = {
+      { 1.0f, 0.8f, 0.4f, 0.0f },                     // VkClearColorValue              color
+    };
+
+    const std::vector<ImageParameters>& swap_chain_images = GetSwapChain().Images;
+
+    for( size_t i = 0; i < Vulkan.GraphicsCommandBuffers.size(); ++i ) {
+      vkBeginCommandBuffer( Vulkan.GraphicsCommandBuffers[i], &graphics_commandd_buffer_begin_info );
+
+      if( GetPresentQueue().Handle != GetGraphicsQueue().Handle ) {
+        VkImageMemoryBarrier barrier_from_present_to_draw = {
+          VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType                sType
+          nullptr,                                    // const void                    *pNext
+          VK_ACCESS_MEMORY_READ_BIT,                  // VkAccessFlags                  srcAccessMask
+          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,       // VkAccessFlags                  dstAccessMask
+          VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout                  oldLayout
+          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,            // VkImageLayout                  newLayout
+          GetPresentQueue().FamilyIndex,              // uint32_t                       srcQueueFamilyIndex
+          GetGraphicsQueue().FamilyIndex,             // uint32_t                       dstQueueFamilyIndex
+          swap_chain_images[i].Handle,                // VkImage                        image
+          image_subresource_range                     // VkImageSubresourceRange        subresourceRange
+        };
+        vkCmdPipelineBarrier( Vulkan.GraphicsCommandBuffers[i], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_draw );
+      }
+
+      VkRenderPassBeginInfo render_pass_begin_info = {
+        VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,     // VkStructureType                sType
+        nullptr,                                      // const void                    *pNext
+        Vulkan.RenderPass,                            // VkRenderPass                   renderPass
+        Vulkan.Framebuffers[i],                       // VkFramebuffer                  framebuffer
+        {                                             // VkRect2D                       renderArea
+          {                                           // VkOffset2D                     offset
+            0,                                          // int32_t                        x
+            0                                           // int32_t                        y
+          },
+          {                                           // VkExtent2D                     extent
+            300,                                        // int32_t                        width
+            300,                                        // int32_t                        height
+          }
+        },
+        1,                                            // uint32_t                       clearValueCount
+        &clear_value                                  // const VkClearValue            *pClearValues
+      };
+
+      vkCmdBeginRenderPass( Vulkan.GraphicsCommandBuffers[i], &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE );
+
+      vkCmdBindPipeline( Vulkan.GraphicsCommandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, Vulkan.GraphicsPipeline );
+
+      vkCmdDraw( Vulkan.GraphicsCommandBuffers[i], 3, 1, 0, 0 );
+
+      vkCmdEndRenderPass( Vulkan.GraphicsCommandBuffers[i] );
+
+      if( GetGraphicsQueue().Handle != GetPresentQueue().Handle ) {
+        VkImageMemoryBarrier barrier_from_draw_to_present = {
+          VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,       // VkStructureType              sType
+          nullptr,                                      // const void                  *pNext
+          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,         // VkAccessFlags                srcAccessMask
+          VK_ACCESS_MEMORY_READ_BIT,                    // VkAccessFlags                dstAccessMask
+          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,              // VkImageLayout                oldLayout
+          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,              // VkImageLayout                newLayout
+          GetGraphicsQueue().FamilyIndex,               // uint32_t                     srcQueueFamilyIndex
+          GetPresentQueue().FamilyIndex,                // uint32_t                     dstQueueFamilyIndex
+          swap_chain_images[i].Handle,                  // VkImage                      image
+          image_subresource_range                       // VkImageSubresourceRange      subresourceRange
+        };
+        vkCmdPipelineBarrier( Vulkan.GraphicsCommandBuffers[i], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_draw_to_present );
+      }
+      if( vkEndCommandBuffer( Vulkan.GraphicsCommandBuffers[i] ) != VK_SUCCESS ) {
+        std::cout << "Could not record command buffer!" << std::endl;
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool Tutorial03::ChildOnWindowSizeChanged() {
+    if( !CreateRenderPass() ) {
+      return false;
+    }
+    if( !CreateFramebuffers() ) {
+      return false;
+    }
+    if( !CreatePipeline() ) {
+      return false;
+    }
+    if( !CreateCommandBuffers() ) {
+      return false;
+    }
+    if( !RecordCommandBuffers() ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial03::Draw() {
+    VkSwapchainKHR swap_chain = GetSwapChain().Handle;
+    uint32_t image_index;
+
+    VkResult result = vkAcquireNextImageKHR( GetDevice(), swap_chain, UINT64_MAX, Vulkan.ImageAvailableSemaphore, VK_NULL_HANDLE, &image_index );
+    switch( result ) {
+      case VK_SUCCESS:
+      case VK_SUBOPTIMAL_KHR:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during swap chain image acquisition!" << std::endl;
+        return false;
+    }
+
+    VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    VkSubmitInfo submit_info = {
+      VK_STRUCTURE_TYPE_SUBMIT_INFO,                // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      1,                                            // uint32_t                     waitSemaphoreCount
+      &Vulkan.ImageAvailableSemaphore,              // const VkSemaphore           *pWaitSemaphores
+      &wait_dst_stage_mask,                         // const VkPipelineStageFlags  *pWaitDstStageMask;
+      1,                                            // uint32_t                     commandBufferCount
+      &Vulkan.GraphicsCommandBuffers[image_index],  // const VkCommandBuffer       *pCommandBuffers
+      1,                                            // uint32_t                     signalSemaphoreCount
+      &Vulkan.RenderingFinishedSemaphore            // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    VkPresentInfoKHR present_info = {
+      VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,           // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      1,                                            // uint32_t                     waitSemaphoreCount
+      &Vulkan.RenderingFinishedSemaphore,           // const VkSemaphore           *pWaitSemaphores
+      1,                                            // uint32_t                     swapchainCount
+      &swap_chain,                                  // const VkSwapchainKHR        *pSwapchains
+      &image_index,                                 // const uint32_t              *pImageIndices
+      nullptr                                       // VkResult                    *pResults
+    };
+    result = vkQueuePresentKHR( GetPresentQueue().Handle, &present_info );
+
+    switch( result ) {
+      case VK_SUCCESS:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+      case VK_SUBOPTIMAL_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during image presentation!" << std::endl;
+        return false;
+    }
+
+    return true;
+  }
+
+  void Tutorial03::ChildClear() {
+    if( GetDevice() != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( GetDevice() );
+
+      if( (Vulkan.GraphicsCommandBuffers.size() > 0) && (Vulkan.GraphicsCommandBuffers[0] != VK_NULL_HANDLE) ) {
+        vkFreeCommandBuffers( GetDevice(), Vulkan.GraphicsCommandPool, static_cast<uint32_t>(Vulkan.GraphicsCommandBuffers.size()), &Vulkan.GraphicsCommandBuffers[0] );
+        Vulkan.GraphicsCommandBuffers.clear();
+      }
+
+      if( Vulkan.GraphicsCommandPool != VK_NULL_HANDLE ) {
+        vkDestroyCommandPool( GetDevice(), Vulkan.GraphicsCommandPool, nullptr );
+        Vulkan.GraphicsCommandPool = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.GraphicsPipeline != VK_NULL_HANDLE ) {
+        vkDestroyPipeline( GetDevice(), Vulkan.GraphicsPipeline, nullptr );
+        Vulkan.GraphicsPipeline = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.RenderPass != VK_NULL_HANDLE ) {
+        vkDestroyRenderPass( GetDevice(), Vulkan.RenderPass, nullptr );
+        Vulkan.RenderPass = VK_NULL_HANDLE;
+      }
+
+      for( size_t i = 0; i < Vulkan.Framebuffers.size(); ++i ) {
+        if( Vulkan.Framebuffers[i] != VK_NULL_HANDLE ) {
+          vkDestroyFramebuffer( GetDevice(), Vulkan.Framebuffers[i], nullptr );
+          Vulkan.Framebuffers[i] = VK_NULL_HANDLE;
+        }
+      }
+      Vulkan.Framebuffers.clear();
+    }
+  }
+
+  Tutorial03::~Tutorial03() {
+    ChildClear();
+
+    if( GetDevice() != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( GetDevice() );
+
+      if( Vulkan.ImageAvailableSemaphore != VK_NULL_HANDLE ) {
+        vkDestroySemaphore( GetDevice(), Vulkan.ImageAvailableSemaphore, nullptr );
+      }
+
+      if( Vulkan.RenderingFinishedSemaphore != VK_NULL_HANDLE ) {
+        vkDestroySemaphore( GetDevice(), Vulkan.RenderingFinishedSemaphore, nullptr );
+      }
+    }
+  }
+
+} // namespace ApiWithoutSecrets

Project/Tutorials/03/Tutorial03.h

@@ -0,0 +1,83 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_03_HEADER)
+#define TUTORIAL_03_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // VulkanTutorial03Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial03Parameters {
+    VkRenderPass                        RenderPass;
+    std::vector<VkFramebuffer>          Framebuffers;
+    VkPipeline                          GraphicsPipeline;
+    VkSemaphore                         ImageAvailableSemaphore;
+    VkSemaphore                         RenderingFinishedSemaphore;
+    VkCommandPool                       GraphicsCommandPool;
+    std::vector<VkCommandBuffer>        GraphicsCommandBuffers;
+
+    VulkanTutorial03Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      Framebuffers(),
+      GraphicsCommandPool( VK_NULL_HANDLE ),
+      GraphicsCommandBuffers(),
+      GraphicsPipeline( VK_NULL_HANDLE ),
+      ImageAvailableSemaphore( VK_NULL_HANDLE ),
+      RenderingFinishedSemaphore( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial03                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial03 : public VulkanCommon {
+  public:
+    Tutorial03();
+    ~Tutorial03();
+
+    bool    CreateRenderPass();
+    bool    CreateFramebuffers();
+    bool    CreatePipeline();
+    bool    CreateSemaphores();
+    bool    CreateCommandBuffers();
+    bool    RecordCommandBuffers();
+
+    bool    Draw() override;
+
+  private:
+    VulkanTutorial03Parameters  Vulkan;
+
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>     CreateShaderModule( const char* filename );
+    Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> CreatePipelineLayout();
+    bool                                                              CreateCommandPool( uint32_t queue_family_index, VkCommandPool *pool );
+    bool                                                              AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers );
+
+    void                                                              ChildClear() override;
+    bool                                                              ChildOnWindowSizeChanged() override;
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_03_HEADER

Project/Tutorials/03/main.cpp

@@ -0,0 +1,59 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial03.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial03 tutorial03;
+
+  // Window creation
+  if( !window.Create( "03 - First Triangle" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial03.PrepareVulkan( window.GetParameters() ) ) {
+    return -1;
+  }
+
+  // Tutorial 03
+  if( !tutorial03.CreateRenderPass() ) {
+    return -1;
+  }
+  if( !tutorial03.CreateFramebuffers() ) {
+    return -1;
+  }
+  if( !tutorial03.CreatePipeline() ) {
+    return -1;
+  }
+  if( !tutorial03.CreateSemaphores() ) {
+    return -1;
+  }
+  if( !tutorial03.CreateCommandBuffers() ) {
+    return -1;
+  }
+  if( !tutorial03.RecordCommandBuffers() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial03 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorials/04/Data/frag.spv.txt

@@ -0,0 +1,36 @@
+Tutorial04/Data04/shader.frag
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked fragment stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 13
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 9 11
+                              ExecutionMode 4 OriginLowerLeft
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 9  "o_Color"
+                              Name 11  "v_Color"
+                              Decorate 9(o_Color) Location 0
+                              Decorate 11(v_Color) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Output 7(fvec4)
+      9(o_Color):      8(ptr) Variable Output
+              10:             TypePointer Input 7(fvec4)
+     11(v_Color):     10(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              12:    7(fvec4) Load 11(v_Color)
+                              Store 9(o_Color) 12
+                              Return
+                              FunctionEnd

Project/Tutorials/04/Data/shader.frag

@@ -0,0 +1,19 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(location = 0) in vec4 v_Color;
+
+layout(location = 0) out vec4 o_Color;
+
+void main() {
+  o_Color = v_Color;
+}

Project/Tutorials/04/Data/shader.vert

@@ -0,0 +1,26 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(location = 0) in vec4 i_Position;
+layout(location = 1) in vec4 i_Color;
+
+out gl_PerVertex
+{
+  vec4 gl_Position;
+};
+
+layout(location = 0) out vec4 v_Color;
+
+void main() {
+    gl_Position = i_Position;
+    v_Color = i_Color;
+}

Project/Tutorials/04/Data/vert.spv.txt

@@ -0,0 +1,51 @@
+Tutorial04/Data04/shader.vert
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked vertex stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 21
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 10 14 18 19
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 8  "gl_PerVertex"
+                              MemberName 8(gl_PerVertex) 0  "gl_Position"
+                              Name 10  ""
+                              Name 14  "i_Position"
+                              Name 18  "v_Color"
+                              Name 19  "i_Color"
+                              MemberDecorate 8(gl_PerVertex) 0 BuiltIn Position
+                              Decorate 8(gl_PerVertex) Block
+                              Decorate 14(i_Position) Location 0
+                              Decorate 18(v_Color) Location 0
+                              Decorate 19(i_Color) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+ 8(gl_PerVertex):             TypeStruct 7(fvec4)
+               9:             TypePointer Output 8(gl_PerVertex)
+              10:      9(ptr) Variable Output
+              11:             TypeInt 32 1
+              12:     11(int) Constant 0
+              13:             TypePointer Input 7(fvec4)
+  14(i_Position):     13(ptr) Variable Input
+              16:             TypePointer Output 7(fvec4)
+     18(v_Color):     16(ptr) Variable Output
+     19(i_Color):     13(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              15:    7(fvec4) Load 14(i_Position)
+              17:     16(ptr) AccessChain 10 12
+                              Store 17 15
+              20:    7(fvec4) Load 19(i_Color)
+                              Store 18(v_Color) 20
+                              Return
+                              FunctionEnd

Project/Tutorials/04/Tutorial04.cpp

@@ -0,0 +1,784 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include <cstddef>
+#include "Tutorial04.h"
+#include "VulkanFunctions.h"
+
+namespace ApiWithoutSecrets {
+
+  Tutorial04::Tutorial04() :
+    Vulkan() {
+  }
+
+  bool Tutorial04::CreateRenderPass() {
+    VkAttachmentDescription attachment_descriptions[] = {
+      {
+        0,                                              // VkAttachmentDescriptionFlags   flags
+        GetSwapChain().Format,                          // VkFormat                       format
+        VK_SAMPLE_COUNT_1_BIT,                          // VkSampleCountFlagBits          samples
+        VK_ATTACHMENT_LOAD_OP_CLEAR,                    // VkAttachmentLoadOp             loadOp
+        VK_ATTACHMENT_STORE_OP_STORE,                   // VkAttachmentStoreOp            storeOp
+        VK_ATTACHMENT_LOAD_OP_DONT_CARE,                // VkAttachmentLoadOp             stencilLoadOp
+        VK_ATTACHMENT_STORE_OP_DONT_CARE,               // VkAttachmentStoreOp            stencilStoreOp
+        VK_IMAGE_LAYOUT_UNDEFINED,                      // VkImageLayout                  initialLayout;
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR                 // VkImageLayout                  finalLayout
+      }
+    };
+
+    VkAttachmentReference color_attachment_references[] = {
+      {
+        0,                                              // uint32_t                       attachment
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL        // VkImageLayout                  layout
+      }
+    };
+
+    VkSubpassDescription subpass_descriptions[] = {
+      {
+        0,                                              // VkSubpassDescriptionFlags      flags
+        VK_PIPELINE_BIND_POINT_GRAPHICS,                // VkPipelineBindPoint            pipelineBindPoint
+        0,                                              // uint32_t                       inputAttachmentCount
+        nullptr,                                        // const VkAttachmentReference   *pInputAttachments
+        1,                                              // uint32_t                       colorAttachmentCount
+        color_attachment_references,                    // const VkAttachmentReference   *pColorAttachments
+        nullptr,                                        // const VkAttachmentReference   *pResolveAttachments
+        nullptr,                                        // const VkAttachmentReference   *pDepthStencilAttachment
+        0,                                              // uint32_t                       preserveAttachmentCount
+        nullptr                                         // const uint32_t*                pPreserveAttachments
+      }
+    };
+
+    std::vector<VkSubpassDependency> dependencies = {
+      {
+        VK_SUBPASS_EXTERNAL,                            // uint32_t                       srcSubpass
+        0,                                              // uint32_t                       dstSubpass
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,           // VkPipelineStageFlags           srcStageMask
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,  // VkPipelineStageFlags           dstStageMask
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                  srcAccessMask
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                  dstAccessMask
+        VK_DEPENDENCY_BY_REGION_BIT                     // VkDependencyFlags              dependencyFlags
+      },
+      {
+        0,                                              // uint32_t                       srcSubpass
+        VK_SUBPASS_EXTERNAL,                            // uint32_t                       dstSubpass
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,  // VkPipelineStageFlags           srcStageMask
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,           // VkPipelineStageFlags           dstStageMask
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                  srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                  dstAccessMask
+        VK_DEPENDENCY_BY_REGION_BIT                     // VkDependencyFlags              dependencyFlags
+      }
+    };
+
+    VkRenderPassCreateInfo render_pass_create_info = {
+      VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,        // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkRenderPassCreateFlags        flags
+      1,                                                // uint32_t                       attachmentCount
+      attachment_descriptions,                          // const VkAttachmentDescription *pAttachments
+      1,                                                // uint32_t                       subpassCount
+      subpass_descriptions,                             // const VkSubpassDescription    *pSubpasses
+      static_cast<uint32_t>(dependencies.size()),       // uint32_t                       dependencyCount
+      &dependencies[0]                                  // const VkSubpassDependency     *pDependencies
+    };
+
+    if( vkCreateRenderPass( GetDevice(), &render_pass_create_info, nullptr, &Vulkan.RenderPass ) != VK_SUCCESS ) {
+      std::cout << "Could not create render pass!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> Tutorial04::CreateShaderModule( const char* filename ) {
+    const std::vector<char> code = Tools::GetBinaryFileContents( filename );
+    if( code.size() == 0 ) {
+      return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>();
+    }
+
+    VkShaderModuleCreateInfo shader_module_create_info = {
+      VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,    // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      0,                                              // VkShaderModuleCreateFlags      flags
+      code.size(),                                    // size_t                         codeSize
+      reinterpret_cast<const uint32_t*>(&code[0])     // const uint32_t                *pCode
+    };
+
+    VkShaderModule shader_module;
+    if( vkCreateShaderModule( GetDevice(), &shader_module_create_info, nullptr, &shader_module ) != VK_SUCCESS ) {
+      std::cout << "Could not create shader module from a \"" << filename << "\" file!" << std::endl;
+      return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>();
+    }
+
+    return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>( shader_module, vkDestroyShaderModule, GetDevice() );
+  }
+
+  Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> Tutorial04::CreatePipelineLayout() {
+    VkPipelineLayoutCreateInfo layout_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,  // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      0,                                              // VkPipelineLayoutCreateFlags    flags
+      0,                                              // uint32_t                       setLayoutCount
+      nullptr,                                        // const VkDescriptorSetLayout   *pSetLayouts
+      0,                                              // uint32_t                       pushConstantRangeCount
+      nullptr                                         // const VkPushConstantRange     *pPushConstantRanges
+    };
+
+    VkPipelineLayout pipeline_layout;
+    if( vkCreatePipelineLayout( GetDevice(), &layout_create_info, nullptr, &pipeline_layout ) != VK_SUCCESS ) {
+      std::cout << "Could not create pipeline layout!" << std::endl;
+      return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>();
+    }
+
+    return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>( pipeline_layout, vkDestroyPipelineLayout, GetDevice() );
+  }
+
+  bool Tutorial04::CreatePipeline() {
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> vertex_shader_module = CreateShaderModule( "Data/Tutorials/04/vert.spv" );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> fragment_shader_module = CreateShaderModule( "Data/Tutorials/04/frag.spv" );
+
+    if( !vertex_shader_module || !fragment_shader_module ) {
+      return false;
+    }
+
+    std::vector<VkPipelineShaderStageCreateInfo> shader_stage_create_infos = {
+      // Vertex shader
+      {
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,        // VkStructureType                                sType
+        nullptr,                                                    // const void                                    *pNext
+        0,                                                          // VkPipelineShaderStageCreateFlags               flags
+        VK_SHADER_STAGE_VERTEX_BIT,                                 // VkShaderStageFlagBits                          stage
+        vertex_shader_module.Get(),                                 // VkShaderModule                                 module
+        "main",                                                     // const char                                    *pName
+        nullptr                                                     // const VkSpecializationInfo                    *pSpecializationInfo
+      },
+      // Fragment shader
+      {
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,        // VkStructureType                                sType
+        nullptr,                                                    // const void                                    *pNext
+        0,                                                          // VkPipelineShaderStageCreateFlags               flags
+        VK_SHADER_STAGE_FRAGMENT_BIT,                               // VkShaderStageFlagBits                          stage
+        fragment_shader_module.Get(),                               // VkShaderModule                                 module
+        "main",                                                     // const char                                    *pName
+        nullptr                                                     // const VkSpecializationInfo                    *pSpecializationInfo
+      }
+    };
+
+    std::vector<VkVertexInputBindingDescription> vertex_binding_descriptions = {
+      {
+        0,                                                          // uint32_t                                       binding
+        sizeof(VertexData),                                         // uint32_t                                       stride
+        VK_VERTEX_INPUT_RATE_VERTEX                                 // VkVertexInputRate                              inputRate
+      }
+    };
+
+    std::vector<VkVertexInputAttributeDescription> vertex_attribute_descriptions = {
+      {
+        0,                                                          // uint32_t                                       location
+        vertex_binding_descriptions[0].binding,                     // uint32_t                                       binding
+        VK_FORMAT_R32G32B32A32_SFLOAT,                              // VkFormat                                       format
+        offsetof(struct VertexData, x)                              // uint32_t                                       offset
+      },
+      {
+        1,                                                          // uint32_t                                       location
+        vertex_binding_descriptions[0].binding,                     // uint32_t                                       binding
+        VK_FORMAT_R32G32B32A32_SFLOAT,                              // VkFormat                                       format
+        offsetof(struct VertexData, r)                              // uint32_t                                       offset
+      }
+    };
+
+    VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,    // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineVertexInputStateCreateFlags          flags
+      static_cast<uint32_t>(vertex_binding_descriptions.size()),    // uint32_t                                       vertexBindingDescriptionCount
+      &vertex_binding_descriptions[0],                              // const VkVertexInputBindingDescription         *pVertexBindingDescriptions
+      static_cast<uint32_t>(vertex_attribute_descriptions.size()),  // uint32_t                                       vertexAttributeDescriptionCount
+      &vertex_attribute_descriptions[0]                             // const VkVertexInputAttributeDescription       *pVertexAttributeDescriptions
+    };
+
+    VkPipelineInputAssemblyStateCreateInfo input_assembly_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,  // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineInputAssemblyStateCreateFlags        flags
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,                         // VkPrimitiveTopology                            topology
+      VK_FALSE                                                      // VkBool32                                       primitiveRestartEnable
+    };
+
+    VkPipelineViewportStateCreateInfo viewport_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,        // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineViewportStateCreateFlags             flags
+      1,                                                            // uint32_t                                       viewportCount
+      nullptr,                                                      // const VkViewport                              *pViewports
+      1,                                                            // uint32_t                                       scissorCount
+      nullptr                                                       // const VkRect2D                                *pScissors
+    };
+
+    VkPipelineRasterizationStateCreateInfo rasterization_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,   // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineRasterizationStateCreateFlags        flags
+      VK_FALSE,                                                     // VkBool32                                       depthClampEnable
+      VK_FALSE,                                                     // VkBool32                                       rasterizerDiscardEnable
+      VK_POLYGON_MODE_FILL,                                         // VkPolygonMode                                  polygonMode
+      VK_CULL_MODE_BACK_BIT,                                        // VkCullModeFlags                                cullMode
+      VK_FRONT_FACE_COUNTER_CLOCKWISE,                              // VkFrontFace                                    frontFace
+      VK_FALSE,                                                     // VkBool32                                       depthBiasEnable
+      0.0f,                                                         // float                                          depthBiasConstantFactor
+      0.0f,                                                         // float                                          depthBiasClamp
+      0.0f,                                                         // float                                          depthBiasSlopeFactor
+      1.0f                                                          // float                                          lineWidth
+    };
+
+    VkPipelineMultisampleStateCreateInfo multisample_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,     // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineMultisampleStateCreateFlags          flags
+      VK_SAMPLE_COUNT_1_BIT,                                        // VkSampleCountFlagBits                          rasterizationSamples
+      VK_FALSE,                                                     // VkBool32                                       sampleShadingEnable
+      1.0f,                                                         // float                                          minSampleShading
+      nullptr,                                                      // const VkSampleMask                            *pSampleMask
+      VK_FALSE,                                                     // VkBool32                                       alphaToCoverageEnable
+      VK_FALSE                                                      // VkBool32                                       alphaToOneEnable
+    };
+
+    VkPipelineColorBlendAttachmentState color_blend_attachment_state = {
+      VK_FALSE,                                                     // VkBool32                                       blendEnable
+      VK_BLEND_FACTOR_ONE,                                          // VkBlendFactor                                  srcColorBlendFactor
+      VK_BLEND_FACTOR_ZERO,                                         // VkBlendFactor                                  dstColorBlendFactor
+      VK_BLEND_OP_ADD,                                              // VkBlendOp                                      colorBlendOp
+      VK_BLEND_FACTOR_ONE,                                          // VkBlendFactor                                  srcAlphaBlendFactor
+      VK_BLEND_FACTOR_ZERO,                                         // VkBlendFactor                                  dstAlphaBlendFactor
+      VK_BLEND_OP_ADD,                                              // VkBlendOp                                      alphaBlendOp
+      VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |         // VkColorComponentFlags                          colorWriteMask
+      VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
+    };
+
+    VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,     // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineColorBlendStateCreateFlags           flags
+      VK_FALSE,                                                     // VkBool32                                       logicOpEnable
+      VK_LOGIC_OP_COPY,                                             // VkLogicOp                                      logicOp
+      1,                                                            // uint32_t                                       attachmentCount
+      &color_blend_attachment_state,                                // const VkPipelineColorBlendAttachmentState     *pAttachments
+      { 0.0f, 0.0f, 0.0f, 0.0f }                                    // float                                          blendConstants[4]
+    };
+
+    std::vector<VkDynamicState> dynamic_states = {
+      VK_DYNAMIC_STATE_VIEWPORT,
+      VK_DYNAMIC_STATE_SCISSOR,
+    };
+
+    VkPipelineDynamicStateCreateInfo dynamic_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,         // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineDynamicStateCreateFlags              flags
+      static_cast<uint32_t>(dynamic_states.size()),                 // uint32_t                                       dynamicStateCount
+      &dynamic_states[0]                                            // const VkDynamicState                          *pDynamicStates
+    };
+
+    Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> pipeline_layout = CreatePipelineLayout();
+    if( !pipeline_layout ) {
+      return false;
+    }
+
+    VkGraphicsPipelineCreateInfo pipeline_create_info = {
+      VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,              // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineCreateFlags                          flags
+      static_cast<uint32_t>(shader_stage_create_infos.size()),      // uint32_t                                       stageCount
+      &shader_stage_create_infos[0],                                // const VkPipelineShaderStageCreateInfo         *pStages
+      &vertex_input_state_create_info,                              // const VkPipelineVertexInputStateCreateInfo    *pVertexInputState;
+      &input_assembly_state_create_info,                            // const VkPipelineInputAssemblyStateCreateInfo  *pInputAssemblyState
+      nullptr,                                                      // const VkPipelineTessellationStateCreateInfo   *pTessellationState
+      &viewport_state_create_info,                                  // const VkPipelineViewportStateCreateInfo       *pViewportState
+      &rasterization_state_create_info,                             // const VkPipelineRasterizationStateCreateInfo  *pRasterizationState
+      &multisample_state_create_info,                               // const VkPipelineMultisampleStateCreateInfo    *pMultisampleState
+      nullptr,                                                      // const VkPipelineDepthStencilStateCreateInfo   *pDepthStencilState
+      &color_blend_state_create_info,                               // const VkPipelineColorBlendStateCreateInfo     *pColorBlendState
+      &dynamic_state_create_info,                                   // const VkPipelineDynamicStateCreateInfo        *pDynamicState
+      pipeline_layout.Get(),                                        // VkPipelineLayout                               layout
+      Vulkan.RenderPass,                                            // VkRenderPass                                   renderPass
+      0,                                                            // uint32_t                                       subpass
+      VK_NULL_HANDLE,                                               // VkPipeline                                     basePipelineHandle
+      -1                                                            // int32_t                                        basePipelineIndex
+    };
+
+    if( vkCreateGraphicsPipelines( GetDevice(), VK_NULL_HANDLE, 1, &pipeline_create_info, nullptr, &Vulkan.GraphicsPipeline ) != VK_SUCCESS ) {
+      std::cout << "Could not create graphics pipeline!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateVertexBuffer() {
+    VertexData vertex_data[] = {
+      {
+        -0.7f, -0.7f, 0.0f, 1.0f,
+        1.0f, 0.0f, 0.0f, 0.0f
+      },
+      {
+        -0.7f, 0.7f, 0.0f, 1.0f,
+        0.0f, 1.0f, 0.0f, 0.0f
+      },
+      {
+        0.7f, -0.7f, 0.0f, 1.0f,
+        0.0f, 0.0f, 1.0f, 0.0f
+      },
+      {
+        0.7f, 0.7f, 0.0f, 1.0f,
+        0.3f, 0.3f, 0.3f, 0.0f
+      }
+    };
+
+    Vulkan.VertexBuffer.Size = sizeof(vertex_data);
+
+    VkBufferCreateInfo buffer_create_info = {
+      VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,             // VkStructureType        sType
+      nullptr,                                          // const void            *pNext
+      0,                                                // VkBufferCreateFlags    flags
+      Vulkan.VertexBuffer.Size,                         // VkDeviceSize           size
+      VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,                // VkBufferUsageFlags     usage
+      VK_SHARING_MODE_EXCLUSIVE,                        // VkSharingMode          sharingMode
+      0,                                                // uint32_t               queueFamilyIndexCount
+      nullptr                                           // const uint32_t        *pQueueFamilyIndices
+    };
+
+    if( vkCreateBuffer( GetDevice(), &buffer_create_info, nullptr, &Vulkan.VertexBuffer.Handle ) != VK_SUCCESS ) {
+      std::cout << "Could not create a vertex buffer!" << std::endl;
+      return false;
+    }
+
+    if( !AllocateBufferMemory( Vulkan.VertexBuffer.Handle, &Vulkan.VertexBuffer.Memory ) ) {
+      std::cout << "Could not allocate memory for a vertex buffer!" << std::endl;
+      return false;
+    }
+
+    if( vkBindBufferMemory( GetDevice(), Vulkan.VertexBuffer.Handle, Vulkan.VertexBuffer.Memory, 0 ) != VK_SUCCESS ) {
+      std::cout << "Could not bind memory for a vertex buffer!" << std::endl;
+      return false;
+    }
+
+    void *vertex_buffer_memory_pointer;
+    if( vkMapMemory( GetDevice(), Vulkan.VertexBuffer.Memory, 0, Vulkan.VertexBuffer.Size, 0, &vertex_buffer_memory_pointer ) != VK_SUCCESS ) {
+      std::cout << "Could not map memory and upload data to a vertex buffer!" << std::endl;
+      return false;
+    }
+
+    memcpy( vertex_buffer_memory_pointer, vertex_data, Vulkan.VertexBuffer.Size );
+
+    VkMappedMemoryRange flush_range = {
+      VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,            // VkStructureType        sType
+      nullptr,                                          // const void            *pNext
+      Vulkan.VertexBuffer.Memory,                       // VkDeviceMemory         memory
+      0,                                                // VkDeviceSize           offset
+      VK_WHOLE_SIZE                                     // VkDeviceSize           size
+    };
+    vkFlushMappedMemoryRanges( GetDevice(), 1, &flush_range );
+
+    vkUnmapMemory( GetDevice(), Vulkan.VertexBuffer.Memory );
+
+    return true;
+  }
+
+  bool Tutorial04::AllocateBufferMemory( VkBuffer buffer, VkDeviceMemory *memory ) {
+    VkMemoryRequirements buffer_memory_requirements;
+    vkGetBufferMemoryRequirements( GetDevice(), buffer, &buffer_memory_requirements );
+
+    VkPhysicalDeviceMemoryProperties memory_properties;
+    vkGetPhysicalDeviceMemoryProperties( GetPhysicalDevice(), &memory_properties );
+
+    for( uint32_t i = 0; i < memory_properties.memoryTypeCount; ++i ) {
+      if( (buffer_memory_requirements.memoryTypeBits & (1 << i)) &&
+        (memory_properties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) ) {
+
+        VkMemoryAllocateInfo memory_allocate_info = {
+          VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,     // VkStructureType                        sType
+          nullptr,                                    // const void                            *pNext
+          buffer_memory_requirements.size,            // VkDeviceSize                           allocationSize
+          i                                           // uint32_t                               memoryTypeIndex
+        };
+
+        if( vkAllocateMemory( GetDevice(), &memory_allocate_info, nullptr, memory ) == VK_SUCCESS ) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  bool Tutorial04::CreateRenderingResources() {
+    if( !CreateCommandBuffers() ) {
+      return false;
+    }
+    if( !CreateSemaphores() ) {
+      return false;
+    }
+    if( !CreateFences() ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateCommandBuffers() {
+    if( !CreateCommandPool( GetGraphicsQueue().FamilyIndex, &Vulkan.CommandPool ) ) {
+      std::cout << "Could not create command pool!" << std::endl;
+      return false;
+    }
+    for( size_t i = 0; i < Vulkan.RenderingResources.size(); ++i ) {
+      if( !AllocateCommandBuffers( Vulkan.CommandPool, 1, &Vulkan.RenderingResources[i].CommandBuffer ) ) {
+        std::cout << "Could not allocate command buffer!" << std::endl;
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateCommandPool( uint32_t queue_family_index, VkCommandPool *pool ) {
+    VkCommandPoolCreateInfo cmd_pool_create_info = {
+      VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,       // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | // VkCommandPoolCreateFlags       flags
+      VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
+      queue_family_index                                // uint32_t                       queueFamilyIndex
+    };
+
+    if( vkCreateCommandPool( GetDevice(), &cmd_pool_create_info, nullptr, pool ) != VK_SUCCESS ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers ) {
+    VkCommandBufferAllocateInfo command_buffer_allocate_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      pool,                                             // VkCommandPool                  commandPool
+      VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // VkCommandBufferLevel           level
+      count                                             // uint32_t                       bufferCount
+    };
+
+    if( vkAllocateCommandBuffers( GetDevice(), &command_buffer_allocate_info, command_buffers ) != VK_SUCCESS ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateSemaphores() {
+    VkSemaphoreCreateInfo semaphore_create_info = {
+      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,          // VkStructureType                sType
+      nullptr,                                          // const void*                    pNext
+      0                                                 // VkSemaphoreCreateFlags         flags
+    };
+
+    for( size_t i = 0; i < Vulkan.RenderingResources.size(); ++i ) {
+      if( (vkCreateSemaphore( GetDevice(), &semaphore_create_info, nullptr, &Vulkan.RenderingResources[i].ImageAvailableSemaphore ) != VK_SUCCESS) ||
+        (vkCreateSemaphore( GetDevice(), &semaphore_create_info, nullptr, &Vulkan.RenderingResources[i].FinishedRenderingSemaphore ) != VK_SUCCESS) ) {
+        std::cout << "Could not create semaphores!" << std::endl;
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateFences() {
+    VkFenceCreateInfo fence_create_info = {
+      VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,              // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      VK_FENCE_CREATE_SIGNALED_BIT                      // VkFenceCreateFlags             flags
+    };
+
+    for( size_t i = 0; i < Vulkan.RenderingResources.size(); ++i ) {
+      if( vkCreateFence( GetDevice(), &fence_create_info, nullptr, &Vulkan.RenderingResources[i].Fence ) != VK_SUCCESS ) {
+        std::cout << "Could not create a fence!" << std::endl;
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool Tutorial04::PrepareFrame( VkCommandBuffer command_buffer, const ImageParameters &image_parameters, VkFramebuffer &framebuffer ) {
+    if( !CreateFramebuffer( framebuffer, image_parameters.View ) ) {
+      return false;
+    }
+
+    VkCommandBufferBeginInfo command_buffer_begin_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,        // VkStructureType                        sType
+      nullptr,                                            // const void                            *pNext
+      VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,        // VkCommandBufferUsageFlags              flags
+      nullptr                                             // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
+    };
+
+    vkBeginCommandBuffer( command_buffer, &command_buffer_begin_info );
+
+    VkImageSubresourceRange image_subresource_range = {
+      VK_IMAGE_ASPECT_COLOR_BIT,                          // VkImageAspectFlags                     aspectMask
+      0,                                                  // uint32_t                               baseMipLevel
+      1,                                                  // uint32_t                               levelCount
+      0,                                                  // uint32_t                               baseArrayLayer
+      1                                                   // uint32_t                               layerCount
+    };
+
+    if( GetPresentQueue().Handle != GetGraphicsQueue().Handle ) {
+      VkImageMemoryBarrier barrier_from_present_to_draw = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,           // VkStructureType                        sType
+        nullptr,                                          // const void                            *pNext
+        VK_ACCESS_MEMORY_READ_BIT,                        // VkAccessFlags                          srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                        // VkAccessFlags                          dstAccessMask
+        VK_IMAGE_LAYOUT_UNDEFINED,                        // VkImageLayout                          oldLayout
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,                  // VkImageLayout                          newLayout
+        GetPresentQueue().FamilyIndex,                    // uint32_t                               srcQueueFamilyIndex
+        GetGraphicsQueue().FamilyIndex,                   // uint32_t                               dstQueueFamilyIndex
+        image_parameters.Handle,                          // VkImage                                image
+        image_subresource_range                           // VkImageSubresourceRange                subresourceRange
+      };
+      vkCmdPipelineBarrier( command_buffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_draw );
+    }
+
+    VkClearValue clear_value = {
+      { 1.0f, 0.8f, 0.4f, 0.0f },                         // VkClearColorValue                      color
+    };
+
+    VkRenderPassBeginInfo render_pass_begin_info = {
+      VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,           // VkStructureType                        sType
+      nullptr,                                            // const void                            *pNext
+      Vulkan.RenderPass,                                  // VkRenderPass                           renderPass
+      framebuffer,                                        // VkFramebuffer                          framebuffer
+      {                                                   // VkRect2D                               renderArea
+        {                                                 // VkOffset2D                             offset
+          0,                                                // int32_t                                x
+          0                                                 // int32_t                                y
+        },
+        GetSwapChain().Extent,                            // VkExtent2D                             extent;
+      },
+      1,                                                  // uint32_t                               clearValueCount
+      &clear_value                                        // const VkClearValue                    *pClearValues
+    };
+
+    vkCmdBeginRenderPass( command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE );
+
+    vkCmdBindPipeline( command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, Vulkan.GraphicsPipeline );
+
+    VkViewport viewport = {
+      0.0f,                                               // float                                  x
+      0.0f,                                               // float                                  y
+      static_cast<float>(GetSwapChain().Extent.width),    // float                                  width
+      static_cast<float>(GetSwapChain().Extent.height),   // float                                  height
+      0.0f,                                               // float                                  minDepth
+      1.0f                                                // float                                  maxDepth
+    };
+
+    VkRect2D scissor = {
+      {                                                   // VkOffset2D                             offset
+        0,                                                  // int32_t                                x
+        0                                                   // int32_t                                y
+      },
+      {                                                   // VkExtent2D                             extent
+        GetSwapChain().Extent.width,                        // uint32_t                               width
+        GetSwapChain().Extent.height                        // uint32_t                               height
+      }
+    };
+
+    vkCmdSetViewport( command_buffer, 0, 1, &viewport );
+    vkCmdSetScissor( command_buffer, 0, 1, &scissor );
+
+    VkDeviceSize offset = 0;
+    vkCmdBindVertexBuffers( command_buffer, 0, 1, &Vulkan.VertexBuffer.Handle, &offset );
+
+    vkCmdDraw( command_buffer, 4, 1, 0, 0 );
+
+    vkCmdEndRenderPass( command_buffer );
+
+    if( GetGraphicsQueue().Handle != GetPresentQueue().Handle ) {
+      VkImageMemoryBarrier barrier_from_draw_to_present = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,           // VkStructureType                        sType
+        nullptr,                                          // const void                            *pNext
+        VK_ACCESS_MEMORY_READ_BIT,                        // VkAccessFlags                          srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                        // VkAccessFlags                          dstAccessMask
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,                  // VkImageLayout                          oldLayout
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,                  // VkImageLayout                          newLayout
+        GetGraphicsQueue().FamilyIndex,                   // uint32_t                               srcQueueFamilyIndex
+        GetPresentQueue().FamilyIndex,                    // uint32_t                               dstQueueFamilyIndex
+        image_parameters.Handle,                          // VkImage                                image
+        image_subresource_range                           // VkImageSubresourceRange                subresourceRange
+      };
+      vkCmdPipelineBarrier( command_buffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_draw_to_present );
+    }
+
+    if( vkEndCommandBuffer( command_buffer ) != VK_SUCCESS ) {
+      std::cout << "Could not record command buffer!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateFramebuffer( VkFramebuffer &framebuffer, VkImageView image_view ) {
+    if( framebuffer != VK_NULL_HANDLE ) {
+      vkDestroyFramebuffer( GetDevice(), framebuffer, nullptr );
+      framebuffer = VK_NULL_HANDLE;
+    }
+
+    VkFramebufferCreateInfo framebuffer_create_info = {
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,      // VkStructureType                sType
+      nullptr,                                        // const void                    *pNext
+      0,                                              // VkFramebufferCreateFlags       flags
+      Vulkan.RenderPass,                              // VkRenderPass                   renderPass
+      1,                                              // uint32_t                       attachmentCount
+      &image_view,                                    // const VkImageView             *pAttachments
+      GetSwapChain().Extent.width,                    // uint32_t                       width
+      GetSwapChain().Extent.height,                   // uint32_t                       height
+      1                                               // uint32_t                       layers
+    };
+
+    if( vkCreateFramebuffer( GetDevice(), &framebuffer_create_info, nullptr, &framebuffer ) != VK_SUCCESS ) {
+      std::cout << "Could not create a framebuffer!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial04::ChildOnWindowSizeChanged() {
+    return true;
+  }
+
+  bool Tutorial04::Draw() {
+    static size_t           resource_index = 0;
+    RenderingResourcesData &current_rendering_resource = Vulkan.RenderingResources[resource_index];
+    VkSwapchainKHR          swap_chain = GetSwapChain().Handle;
+    uint32_t                image_index;
+
+    resource_index = (resource_index + 1) % VulkanTutorial04Parameters::ResourcesCount;
+
+    if( vkWaitForFences( GetDevice(), 1, &current_rendering_resource.Fence, VK_FALSE, 1000000000 ) != VK_SUCCESS ) {
+      std::cout << "Waiting for fence takes too long!" << std::endl;
+      return false;
+    }
+    vkResetFences( GetDevice(), 1, &current_rendering_resource.Fence );
+
+    VkResult result = vkAcquireNextImageKHR( GetDevice(), swap_chain, UINT64_MAX, current_rendering_resource.ImageAvailableSemaphore, VK_NULL_HANDLE, &image_index );
+    switch( result ) {
+      case VK_SUCCESS:
+      case VK_SUBOPTIMAL_KHR:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during swap chain image acquisition!" << std::endl;
+        return false;
+    }
+
+    if( !PrepareFrame( current_rendering_resource.CommandBuffer, GetSwapChain().Images[image_index], current_rendering_resource.Framebuffer ) ) {
+      return false;
+    }
+
+    VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    VkSubmitInfo submit_info = {
+      VK_STRUCTURE_TYPE_SUBMIT_INFO,                          // VkStructureType              sType
+      nullptr,                                                // const void                  *pNext
+      1,                                                      // uint32_t                     waitSemaphoreCount
+      &current_rendering_resource.ImageAvailableSemaphore,    // const VkSemaphore           *pWaitSemaphores
+      &wait_dst_stage_mask,                                   // const VkPipelineStageFlags  *pWaitDstStageMask;
+      1,                                                      // uint32_t                     commandBufferCount
+      &current_rendering_resource.CommandBuffer,              // const VkCommandBuffer       *pCommandBuffers
+      1,                                                      // uint32_t                     signalSemaphoreCount
+      &current_rendering_resource.FinishedRenderingSemaphore  // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_info, current_rendering_resource.Fence ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    VkPresentInfoKHR present_info = {
+      VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,                     // VkStructureType              sType
+      nullptr,                                                // const void                  *pNext
+      1,                                                      // uint32_t                     waitSemaphoreCount
+      &current_rendering_resource.FinishedRenderingSemaphore, // const VkSemaphore           *pWaitSemaphores
+      1,                                                      // uint32_t                     swapchainCount
+      &swap_chain,                                            // const VkSwapchainKHR        *pSwapchains
+      &image_index,                                           // const uint32_t              *pImageIndices
+      nullptr                                                 // VkResult                    *pResults
+    };
+    result = vkQueuePresentKHR( GetPresentQueue().Handle, &present_info );
+
+    switch( result ) {
+      case VK_SUCCESS:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+      case VK_SUBOPTIMAL_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during image presentation!" << std::endl;
+        return false;
+    }
+
+    return true;
+  }
+
+  void Tutorial04::ChildClear() {
+  }
+
+  Tutorial04::~Tutorial04() {
+    if( GetDevice() != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( GetDevice() );
+
+      for( size_t i = 0; i < Vulkan.RenderingResources.size(); ++i ) {
+        if( Vulkan.RenderingResources[i].Framebuffer != VK_NULL_HANDLE ) {
+          vkDestroyFramebuffer( GetDevice(), Vulkan.RenderingResources[i].Framebuffer, nullptr );
+        }
+        if( Vulkan.RenderingResources[i].CommandBuffer != VK_NULL_HANDLE ) {
+          vkFreeCommandBuffers( GetDevice(), Vulkan.CommandPool, 1, &Vulkan.RenderingResources[i].CommandBuffer );
+        }
+        if( Vulkan.RenderingResources[i].ImageAvailableSemaphore != VK_NULL_HANDLE ) {
+          vkDestroySemaphore( GetDevice(), Vulkan.RenderingResources[i].ImageAvailableSemaphore, nullptr );
+        }
+        if( Vulkan.RenderingResources[i].FinishedRenderingSemaphore != VK_NULL_HANDLE ) {
+          vkDestroySemaphore( GetDevice(), Vulkan.RenderingResources[i].FinishedRenderingSemaphore, nullptr );
+        }
+        if( Vulkan.RenderingResources[i].Fence != VK_NULL_HANDLE ) {
+          vkDestroyFence( GetDevice(), Vulkan.RenderingResources[i].Fence, nullptr );
+        }
+      }
+
+      if( Vulkan.CommandPool != VK_NULL_HANDLE ) {
+        vkDestroyCommandPool( GetDevice(), Vulkan.CommandPool, nullptr );
+        Vulkan.CommandPool = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.VertexBuffer.Handle != VK_NULL_HANDLE ) {
+        vkDestroyBuffer( GetDevice(), Vulkan.VertexBuffer.Handle, nullptr );
+        Vulkan.VertexBuffer.Handle = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.VertexBuffer.Memory != VK_NULL_HANDLE ) {
+        vkFreeMemory( GetDevice(), Vulkan.VertexBuffer.Memory, nullptr );
+        Vulkan.VertexBuffer.Memory = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.GraphicsPipeline != VK_NULL_HANDLE ) {
+        vkDestroyPipeline( GetDevice(), Vulkan.GraphicsPipeline, nullptr );
+        Vulkan.GraphicsPipeline = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.RenderPass != VK_NULL_HANDLE ) {
+        vkDestroyRenderPass( GetDevice(), Vulkan.RenderPass, nullptr );
+        Vulkan.RenderPass = VK_NULL_HANDLE;
+      }
+    }
+  }
+
+} // namespace ApiWithoutSecrets

Project/Tutorials/04/Tutorial04.h

@@ -0,0 +1,133 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_04_HEADER)
+#define TUTORIAL_04_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // BufferParameters                                             //
+  //                                                              //
+  // Vulkan Buffer's parameters container class                   //
+  // ************************************************************ //
+  struct BufferParameters {
+    VkBuffer                        Handle;
+    VkDeviceMemory                  Memory;
+    uint32_t                        Size;
+
+    BufferParameters() :
+      Handle( VK_NULL_HANDLE ),
+      Memory( VK_NULL_HANDLE ),
+      Size( 0 ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VertexData                                                   //
+  //                                                              //
+  // Struct describing data type and format of vertex attributes  //
+  // ************************************************************ //
+  struct VertexData {
+    float   x, y, z, w;
+    float   r, g, b, a;
+  };
+
+  // ************************************************************ //
+  // RenderingResourcesData                                       //
+  //                                                              //
+  // Struct containing data used during rendering process         //
+  // ************************************************************ //
+  struct RenderingResourcesData {
+    VkFramebuffer                         Framebuffer;
+    VkCommandBuffer                       CommandBuffer;
+    VkSemaphore                           ImageAvailableSemaphore;
+    VkSemaphore                           FinishedRenderingSemaphore;
+    VkFence                               Fence;
+
+    RenderingResourcesData() :
+      Framebuffer( VK_NULL_HANDLE ),
+      CommandBuffer( VK_NULL_HANDLE ),
+      ImageAvailableSemaphore( VK_NULL_HANDLE ),
+      FinishedRenderingSemaphore( VK_NULL_HANDLE ),
+      Fence( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VulkanTutorial04Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial04Parameters {
+    VkRenderPass                          RenderPass;
+    VkPipeline                            GraphicsPipeline;
+    BufferParameters                      VertexBuffer;
+    VkCommandPool                         CommandPool;
+    std::vector<RenderingResourcesData>   RenderingResources;
+
+    static const size_t                   ResourcesCount = 3;
+
+    VulkanTutorial04Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      GraphicsPipeline( VK_NULL_HANDLE ),
+      VertexBuffer(),
+      CommandPool( VK_NULL_HANDLE ),
+      RenderingResources( ResourcesCount ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial04                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial04 : public VulkanCommon {
+  public:
+    Tutorial04();
+    ~Tutorial04();
+
+    bool    CreateRenderPass();
+    bool    CreatePipeline();
+    bool    CreateVertexBuffer();
+    bool    CreateRenderingResources();
+
+    bool    Draw() override;
+
+  private:
+    VulkanTutorial04Parameters  Vulkan;
+
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>     CreateShaderModule( const char* filename );
+    Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> CreatePipelineLayout();
+    bool                                                              AllocateBufferMemory( VkBuffer buffer, VkDeviceMemory *memory );
+    bool                                                              CreateCommandPool( uint32_t queue_family_index, VkCommandPool *pool );
+    bool                                                              AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers );
+    bool                                                              CreateCommandBuffers();
+    bool                                                              CreateSemaphores();
+    bool                                                              CreateFences();
+    bool                                                              PrepareFrame( VkCommandBuffer command_buffer, const ImageParameters &image_parameters, VkFramebuffer &framebuffer );
+    bool                                                              CreateFramebuffer( VkFramebuffer &framebuffer, VkImageView image_view );
+
+    void                                                              ChildClear() override;
+    bool                                                              ChildOnWindowSizeChanged() override;
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_04_HEADER

Project/Tutorials/04/main.cpp

@@ -0,0 +1,53 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial04.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial04 tutorial04;
+
+  // Window creation
+  if( !window.Create( "04 - Vertex Attributes" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial04.PrepareVulkan( window.GetParameters() ) ) {
+    return -1;
+  }
+
+  // Tutorial 04
+  if( !tutorial04.CreateRenderPass() ) {
+    return -1;
+  }
+  if( !tutorial04.CreatePipeline() ) {
+    return -1;
+  }
+  if( !tutorial04.CreateVertexBuffer() ) {
+    return -1;
+  }
+  if( !tutorial04.CreateRenderingResources() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial04 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorials/05/Data/frag.spv.txt

@@ -0,0 +1,36 @@
+Tutorial05/Data05/shader.frag
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked fragment stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 13
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 9 11
+                              ExecutionMode 4 OriginLowerLeft
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 9  "o_Color"
+                              Name 11  "v_Color"
+                              Decorate 9(o_Color) Location 0
+                              Decorate 11(v_Color) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Output 7(fvec4)
+      9(o_Color):      8(ptr) Variable Output
+              10:             TypePointer Input 7(fvec4)
+     11(v_Color):     10(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              12:    7(fvec4) Load 11(v_Color)
+                              Store 9(o_Color) 12
+                              Return
+                              FunctionEnd

Project/Tutorials/05/Data/shader.frag

@@ -0,0 +1,19 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(location = 0) in vec4 v_Color;
+
+layout(location = 0) out vec4 o_Color;
+
+void main() {
+  o_Color = v_Color;
+}

Project/Tutorials/05/Data/shader.vert

@@ -0,0 +1,26 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(location = 0) in vec4 i_Position;
+layout(location = 1) in vec4 i_Color;
+
+out gl_PerVertex
+{
+  vec4 gl_Position;
+};
+
+layout(location = 0) out vec4 v_Color;
+
+void main() {
+    gl_Position = i_Position;
+    v_Color = i_Color;
+}

Project/Tutorials/05/Data/vert.spv.txt

@@ -0,0 +1,51 @@
+Tutorial05/Data05/shader.vert
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked vertex stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 21
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 10 14 18 19
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 8  "gl_PerVertex"
+                              MemberName 8(gl_PerVertex) 0  "gl_Position"
+                              Name 10  ""
+                              Name 14  "i_Position"
+                              Name 18  "v_Color"
+                              Name 19  "i_Color"
+                              MemberDecorate 8(gl_PerVertex) 0 BuiltIn Position
+                              Decorate 8(gl_PerVertex) Block
+                              Decorate 14(i_Position) Location 0
+                              Decorate 18(v_Color) Location 0
+                              Decorate 19(i_Color) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+ 8(gl_PerVertex):             TypeStruct 7(fvec4)
+               9:             TypePointer Output 8(gl_PerVertex)
+              10:      9(ptr) Variable Output
+              11:             TypeInt 32 1
+              12:     11(int) Constant 0
+              13:             TypePointer Input 7(fvec4)
+  14(i_Position):     13(ptr) Variable Input
+              16:             TypePointer Output 7(fvec4)
+     18(v_Color):     16(ptr) Variable Output
+     19(i_Color):     13(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              15:    7(fvec4) Load 14(i_Position)
+              17:     16(ptr) AccessChain 10 12
+                              Store 17 15
+              20:    7(fvec4) Load 19(i_Color)
+                              Store 18(v_Color) 20
+                              Return
+                              FunctionEnd

Project/Tutorials/05/Tutorial05.cpp

@@ -0,0 +1,863 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial05.h"
+#include "VulkanFunctions.h"
+
+namespace ApiWithoutSecrets {
+
+  Tutorial05::Tutorial05() :
+    Vulkan() {
+  }
+
+  bool Tutorial05::CreateRenderingResources() {
+    if( !CreateCommandPool( GetGraphicsQueue().FamilyIndex, &Vulkan.CommandPool ) ) {
+      return false;
+    }
+
+    for( size_t i = 0; i < Vulkan.RenderingResources.size(); ++i ) {
+      if( !AllocateCommandBuffers( Vulkan.CommandPool, 1, &Vulkan.RenderingResources[i].CommandBuffer ) ) {
+        return false;
+      }
+
+      if( !CreateSemaphore( &Vulkan.RenderingResources[i].ImageAvailableSemaphore ) ) {
+        return false;
+      }
+
+      if( !CreateSemaphore( &Vulkan.RenderingResources[i].FinishedRenderingSemaphore ) ) {
+        return false;
+      }
+
+      if( !CreateFence( VK_FENCE_CREATE_SIGNALED_BIT, &Vulkan.RenderingResources[i].Fence ) ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool Tutorial05::CreateCommandPool( uint32_t queue_family_index, VkCommandPool *pool ) {
+    VkCommandPoolCreateInfo cmd_pool_create_info = {
+      VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,       // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | // VkCommandPoolCreateFlags       flags
+      VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
+      queue_family_index                                // uint32_t                       queueFamilyIndex
+    };
+
+    if( vkCreateCommandPool( GetDevice(), &cmd_pool_create_info, nullptr, pool ) != VK_SUCCESS ) {
+      std::cout << "Could not create command pool!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial05::AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers ) {
+    VkCommandBufferAllocateInfo command_buffer_allocate_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      pool,                                             // VkCommandPool                  commandPool
+      VK_COMMAND_BUFFER_LEVEL_PRIMARY,                  // VkCommandBufferLevel           level
+      count                                             // uint32_t                       bufferCount
+    };
+
+    if( vkAllocateCommandBuffers( GetDevice(), &command_buffer_allocate_info, command_buffers ) != VK_SUCCESS ) {
+      std::cout << "Could not allocate command buffer!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial05::CreateSemaphore( VkSemaphore *semaphore ) {
+    VkSemaphoreCreateInfo semaphore_create_info = {
+      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,          // VkStructureType                sType
+      nullptr,                                          // const void*                    pNext
+      0                                                 // VkSemaphoreCreateFlags         flags
+    };
+
+    if( vkCreateSemaphore( GetDevice(), &semaphore_create_info, nullptr, semaphore ) != VK_SUCCESS ) {
+      std::cout << "Could not create semaphore!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial05::CreateFence( VkFenceCreateFlags flags, VkFence *fence ) {
+    VkFenceCreateInfo fence_create_info = {
+      VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,              // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      flags                                             // VkFenceCreateFlags             flags
+    };
+
+    if( vkCreateFence( GetDevice(), &fence_create_info, nullptr, fence ) != VK_SUCCESS ) {
+      std::cout << "Could not create a fence!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial05::CreateRenderPass() {
+    VkAttachmentDescription attachment_descriptions[] = {
+      {
+        0,                                              // VkAttachmentDescriptionFlags   flags
+        GetSwapChain().Format,                          // VkFormat                       format
+        VK_SAMPLE_COUNT_1_BIT,                          // VkSampleCountFlagBits          samples
+        VK_ATTACHMENT_LOAD_OP_CLEAR,                    // VkAttachmentLoadOp             loadOp
+        VK_ATTACHMENT_STORE_OP_STORE,                   // VkAttachmentStoreOp            storeOp
+        VK_ATTACHMENT_LOAD_OP_DONT_CARE,                // VkAttachmentLoadOp             stencilLoadOp
+        VK_ATTACHMENT_STORE_OP_DONT_CARE,               // VkAttachmentStoreOp            stencilStoreOp
+        VK_IMAGE_LAYOUT_UNDEFINED,                      // VkImageLayout                  initialLayout;
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR                 // VkImageLayout                  finalLayout
+      }
+    };
+
+    VkAttachmentReference color_attachment_references[] = {
+      {
+        0,                                              // uint32_t                       attachment
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL        // VkImageLayout                  layout
+      }
+    };
+
+    VkSubpassDescription subpass_descriptions[] = {
+      {
+        0,                                              // VkSubpassDescriptionFlags      flags
+        VK_PIPELINE_BIND_POINT_GRAPHICS,                // VkPipelineBindPoint            pipelineBindPoint
+        0,                                              // uint32_t                       inputAttachmentCount
+        nullptr,                                        // const VkAttachmentReference   *pInputAttachments
+        1,                                              // uint32_t                       colorAttachmentCount
+        color_attachment_references,                    // const VkAttachmentReference   *pColorAttachments
+        nullptr,                                        // const VkAttachmentReference   *pResolveAttachments
+        nullptr,                                        // const VkAttachmentReference   *pDepthStencilAttachment
+        0,                                              // uint32_t                       preserveAttachmentCount
+        nullptr                                         // const uint32_t*                pPreserveAttachments
+      }
+    };
+
+    std::vector<VkSubpassDependency> dependencies = {
+      {
+        VK_SUBPASS_EXTERNAL,                            // uint32_t                       srcSubpass
+        0,                                              // uint32_t                       dstSubpass
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,           // VkPipelineStageFlags           srcStageMask
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,  // VkPipelineStageFlags           dstStageMask
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                  srcAccessMask
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                  dstAccessMask
+        VK_DEPENDENCY_BY_REGION_BIT                     // VkDependencyFlags              dependencyFlags
+      },
+      {
+        0,                                              // uint32_t                       srcSubpass
+        VK_SUBPASS_EXTERNAL,                            // uint32_t                       dstSubpass
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,  // VkPipelineStageFlags           srcStageMask
+        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,           // VkPipelineStageFlags           dstStageMask
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,           // VkAccessFlags                  srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                  dstAccessMask
+        VK_DEPENDENCY_BY_REGION_BIT                     // VkDependencyFlags              dependencyFlags
+      }
+    };
+
+    VkRenderPassCreateInfo render_pass_create_info = {
+      VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,        // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkRenderPassCreateFlags        flags
+      1,                                                // uint32_t                       attachmentCount
+      attachment_descriptions,                          // const VkAttachmentDescription *pAttachments
+      1,                                                // uint32_t                       subpassCount
+      subpass_descriptions,                             // const VkSubpassDescription    *pSubpasses
+      static_cast<uint32_t>(dependencies.size()),       // uint32_t                       dependencyCount
+      &dependencies[0]                                  // const VkSubpassDependency     *pDependencies
+    };
+
+    if( vkCreateRenderPass( GetDevice(), &render_pass_create_info, nullptr, &Vulkan.RenderPass ) != VK_SUCCESS ) {
+      std::cout << "Could not create render pass!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> Tutorial05::CreateShaderModule( const char* filename ) {
+    const std::vector<char> code = Tools::GetBinaryFileContents( filename );
+    if( code.size() == 0 ) {
+      return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>();
+    }
+
+    VkShaderModuleCreateInfo shader_module_create_info = {
+      VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,      // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkShaderModuleCreateFlags      flags
+      code.size(),                                      // size_t                         codeSize
+      reinterpret_cast<const uint32_t*>(&code[0])       // const uint32_t                *pCode
+    };
+
+    VkShaderModule shader_module;
+    if( vkCreateShaderModule( GetDevice(), &shader_module_create_info, nullptr, &shader_module ) != VK_SUCCESS ) {
+      std::cout << "Could not create shader module from a \"" << filename << "\" file!" << std::endl;
+      return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>();
+    }
+
+    return Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>( shader_module, vkDestroyShaderModule, GetDevice() );
+  }
+
+  Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> Tutorial05::CreatePipelineLayout() {
+    VkPipelineLayoutCreateInfo layout_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,    // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkPipelineLayoutCreateFlags    flags
+      0,                                                // uint32_t                       setLayoutCount
+      nullptr,                                          // const VkDescriptorSetLayout   *pSetLayouts
+      0,                                                // uint32_t                       pushConstantRangeCount
+      nullptr                                           // const VkPushConstantRange     *pPushConstantRanges
+    };
+
+    VkPipelineLayout pipeline_layout;
+    if( vkCreatePipelineLayout( GetDevice(), &layout_create_info, nullptr, &pipeline_layout ) != VK_SUCCESS ) {
+      std::cout << "Could not create pipeline layout!" << std::endl;
+      return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>();
+    }
+
+    return Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout>( pipeline_layout, vkDestroyPipelineLayout, GetDevice() );
+  }
+
+  bool Tutorial05::CreatePipeline() {
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> vertex_shader_module = CreateShaderModule( "Data/Tutorials/05/vert.spv" );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> fragment_shader_module = CreateShaderModule( "Data/Tutorials/05/frag.spv" );
+
+    if( !vertex_shader_module || !fragment_shader_module ) {
+      return false;
+    }
+
+    std::vector<VkPipelineShaderStageCreateInfo> shader_stage_create_infos = {
+      // Vertex shader
+      {
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,        // VkStructureType                                sType
+        nullptr,                                                    // const void                                    *pNext
+        0,                                                          // VkPipelineShaderStageCreateFlags               flags
+        VK_SHADER_STAGE_VERTEX_BIT,                                 // VkShaderStageFlagBits                          stage
+        vertex_shader_module.Get(),                                 // VkShaderModule                                 module
+        "main",                                                     // const char                                    *pName
+        nullptr                                                     // const VkSpecializationInfo                    *pSpecializationInfo
+      },
+      // Fragment shader
+      {
+        VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,        // VkStructureType                                sType
+        nullptr,                                                    // const void                                    *pNext
+        0,                                                          // VkPipelineShaderStageCreateFlags               flags
+        VK_SHADER_STAGE_FRAGMENT_BIT,                               // VkShaderStageFlagBits                          stage
+        fragment_shader_module.Get(),                               // VkShaderModule                                 module
+        "main",                                                     // const char                                    *pName
+        nullptr                                                     // const VkSpecializationInfo                    *pSpecializationInfo
+      }
+    };
+
+    std::vector<VkVertexInputBindingDescription> vertex_binding_descriptions = {
+      {
+        0,                                                          // uint32_t                                       binding
+        sizeof(VertexData),                                         // uint32_t                                       stride
+        VK_VERTEX_INPUT_RATE_VERTEX                                 // VkVertexInputRate                              inputRate
+      }
+    };
+
+    std::vector<VkVertexInputAttributeDescription> vertex_attribute_descriptions = {
+      {
+        0,                                                          // uint32_t                                       location
+        vertex_binding_descriptions[0].binding,                     // uint32_t                                       binding
+        VK_FORMAT_R32G32B32A32_SFLOAT,                              // VkFormat                                       format
+        offsetof(struct VertexData, x)                              // uint32_t                                       offset
+      },
+      {
+        1,                                                          // uint32_t                                       location
+        vertex_binding_descriptions[0].binding,                     // uint32_t                                       binding
+        VK_FORMAT_R32G32B32A32_SFLOAT,                              // VkFormat                                       format
+        offsetof(struct VertexData, r)                              // uint32_t                                       offset
+      }
+    };
+
+    VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,    // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineVertexInputStateCreateFlags          flags
+      static_cast<uint32_t>(vertex_binding_descriptions.size()),    // uint32_t                                       vertexBindingDescriptionCount
+      &vertex_binding_descriptions[0],                              // const VkVertexInputBindingDescription         *pVertexBindingDescriptions
+      static_cast<uint32_t>(vertex_attribute_descriptions.size()),  // uint32_t                                       vertexAttributeDescriptionCount
+      &vertex_attribute_descriptions[0]                             // const VkVertexInputAttributeDescription       *pVertexAttributeDescriptions
+    };
+
+    VkPipelineInputAssemblyStateCreateInfo input_assembly_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,  // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineInputAssemblyStateCreateFlags        flags
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,                         // VkPrimitiveTopology                            topology
+      VK_FALSE                                                      // VkBool32                                       primitiveRestartEnable
+    };
+
+    VkPipelineViewportStateCreateInfo viewport_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,        // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineViewportStateCreateFlags             flags
+      1,                                                            // uint32_t                                       viewportCount
+      nullptr,                                                      // const VkViewport                              *pViewports
+      1,                                                            // uint32_t                                       scissorCount
+      nullptr                                                       // const VkRect2D                                *pScissors
+    };
+
+    VkPipelineRasterizationStateCreateInfo rasterization_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,   // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineRasterizationStateCreateFlags        flags
+      VK_FALSE,                                                     // VkBool32                                       depthClampEnable
+      VK_FALSE,                                                     // VkBool32                                       rasterizerDiscardEnable
+      VK_POLYGON_MODE_FILL,                                         // VkPolygonMode                                  polygonMode
+      VK_CULL_MODE_BACK_BIT,                                        // VkCullModeFlags                                cullMode
+      VK_FRONT_FACE_COUNTER_CLOCKWISE,                              // VkFrontFace                                    frontFace
+      VK_FALSE,                                                     // VkBool32                                       depthBiasEnable
+      0.0f,                                                         // float                                          depthBiasConstantFactor
+      0.0f,                                                         // float                                          depthBiasClamp
+      0.0f,                                                         // float                                          depthBiasSlopeFactor
+      1.0f                                                          // float                                          lineWidth
+    };
+
+    VkPipelineMultisampleStateCreateInfo multisample_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,     // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineMultisampleStateCreateFlags          flags
+      VK_SAMPLE_COUNT_1_BIT,                                        // VkSampleCountFlagBits                          rasterizationSamples
+      VK_FALSE,                                                     // VkBool32                                       sampleShadingEnable
+      1.0f,                                                         // float                                          minSampleShading
+      nullptr,                                                      // const VkSampleMask                            *pSampleMask
+      VK_FALSE,                                                     // VkBool32                                       alphaToCoverageEnable
+      VK_FALSE                                                      // VkBool32                                       alphaToOneEnable
+    };
+
+    VkPipelineColorBlendAttachmentState color_blend_attachment_state = {
+      VK_FALSE,                                                     // VkBool32                                       blendEnable
+      VK_BLEND_FACTOR_ONE,                                          // VkBlendFactor                                  srcColorBlendFactor
+      VK_BLEND_FACTOR_ZERO,                                         // VkBlendFactor                                  dstColorBlendFactor
+      VK_BLEND_OP_ADD,                                              // VkBlendOp                                      colorBlendOp
+      VK_BLEND_FACTOR_ONE,                                          // VkBlendFactor                                  srcAlphaBlendFactor
+      VK_BLEND_FACTOR_ZERO,                                         // VkBlendFactor                                  dstAlphaBlendFactor
+      VK_BLEND_OP_ADD,                                              // VkBlendOp                                      alphaBlendOp
+      VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |         // VkColorComponentFlags                          colorWriteMask
+      VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
+    };
+
+    VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,     // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineColorBlendStateCreateFlags           flags
+      VK_FALSE,                                                     // VkBool32                                       logicOpEnable
+      VK_LOGIC_OP_COPY,                                             // VkLogicOp                                      logicOp
+      1,                                                            // uint32_t                                       attachmentCount
+      &color_blend_attachment_state,                                // const VkPipelineColorBlendAttachmentState     *pAttachments
+      { 0.0f, 0.0f, 0.0f, 0.0f }                                    // float                                          blendConstants[4]
+    };
+
+    std::vector<VkDynamicState> dynamic_states = {
+      VK_DYNAMIC_STATE_VIEWPORT,
+      VK_DYNAMIC_STATE_SCISSOR,
+    };
+
+    VkPipelineDynamicStateCreateInfo dynamic_state_create_info = {
+      VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,         // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineDynamicStateCreateFlags              flags
+      static_cast<uint32_t>(dynamic_states.size()),                 // uint32_t                                       dynamicStateCount
+      &dynamic_states[0]                                            // const VkDynamicState                          *pDynamicStates
+    };
+
+    Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> pipeline_layout = CreatePipelineLayout();
+    if( !pipeline_layout ) {
+      return false;
+    }
+
+    VkGraphicsPipelineCreateInfo pipeline_create_info = {
+      VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,              // VkStructureType                                sType
+      nullptr,                                                      // const void                                    *pNext
+      0,                                                            // VkPipelineCreateFlags                          flags
+      static_cast<uint32_t>(shader_stage_create_infos.size()),      // uint32_t                                       stageCount
+      &shader_stage_create_infos[0],                                // const VkPipelineShaderStageCreateInfo         *pStages
+      &vertex_input_state_create_info,                              // const VkPipelineVertexInputStateCreateInfo    *pVertexInputState;
+      &input_assembly_state_create_info,                            // const VkPipelineInputAssemblyStateCreateInfo  *pInputAssemblyState
+      nullptr,                                                      // const VkPipelineTessellationStateCreateInfo   *pTessellationState
+      &viewport_state_create_info,                                  // const VkPipelineViewportStateCreateInfo       *pViewportState
+      &rasterization_state_create_info,                             // const VkPipelineRasterizationStateCreateInfo  *pRasterizationState
+      &multisample_state_create_info,                               // const VkPipelineMultisampleStateCreateInfo    *pMultisampleState
+      nullptr,                                                      // const VkPipelineDepthStencilStateCreateInfo   *pDepthStencilState
+      &color_blend_state_create_info,                               // const VkPipelineColorBlendStateCreateInfo     *pColorBlendState
+      &dynamic_state_create_info,                                   // const VkPipelineDynamicStateCreateInfo        *pDynamicState
+      pipeline_layout.Get(),                                        // VkPipelineLayout                               layout
+      Vulkan.RenderPass,                                            // VkRenderPass                                   renderPass
+      0,                                                            // uint32_t                                       subpass
+      VK_NULL_HANDLE,                                               // VkPipeline                                     basePipelineHandle
+      -1                                                            // int32_t                                        basePipelineIndex
+    };
+
+    if( vkCreateGraphicsPipelines( GetDevice(), VK_NULL_HANDLE, 1, &pipeline_create_info, nullptr, &Vulkan.GraphicsPipeline ) != VK_SUCCESS ) {
+      std::cout << "Could not create graphics pipeline!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial05::CreateVertexBuffer() {
+    const std::vector<float>& vertex_data = GetVertexData();
+
+    Vulkan.VertexBuffer.Size = static_cast<uint32_t>(vertex_data.size() * sizeof(vertex_data[0]));
+    if( !CreateBuffer( VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, Vulkan.VertexBuffer ) ) {
+      std::cout << "Could not create vertex buffer!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial05::CreateStagingBuffer() {
+    Vulkan.StagingBuffer.Size = 4000;
+    if( !CreateBuffer( VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, Vulkan.StagingBuffer ) ) {
+      std::cout << "Could not staging buffer!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial05::CreateBuffer( VkBufferUsageFlags usage, VkMemoryPropertyFlagBits memoryProperty, BufferParameters &buffer ) {
+    VkBufferCreateInfo buffer_create_info = {
+      VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,             // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkBufferCreateFlags            flags
+      buffer.Size,                                      // VkDeviceSize                   size
+      usage,                                            // VkBufferUsageFlags             usage
+      VK_SHARING_MODE_EXCLUSIVE,                        // VkSharingMode                  sharingMode
+      0,                                                // uint32_t                       queueFamilyIndexCount
+      nullptr                                           // const uint32_t                *pQueueFamilyIndices
+    };
+
+    if( vkCreateBuffer( GetDevice(), &buffer_create_info, nullptr, &buffer.Handle ) != VK_SUCCESS ) {
+      std::cout << "Could not create buffer!" << std::endl;
+      return false;
+    }
+
+    if( !AllocateBufferMemory( buffer.Handle, memoryProperty, &buffer.Memory ) ) {
+      std::cout << "Could not allocate memory for a buffer!" << std::endl;
+      return false;
+    }
+
+    if( vkBindBufferMemory( GetDevice(), buffer.Handle, buffer.Memory, 0 ) != VK_SUCCESS ) {
+      std::cout << "Could not bind memory to a buffer!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial05::AllocateBufferMemory( VkBuffer buffer, VkMemoryPropertyFlagBits property, VkDeviceMemory *memory ) {
+    VkMemoryRequirements buffer_memory_requirements;
+    vkGetBufferMemoryRequirements( GetDevice(), buffer, &buffer_memory_requirements );
+
+    VkPhysicalDeviceMemoryProperties memory_properties;
+    vkGetPhysicalDeviceMemoryProperties( GetPhysicalDevice(), &memory_properties );
+
+    for( uint32_t i = 0; i < memory_properties.memoryTypeCount; ++i ) {
+      if( (buffer_memory_requirements.memoryTypeBits & (1 << i)) &&
+         ((memory_properties.memoryTypes[i].propertyFlags & property) == property) ) {
+
+        VkMemoryAllocateInfo memory_allocate_info = {
+          VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,       // VkStructureType                sType
+          nullptr,                                      // const void                    *pNext
+          buffer_memory_requirements.size,              // VkDeviceSize                   allocationSize
+          i                                             // uint32_t                       memoryTypeIndex
+        };
+
+        if( vkAllocateMemory( GetDevice(), &memory_allocate_info, nullptr, memory ) == VK_SUCCESS ) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  const std::vector<float>& Tutorial05::GetVertexData() const {
+    static const std::vector<float> vertex_data = {
+      -0.7f, -0.7f, 0.0f, 1.0f,
+      1.0f, 0.0f, 0.0f, 0.0f,
+      //
+      -0.7f, 0.7f, 0.0f, 1.0f,
+      0.0f, 1.0f, 0.0f, 0.0f,
+      //
+      0.7f, -0.7f, 0.0f, 1.0f,
+      0.0f, 0.0f, 1.0f, 0.0f,
+      //
+      0.7f, 0.7f, 0.0f, 1.0f,
+      0.3f, 0.3f, 0.3f, 0.0f
+    };
+
+    return vertex_data;
+  }
+
+  bool Tutorial05::CopyVertexData() {
+    // Prepare data in a staging buffer
+    const std::vector<float>& vertex_data = GetVertexData();
+
+    void *staging_buffer_memory_pointer;
+    if( vkMapMemory( GetDevice(), Vulkan.StagingBuffer.Memory, 0, Vulkan.VertexBuffer.Size, 0, &staging_buffer_memory_pointer) != VK_SUCCESS ) {
+      std::cout << "Could not map memory and upload data to a staging buffer!" << std::endl;
+      return false;
+    }
+
+    memcpy( staging_buffer_memory_pointer, &vertex_data[0], Vulkan.VertexBuffer.Size );
+
+    VkMappedMemoryRange flush_range = {
+      VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,            // VkStructureType                        sType
+      nullptr,                                          // const void                            *pNext
+      Vulkan.StagingBuffer.Memory,                      // VkDeviceMemory                         memory
+      0,                                                // VkDeviceSize                           offset
+      Vulkan.VertexBuffer.Size                          // VkDeviceSize                           size
+    };
+    vkFlushMappedMemoryRanges( GetDevice(), 1, &flush_range );
+
+    vkUnmapMemory( GetDevice(), Vulkan.StagingBuffer.Memory );
+
+    // Prepare command buffer to copy data from staging buffer to a vertex buffer
+    VkCommandBufferBeginInfo command_buffer_begin_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,      // VkStructureType                        sType
+      nullptr,                                          // const void                            *pNext
+      VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,      // VkCommandBufferUsageFlags              flags
+      nullptr                                           // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
+    };
+
+    VkCommandBuffer command_buffer = Vulkan.RenderingResources[0].CommandBuffer;
+
+    vkBeginCommandBuffer( command_buffer, &command_buffer_begin_info);
+
+    VkBufferCopy buffer_copy_info = {
+      0,                                                // VkDeviceSize                           srcOffset
+      0,                                                // VkDeviceSize                           dstOffset
+      Vulkan.VertexBuffer.Size                          // VkDeviceSize                           size
+    };
+    vkCmdCopyBuffer( command_buffer, Vulkan.StagingBuffer.Handle, Vulkan.VertexBuffer.Handle, 1, &buffer_copy_info );
+
+    VkBufferMemoryBarrier buffer_memory_barrier = {
+      VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,          // VkStructureType                        sType
+      nullptr,                                          // const void                            *pNext
+      VK_ACCESS_MEMORY_WRITE_BIT,                       // VkAccessFlags                          srcAccessMask
+      VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,              // VkAccessFlags                          dstAccessMask
+      VK_QUEUE_FAMILY_IGNORED,                          // uint32_t                               srcQueueFamilyIndex
+      VK_QUEUE_FAMILY_IGNORED,                          // uint32_t                               dstQueueFamilyIndex
+      Vulkan.VertexBuffer.Handle,                       // VkBuffer                               buffer
+      0,                                                // VkDeviceSize                           offset
+      VK_WHOLE_SIZE                                     // VkDeviceSize                           size
+    };
+    vkCmdPipelineBarrier( command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0, 0, nullptr, 1, &buffer_memory_barrier, 0, nullptr );
+
+    vkEndCommandBuffer( command_buffer );
+
+    // Submit command buffer and copy data from staging buffer to a vertex buffer
+    VkSubmitInfo submit_info = {
+      VK_STRUCTURE_TYPE_SUBMIT_INFO,                    // VkStructureType                        sType
+      nullptr,                                          // const void                            *pNext
+      0,                                                // uint32_t                               waitSemaphoreCount
+      nullptr,                                          // const VkSemaphore                     *pWaitSemaphores
+      nullptr,                                          // const VkPipelineStageFlags            *pWaitDstStageMask;
+      1,                                                // uint32_t                               commandBufferCount
+      &command_buffer,                                  // const VkCommandBuffer                 *pCommandBuffers
+      0,                                                // uint32_t                               signalSemaphoreCount
+      nullptr                                           // const VkSemaphore                     *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    vkDeviceWaitIdle( GetDevice() );
+
+    return true;
+  }
+
+  bool Tutorial05::PrepareFrame( VkCommandBuffer command_buffer, const ImageParameters &image_parameters, VkFramebuffer &framebuffer ) {
+    if( !CreateFramebuffer( framebuffer, image_parameters.View ) ) {
+      return false;
+    }
+
+    VkCommandBufferBeginInfo command_buffer_begin_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,      // VkStructureType                        sType
+      nullptr,                                          // const void                            *pNext
+      VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,      // VkCommandBufferUsageFlags              flags
+      nullptr                                           // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
+    };
+
+    vkBeginCommandBuffer( command_buffer, &command_buffer_begin_info );
+
+    VkImageSubresourceRange image_subresource_range = {
+      VK_IMAGE_ASPECT_COLOR_BIT,                        // VkImageAspectFlags                     aspectMask
+      0,                                                // uint32_t                               baseMipLevel
+      1,                                                // uint32_t                               levelCount
+      0,                                                // uint32_t                               baseArrayLayer
+      1                                                 // uint32_t                               layerCount
+    };
+
+    if( GetPresentQueue().Handle != GetGraphicsQueue().Handle ) {
+      VkImageMemoryBarrier barrier_from_present_to_draw = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                        sType
+        nullptr,                                        // const void                            *pNext
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                          srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                          dstAccessMask
+        VK_IMAGE_LAYOUT_UNDEFINED,                      // VkImageLayout                          oldLayout
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,                // VkImageLayout                          newLayout
+        GetPresentQueue().FamilyIndex,                  // uint32_t                               srcQueueFamilyIndex
+        GetGraphicsQueue().FamilyIndex,                 // uint32_t                               dstQueueFamilyIndex
+        image_parameters.Handle,                        // VkImage                                image
+        image_subresource_range                         // VkImageSubresourceRange                subresourceRange
+      };
+      vkCmdPipelineBarrier( command_buffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_draw );
+    }
+
+    VkClearValue clear_value = {
+      { 1.0f, 0.8f, 0.4f, 0.0f },                       // VkClearColorValue                      color
+    };
+
+    VkRenderPassBeginInfo render_pass_begin_info = {
+      VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,         // VkStructureType                        sType
+      nullptr,                                          // const void                            *pNext
+      Vulkan.RenderPass,                                // VkRenderPass                           renderPass
+      framebuffer,                                      // VkFramebuffer                          framebuffer
+      {                                                 // VkRect2D                               renderArea
+        {                                               // VkOffset2D                             offset
+          0,                                              // int32_t                                x
+          0                                               // int32_t                                y
+        },
+        GetSwapChain().Extent,                          // VkExtent2D                             extent;
+      },
+      1,                                                // uint32_t                               clearValueCount
+      &clear_value                                      // const VkClearValue                    *pClearValues
+    };
+
+    vkCmdBeginRenderPass( command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE );
+
+    vkCmdBindPipeline( command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, Vulkan.GraphicsPipeline );
+
+    VkViewport viewport = {
+      0.0f,                                             // float                                  x
+      0.0f,                                             // float                                  y
+      static_cast<float>(GetSwapChain().Extent.width),  // float                                  width
+      static_cast<float>(GetSwapChain().Extent.height), // float                                  height
+      0.0f,                                             // float                                  minDepth
+      1.0f                                              // float                                  maxDepth
+    };
+
+    VkRect2D scissor = {
+      {                                                 // VkOffset2D                             offset
+        0,                                                // int32_t                                x
+        0                                                 // int32_t                                y
+      },
+      {                                                 // VkExtent2D                             extent
+        GetSwapChain().Extent.width,                      // uint32_t                               width
+        GetSwapChain().Extent.height                      // uint32_t                               height
+      }
+    };
+
+    vkCmdSetViewport( command_buffer, 0, 1, &viewport );
+    vkCmdSetScissor( command_buffer, 0, 1, &scissor );
+
+    VkDeviceSize offset = 0;
+    vkCmdBindVertexBuffers( command_buffer, 0, 1, &Vulkan.VertexBuffer.Handle, &offset );
+
+    vkCmdDraw( command_buffer, 4, 1, 0, 0 );
+
+    vkCmdEndRenderPass( command_buffer );
+
+    if( GetGraphicsQueue().Handle != GetPresentQueue().Handle ) {
+      VkImageMemoryBarrier barrier_from_draw_to_present = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                        sType
+        nullptr,                                        // const void                            *pNext
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                          srcAccessMask
+        VK_ACCESS_MEMORY_READ_BIT,                      // VkAccessFlags                          dstAccessMask
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,                // VkImageLayout                          oldLayout
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,                // VkImageLayout                          newLayout
+        GetGraphicsQueue().FamilyIndex,                 // uint32_t                               srcQueueFamilyIndex
+        GetPresentQueue().FamilyIndex,                  // uint32_t                               dstQueueFamilyIndex
+        image_parameters.Handle,                        // VkImage                                image
+        image_subresource_range                         // VkImageSubresourceRange                subresourceRange
+      };
+      vkCmdPipelineBarrier( command_buffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_draw_to_present );
+    }
+
+    if( vkEndCommandBuffer( command_buffer ) != VK_SUCCESS ) {
+      std::cout << "Could not record command buffer!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial05::CreateFramebuffer( VkFramebuffer &framebuffer, VkImageView image_view ) {
+    if( framebuffer != VK_NULL_HANDLE ) {
+      vkDestroyFramebuffer( GetDevice(), framebuffer, nullptr );
+      framebuffer = VK_NULL_HANDLE;
+    }
+
+    VkFramebufferCreateInfo framebuffer_create_info = {
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,        // VkStructureType                sType
+      nullptr,                                          // const void                    *pNext
+      0,                                                // VkFramebufferCreateFlags       flags
+      Vulkan.RenderPass,                                // VkRenderPass                   renderPass
+      1,                                                // uint32_t                       attachmentCount
+      &image_view,                                      // const VkImageView             *pAttachments
+      GetSwapChain().Extent.width,                      // uint32_t                       width
+      GetSwapChain().Extent.height,                     // uint32_t                       height
+      1                                                 // uint32_t                       layers
+    };
+
+    if( vkCreateFramebuffer( GetDevice(), &framebuffer_create_info, nullptr, &framebuffer ) != VK_SUCCESS ) {
+      std::cout << "Could not create a framebuffer!" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial05::ChildOnWindowSizeChanged() {
+    return true;
+  }
+
+  bool Tutorial05::Draw() {
+    static size_t           resource_index = 0;
+    RenderingResourcesData &current_rendering_resource = Vulkan.RenderingResources[resource_index];
+    VkSwapchainKHR          swap_chain = GetSwapChain().Handle;
+    uint32_t                image_index;
+
+    resource_index = (resource_index + 1) % VulkanTutorial05Parameters::ResourcesCount;
+
+    if( vkWaitForFences( GetDevice(), 1, &current_rendering_resource.Fence, VK_FALSE, 1000000000 ) != VK_SUCCESS ) {
+      std::cout << "Waiting for fence takes too long!" << std::endl;
+      return false;
+    }
+    vkResetFences( GetDevice(), 1, &current_rendering_resource.Fence );
+
+    VkResult result = vkAcquireNextImageKHR( GetDevice(), swap_chain, UINT64_MAX, current_rendering_resource.ImageAvailableSemaphore, VK_NULL_HANDLE, &image_index );
+    switch( result ) {
+      case VK_SUCCESS:
+      case VK_SUBOPTIMAL_KHR:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during swap chain image acquisition!" << std::endl;
+        return false;
+    }
+
+    if( !PrepareFrame( current_rendering_resource.CommandBuffer, GetSwapChain().Images[image_index], current_rendering_resource.Framebuffer ) ) {
+      return false;
+    }
+
+    VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+    VkSubmitInfo submit_info = {
+      VK_STRUCTURE_TYPE_SUBMIT_INFO,                          // VkStructureType              sType
+      nullptr,                                                // const void                  *pNext
+      1,                                                      // uint32_t                     waitSemaphoreCount
+      &current_rendering_resource.ImageAvailableSemaphore,    // const VkSemaphore           *pWaitSemaphores
+      &wait_dst_stage_mask,                                   // const VkPipelineStageFlags  *pWaitDstStageMask;
+      1,                                                      // uint32_t                     commandBufferCount
+      &current_rendering_resource.CommandBuffer,              // const VkCommandBuffer       *pCommandBuffers
+      1,                                                      // uint32_t                     signalSemaphoreCount
+      &current_rendering_resource.FinishedRenderingSemaphore  // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_info, current_rendering_resource.Fence ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    VkPresentInfoKHR present_info = {
+      VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,                     // VkStructureType              sType
+      nullptr,                                                // const void                  *pNext
+      1,                                                      // uint32_t                     waitSemaphoreCount
+      &current_rendering_resource.FinishedRenderingSemaphore, // const VkSemaphore           *pWaitSemaphores
+      1,                                                      // uint32_t                     swapchainCount
+      &swap_chain,                                            // const VkSwapchainKHR        *pSwapchains
+      &image_index,                                           // const uint32_t              *pImageIndices
+      nullptr                                                 // VkResult                    *pResults
+    };
+    result = vkQueuePresentKHR( GetPresentQueue().Handle, &present_info );
+
+    switch( result ) {
+      case VK_SUCCESS:
+        break;
+      case VK_ERROR_OUT_OF_DATE_KHR:
+      case VK_SUBOPTIMAL_KHR:
+        return OnWindowSizeChanged();
+      default:
+        std::cout << "Problem occurred during image presentation!" << std::endl;
+        return false;
+    }
+
+    return true;
+  }
+
+  void Tutorial05::ChildClear() {
+  }
+
+  Tutorial05::~Tutorial05() {
+    if( GetDevice() != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( GetDevice() );
+
+      DestroyBuffer( Vulkan.VertexBuffer );
+
+      DestroyBuffer( Vulkan.StagingBuffer );
+
+      if( Vulkan.GraphicsPipeline != VK_NULL_HANDLE ) {
+        vkDestroyPipeline( GetDevice(), Vulkan.GraphicsPipeline, nullptr );
+        Vulkan.GraphicsPipeline = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.RenderPass != VK_NULL_HANDLE ) {
+        vkDestroyRenderPass( GetDevice(), Vulkan.RenderPass, nullptr );
+        Vulkan.RenderPass = VK_NULL_HANDLE;
+      }
+
+      for( size_t i = 0; i < Vulkan.RenderingResources.size(); ++i ) {
+        if( Vulkan.RenderingResources[i].Framebuffer != VK_NULL_HANDLE ) {
+          vkDestroyFramebuffer( GetDevice(), Vulkan.RenderingResources[i].Framebuffer, nullptr );
+        }
+        if( Vulkan.RenderingResources[i].CommandBuffer != VK_NULL_HANDLE ) {
+          vkFreeCommandBuffers( GetDevice(), Vulkan.CommandPool, 1, &Vulkan.RenderingResources[i].CommandBuffer );
+        }
+        if( Vulkan.RenderingResources[i].ImageAvailableSemaphore != VK_NULL_HANDLE ) {
+          vkDestroySemaphore( GetDevice(), Vulkan.RenderingResources[i].ImageAvailableSemaphore, nullptr );
+        }
+        if( Vulkan.RenderingResources[i].FinishedRenderingSemaphore != VK_NULL_HANDLE ) {
+          vkDestroySemaphore( GetDevice(), Vulkan.RenderingResources[i].FinishedRenderingSemaphore, nullptr );
+        }
+        if( Vulkan.RenderingResources[i].Fence != VK_NULL_HANDLE ) {
+          vkDestroyFence( GetDevice(), Vulkan.RenderingResources[i].Fence, nullptr );
+        }
+      }
+
+      if( Vulkan.CommandPool != VK_NULL_HANDLE ) {
+        vkDestroyCommandPool( GetDevice(), Vulkan.CommandPool, nullptr );
+        Vulkan.CommandPool = VK_NULL_HANDLE;
+      }
+    }
+  }
+
+  void Tutorial05::DestroyBuffer( BufferParameters& buffer ) {
+    if( buffer.Handle != VK_NULL_HANDLE ) {
+      vkDestroyBuffer( GetDevice(), buffer.Handle, nullptr );
+      buffer.Handle = VK_NULL_HANDLE;
+    }
+
+    if( buffer.Memory != VK_NULL_HANDLE ) {
+      vkFreeMemory( GetDevice(), buffer.Memory, nullptr );
+      buffer.Memory = VK_NULL_HANDLE;
+    }
+  }
+
+} // namespace ApiWithoutSecrets

Project/Tutorials/05/Tutorial05.h

@@ -0,0 +1,139 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_05_HEADER)
+#define TUTORIAL_05_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // BufferParameters                                             //
+  //                                                              //
+  // Vulkan Buffer's parameters container class                   //
+  // ************************************************************ //
+  struct BufferParameters {
+    VkBuffer                        Handle;
+    VkDeviceMemory                  Memory;
+    uint32_t                        Size;
+
+    BufferParameters() :
+      Handle( VK_NULL_HANDLE ),
+      Memory( VK_NULL_HANDLE ),
+      Size( 0 ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VertexData                                                   //
+  //                                                              //
+  // Struct describing data type and format of vertex attributes  //
+  // ************************************************************ //
+  struct VertexData {
+    float   x, y, z, w;
+    float   r, g, b, a;
+  };
+
+  // ************************************************************ //
+  // RenderingResourcesData                                       //
+  //                                                              //
+  // Struct containing data used during rendering process         //
+  // ************************************************************ //
+  struct RenderingResourcesData {
+    VkFramebuffer                         Framebuffer;
+    VkCommandBuffer                       CommandBuffer;
+    VkSemaphore                           ImageAvailableSemaphore;
+    VkSemaphore                           FinishedRenderingSemaphore;
+    VkFence                               Fence;
+
+    RenderingResourcesData() :
+      Framebuffer( VK_NULL_HANDLE ),
+      CommandBuffer( VK_NULL_HANDLE ),
+      ImageAvailableSemaphore( VK_NULL_HANDLE ),
+      FinishedRenderingSemaphore( VK_NULL_HANDLE ),
+      Fence( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VulkanTutorial04Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial05Parameters {
+    VkRenderPass                          RenderPass;
+    VkPipeline                            GraphicsPipeline;
+    BufferParameters                      VertexBuffer;
+    BufferParameters                      StagingBuffer;
+    VkCommandPool                         CommandPool;
+    std::vector<RenderingResourcesData>   RenderingResources;
+
+    static const size_t                   ResourcesCount = 3;
+
+    VulkanTutorial05Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      GraphicsPipeline( VK_NULL_HANDLE ),
+      VertexBuffer(),
+      StagingBuffer(),
+      CommandPool( VK_NULL_HANDLE ),
+      RenderingResources( ResourcesCount ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial04                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial05 : public VulkanCommon {
+  public:
+    Tutorial05();
+    ~Tutorial05();
+
+    bool    CreateRenderingResources();
+    bool    CreateRenderPass();
+    bool    CreatePipeline();
+    bool    CreateVertexBuffer();
+    bool    CreateStagingBuffer();
+    bool    CopyVertexData();
+
+    bool    Draw() override;
+
+  private:
+    VulkanTutorial05Parameters  Vulkan;
+
+    bool                                                              CreateCommandPool( uint32_t queue_family_index, VkCommandPool *pool );
+    bool                                                              AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers );
+    bool                                                              CreateSemaphore( VkSemaphore *semaphore );
+    bool                                                              CreateFence( VkFenceCreateFlags flags, VkFence *fence );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>     CreateShaderModule( const char* filename );
+    Tools::AutoDeleter<VkPipelineLayout, PFN_vkDestroyPipelineLayout> CreatePipelineLayout();
+    bool                                                              CreateBuffer( VkBufferUsageFlags usage, VkMemoryPropertyFlagBits memoryProperty, BufferParameters &buffer );
+    bool                                                              AllocateBufferMemory( VkBuffer buffer, VkMemoryPropertyFlagBits property, VkDeviceMemory *memory );
+    const std::vector<float>&                                         GetVertexData() const;
+    bool                                                              PrepareFrame( VkCommandBuffer command_buffer, const ImageParameters &image_parameters, VkFramebuffer &framebuffer );
+    bool                                                              CreateFramebuffer( VkFramebuffer &framebuffer, VkImageView image_view );
+    void                                                              DestroyBuffer( BufferParameters& buffer );
+
+    void                                                              ChildClear() override;
+    bool                                                              ChildOnWindowSizeChanged() override;
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_05_HEADER

Project/Tutorials/05/main.cpp

@@ -0,0 +1,59 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial05.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial05 tutorial05;
+
+  // Window creation
+  if( !window.Create( "05 - Staging Resources" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial05.PrepareVulkan( window.GetParameters() ) ) {
+    return -1;
+  }
+
+  // Tutorial 05
+  if( !tutorial05.CreateRenderingResources() ) {
+    return -1;
+  }
+  if( !tutorial05.CreateRenderPass() ) {
+    return -1;
+  }
+  if( !tutorial05.CreatePipeline() ) {
+    return -1;
+  }
+  if( !tutorial05.CreateVertexBuffer() ) {
+    return -1;
+  }
+  if( !tutorial05.CreateStagingBuffer() ) {
+    return -1;
+  }
+  if( !tutorial05.CopyVertexData() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial05 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorials/06/Data/frag.spv.txt

@@ -0,0 +1,46 @@
+Tutorial06/Data06/shader.frag
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked fragment stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 20
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 9 17
+                              ExecutionMode 4 OriginLowerLeft
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 9  "o_Color"
+                              Name 13  "u_Texture"
+                              Name 17  "v_Texcoord"
+                              Decorate 9(o_Color) Location 0
+                              Decorate 13(u_Texture) DescriptorSet 0
+                              Decorate 13(u_Texture) Binding 0
+                              Decorate 17(v_Texcoord) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Output 7(fvec4)
+      9(o_Color):      8(ptr) Variable Output
+              10:             TypeImage 6(float) 2D sampled format:Unknown
+              11:             TypeSampledImage 10
+              12:             TypePointer UniformConstant 11
+   13(u_Texture):     12(ptr) Variable UniformConstant
+              15:             TypeVector 6(float) 2
+              16:             TypePointer Input 15(fvec2)
+  17(v_Texcoord):     16(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              14:          11 Load 13(u_Texture)
+              18:   15(fvec2) Load 17(v_Texcoord)
+              19:    7(fvec4) ImageSampleImplicitLod 14 18
+                              Store 9(o_Color) 19
+                              Return
+                              FunctionEnd

Project/Tutorials/06/Data/shader.frag

@@ -0,0 +1,21 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(set=0, binding=0) uniform sampler2D u_Texture;
+
+layout(location = 0) in vec2 v_Texcoord;
+
+layout(location = 0) out vec4 o_Color;
+
+void main() {
+  o_Color = texture( u_Texture, v_Texcoord );
+}

Project/Tutorials/06/Data/shader.vert

@@ -0,0 +1,26 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(location = 0) in vec4 i_Position;
+layout(location = 1) in vec2 i_Texcoord;
+
+out gl_PerVertex
+{
+  vec4 gl_Position;
+};
+
+layout(location = 0) out vec2 v_Texcoord;
+
+void main() {
+    gl_Position = i_Position;
+    v_Texcoord = i_Texcoord;
+}

Project/Tutorials/06/Data/vert.spv.txt

@@ -0,0 +1,54 @@
+Tutorial06/Data06/shader.vert
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked vertex stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 24
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 10 14 20 22
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 8  "gl_PerVertex"
+                              MemberName 8(gl_PerVertex) 0  "gl_Position"
+                              Name 10  ""
+                              Name 14  "i_Position"
+                              Name 20  "v_Texcoord"
+                              Name 22  "i_Texcoord"
+                              MemberDecorate 8(gl_PerVertex) 0 BuiltIn Position
+                              Decorate 8(gl_PerVertex) Block
+                              Decorate 14(i_Position) Location 0
+                              Decorate 20(v_Texcoord) Location 0
+                              Decorate 22(i_Texcoord) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+ 8(gl_PerVertex):             TypeStruct 7(fvec4)
+               9:             TypePointer Output 8(gl_PerVertex)
+              10:      9(ptr) Variable Output
+              11:             TypeInt 32 1
+              12:     11(int) Constant 0
+              13:             TypePointer Input 7(fvec4)
+  14(i_Position):     13(ptr) Variable Input
+              16:             TypePointer Output 7(fvec4)
+              18:             TypeVector 6(float) 2
+              19:             TypePointer Output 18(fvec2)
+  20(v_Texcoord):     19(ptr) Variable Output
+              21:             TypePointer Input 18(fvec2)
+  22(i_Texcoord):     21(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              15:    7(fvec4) Load 14(i_Position)
+              17:     16(ptr) AccessChain 10 12
+                              Store 17 15
+              23:   18(fvec2) Load 22(i_Texcoord)
+                              Store 20(v_Texcoord) 23
+                              Return
+                              FunctionEnd

Project/Tutorials/06/Tutorial06.h

@@ -0,0 +1,173 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_06_HEADER)
+#define TUTORIAL_06_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // BufferParameters                                             //
+  //                                                              //
+  // Vulkan Buffer's parameters container class                   //
+  // ************************************************************ //
+  struct BufferParameters {
+    VkBuffer                        Handle;
+    VkDeviceMemory                  Memory;
+    uint32_t                        Size;
+
+    BufferParameters() :
+      Handle( VK_NULL_HANDLE ),
+      Memory( VK_NULL_HANDLE ),
+      Size( 0 ) {
+    }
+  };
+
+  // ************************************************************ //
+  // DescriptorParameters                                         //
+  //                                                              //
+  // Container class for descriptor related resources             //
+  // ************************************************************ //
+  struct DescriptorSetParameters {
+    VkDescriptorPool                Pool;
+    VkDescriptorSetLayout           Layout;
+    VkDescriptorSet                 Handle;
+
+    DescriptorSetParameters() :
+      Pool( VK_NULL_HANDLE ),
+      Layout( VK_NULL_HANDLE ),
+      Handle( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VertexData                                                   //
+  //                                                              //
+  // Struct describing data type and format of vertex attributes  //
+  // ************************************************************ //
+  struct VertexData {
+    float   x, y, z, w;
+    float   u, v;
+  };
+
+  // ************************************************************ //
+  // RenderingResourcesData                                       //
+  //                                                              //
+  // Struct containing data used during rendering process         //
+  // ************************************************************ //
+  struct RenderingResourcesData {
+    VkFramebuffer                         Framebuffer;
+    VkCommandBuffer                       CommandBuffer;
+    VkSemaphore                           ImageAvailableSemaphore;
+    VkSemaphore                           FinishedRenderingSemaphore;
+    VkFence                               Fence;
+
+    RenderingResourcesData() :
+      Framebuffer( VK_NULL_HANDLE ),
+      CommandBuffer( VK_NULL_HANDLE ),
+      ImageAvailableSemaphore( VK_NULL_HANDLE ),
+      FinishedRenderingSemaphore( VK_NULL_HANDLE ),
+      Fence( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VulkanTutorial04Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial06Parameters {
+    VkRenderPass                          RenderPass;
+    ImageParameters                       Image;
+    DescriptorSetParameters               DescriptorSet;
+    VkPipelineLayout                      PipelineLayout;
+    VkPipeline                            GraphicsPipeline;
+    BufferParameters                      VertexBuffer;
+    BufferParameters                      StagingBuffer;
+    VkCommandPool                         CommandPool;
+    std::vector<RenderingResourcesData>   RenderingResources;
+
+    static const size_t                   ResourcesCount = 3;
+
+    VulkanTutorial06Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      Image(),
+      DescriptorSet(),
+      PipelineLayout(),
+      GraphicsPipeline( VK_NULL_HANDLE ),
+      VertexBuffer(),
+      StagingBuffer(),
+      CommandPool( VK_NULL_HANDLE ),
+      RenderingResources( ResourcesCount ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial04                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial06 : public VulkanCommon {
+  public:
+    Tutorial06();
+    ~Tutorial06();
+
+    bool    CreateRenderingResources();
+    bool    CreateStagingBuffer();
+    bool    CreateTexture();
+    bool    CreateDescriptorSetLayout();
+    bool    CreateDescriptorPool();
+    bool    AllocateDescriptorSet();
+    bool    UpdateDescriptorSet();
+    bool    CreateRenderPass();
+    bool    CreatePipelineLayout();
+    bool    CreatePipeline();
+    bool    CreateVertexBuffer();
+
+    bool    Draw() override;
+
+  private:
+    VulkanTutorial06Parameters  Vulkan;
+
+    bool                                                              CreateCommandBuffers();
+    bool                                                              CreateCommandPool(uint32_t queue_family_index, VkCommandPool *pool);
+    bool                                                              AllocateCommandBuffers(VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers);
+    bool                                                              CreateSemaphores();
+    bool                                                              CreateFences();
+    bool                                                              CreateBuffer(VkBufferUsageFlags usage, VkMemoryPropertyFlagBits memoryProperty, BufferParameters &buffer);
+    bool                                                              AllocateBufferMemory(VkBuffer buffer, VkMemoryPropertyFlagBits property, VkDeviceMemory *memory);
+    bool                                                              CreateImage( uint32_t width, uint32_t height, VkImage *image );
+    bool                                                              AllocateImageMemory( VkImage image, VkMemoryPropertyFlagBits property, VkDeviceMemory *memory );
+    bool                                                              CreateImageView( ImageParameters &image_parameters );
+    bool                                                              CreateSampler( VkSampler *sampler );
+    bool                                                              CopyTextureData( char *texture_data, uint32_t data_size, uint32_t width, uint32_t height );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>     CreateShaderModule( const char* filename );
+    const std::vector<float>&                                         GetVertexData() const;
+    bool                                                              CopyVertexData();
+    bool                                                              PrepareFrame( VkCommandBuffer command_buffer, const ImageParameters &image_parameters, VkFramebuffer &framebuffer );
+    bool                                                              CreateFramebuffer( VkFramebuffer &framebuffer, VkImageView image_view );
+    void                                                              DestroyBuffer( BufferParameters& buffer );
+
+    bool                                                              ChildOnWindowSizeChanged() override;
+    void                                                              ChildClear() override;
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_06_HEADER

Project/Tutorials/06/main.cpp

@@ -0,0 +1,74 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial06.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial06 tutorial06;
+
+  // Window creation
+  if( !window.Create( "06 - Descriptor Sets" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial06.PrepareVulkan( window.GetParameters() ) ) {
+    return -1;
+  }
+
+  // Tutorial 06
+  if( !tutorial06.CreateRenderingResources() ) {
+    return -1;
+  }
+  if( !tutorial06.CreateStagingBuffer() ) {
+    return -1;
+  }
+  if( !tutorial06.CreateTexture() ) {
+    return -1;
+  }
+  if( !tutorial06.CreateDescriptorSetLayout() ) {
+    return -1;
+  }
+  if( !tutorial06.CreateDescriptorPool() ) {
+    return -1;
+  }
+  if( !tutorial06.AllocateDescriptorSet() ) {
+    return -1;
+  }
+  if( !tutorial06.UpdateDescriptorSet() ) {
+    return -1;
+  }
+  if( !tutorial06.CreateRenderPass() ) {
+    return -1;
+  }
+  if( !tutorial06.CreatePipelineLayout() ) {
+    return -1;
+  }
+  if( !tutorial06.CreatePipeline() ) {
+    return -1;
+  }
+  if( !tutorial06.CreateVertexBuffer() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial06 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorials/07/Data/frag.spv.txt

@@ -0,0 +1,46 @@
+Tutorial07/Data07/shader.frag
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked fragment stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 20
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 9 17
+                              ExecutionMode 4 OriginLowerLeft
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 9  "o_Color"
+                              Name 13  "u_Texture"
+                              Name 17  "v_Texcoord"
+                              Decorate 9(o_Color) Location 0
+                              Decorate 13(u_Texture) DescriptorSet 0
+                              Decorate 13(u_Texture) Binding 0
+                              Decorate 17(v_Texcoord) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypePointer Output 7(fvec4)
+      9(o_Color):      8(ptr) Variable Output
+              10:             TypeImage 6(float) 2D sampled format:Unknown
+              11:             TypeSampledImage 10
+              12:             TypePointer UniformConstant 11
+   13(u_Texture):     12(ptr) Variable UniformConstant
+              15:             TypeVector 6(float) 2
+              16:             TypePointer Input 15(fvec2)
+  17(v_Texcoord):     16(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              14:          11 Load 13(u_Texture)
+              18:   15(fvec2) Load 17(v_Texcoord)
+              19:    7(fvec4) ImageSampleImplicitLod 14 18
+                              Store 9(o_Color) 19
+                              Return
+                              FunctionEnd

Project/Tutorials/07/Data/shader.frag

@@ -0,0 +1,21 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(set=0, binding=0) uniform sampler2D u_Texture;
+
+layout(location = 0) in vec2 v_Texcoord;
+
+layout(location = 0) out vec4 o_Color;
+
+void main() {
+  o_Color = texture( u_Texture, v_Texcoord );
+}

Project/Tutorials/07/Data/shader.vert

@@ -0,0 +1,30 @@
+// Copyright 2016 Intel Corporation All Rights Reserved
+// 
+// Intel makes no representations about the suitability of this software for any purpose.
+// THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+// EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+// FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+// RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+// Intel does not assume any responsibility for any errors which may appear in this software
+// nor any responsibility to update it.
+
+#version 450
+
+layout(set=0, binding=1) uniform u_UniformBuffer {
+    mat4 u_ProjectionMatrix;
+};
+
+layout(location = 0) in vec4 i_Position;
+layout(location = 1) in vec2 i_Texcoord;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+layout(location = 0) out vec2 v_Texcoord;
+
+void main() {
+    gl_Position = u_ProjectionMatrix * i_Position;
+    v_Texcoord = i_Texcoord;
+}

Project/Tutorials/07/Data/vert.spv.txt

@@ -0,0 +1,71 @@
+Tutorial07/Data07/shader.vert
+Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+
+
+Linked vertex stage:
+
+
+// Module Version 10000
+// Generated by (magic number): 80001
+// Id's are bound by 32
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 10 21 28 30
+                              Source GLSL 450
+                              Name 4  "main"
+                              Name 8  "gl_PerVertex"
+                              MemberName 8(gl_PerVertex) 0  "gl_Position"
+                              Name 10  ""
+                              Name 14  "u_UniformBuffer"
+                              MemberName 14(u_UniformBuffer) 0  "u_ProjectionMatrix"
+                              Name 16  ""
+                              Name 21  "i_Position"
+                              Name 28  "v_Texcoord"
+                              Name 30  "i_Texcoord"
+                              MemberDecorate 8(gl_PerVertex) 0 BuiltIn Position
+                              Decorate 8(gl_PerVertex) Block
+                              MemberDecorate 14(u_UniformBuffer) 0 ColMajor
+                              MemberDecorate 14(u_UniformBuffer) 0 Offset 0
+                              MemberDecorate 14(u_UniformBuffer) 0 MatrixStride 16
+                              Decorate 14(u_UniformBuffer) Block
+                              Decorate 16 DescriptorSet 0
+                              Decorate 16 Binding 1
+                              Decorate 21(i_Position) Location 0
+                              Decorate 28(v_Texcoord) Location 0
+                              Decorate 30(i_Texcoord) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+ 8(gl_PerVertex):             TypeStruct 7(fvec4)
+               9:             TypePointer Output 8(gl_PerVertex)
+              10:      9(ptr) Variable Output
+              11:             TypeInt 32 1
+              12:     11(int) Constant 0
+              13:             TypeMatrix 7(fvec4) 4
+14(u_UniformBuffer):             TypeStruct 13
+              15:             TypePointer Uniform 14(u_UniformBuffer)
+              16:     15(ptr) Variable Uniform
+              17:             TypePointer Uniform 13
+              20:             TypePointer Input 7(fvec4)
+  21(i_Position):     20(ptr) Variable Input
+              24:             TypePointer Output 7(fvec4)
+              26:             TypeVector 6(float) 2
+              27:             TypePointer Output 26(fvec2)
+  28(v_Texcoord):     27(ptr) Variable Output
+              29:             TypePointer Input 26(fvec2)
+  30(i_Texcoord):     29(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              18:     17(ptr) AccessChain 16 12
+              19:          13 Load 18
+              22:    7(fvec4) Load 21(i_Position)
+              23:    7(fvec4) MatrixTimesVector 19 22
+              25:     24(ptr) AccessChain 10 12
+                              Store 25 23
+              31:   26(fvec2) Load 30(i_Texcoord)
+                              Store 28(v_Texcoord) 31
+                              Return
+                              FunctionEnd

Project/Tutorials/07/Tutorial07.h

@@ -0,0 +1,177 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(TUTORIAL_07_HEADER)
+#define TUTORIAL_07_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace ApiWithoutSecrets {
+
+  // ************************************************************ //
+  // BufferParameters                                             //
+  //                                                              //
+  // Vulkan Buffer's parameters container class                   //
+  // ************************************************************ //
+  struct BufferParameters {
+    VkBuffer                        Handle;
+    VkDeviceMemory                  Memory;
+    uint32_t                        Size;
+
+    BufferParameters() :
+      Handle( VK_NULL_HANDLE ),
+      Memory( VK_NULL_HANDLE ),
+      Size( 0 ) {
+    }
+  };
+
+  // ************************************************************ //
+  // DescriptorParameters                                         //
+  //                                                              //
+  // Container class for descriptor related resources             //
+  // ************************************************************ //
+  struct DescriptorSetParameters {
+    VkDescriptorPool                Pool;
+    VkDescriptorSetLayout           Layout;
+    VkDescriptorSet                 Handle;
+
+    DescriptorSetParameters() :
+      Pool( VK_NULL_HANDLE ),
+      Layout( VK_NULL_HANDLE ),
+      Handle( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VertexData                                                   //
+  //                                                              //
+  // Struct describing data type and format of vertex attributes  //
+  // ************************************************************ //
+  struct VertexData {
+    float   x, y, z, w;
+    float   u, v;
+  };
+
+  // ************************************************************ //
+  // RenderingResourcesData                                       //
+  //                                                              //
+  // Struct containing data used during rendering process         //
+  // ************************************************************ //
+  struct RenderingResourcesData {
+    VkFramebuffer                         Framebuffer;
+    VkCommandBuffer                       CommandBuffer;
+    VkSemaphore                           ImageAvailableSemaphore;
+    VkSemaphore                           FinishedRenderingSemaphore;
+    VkFence                               Fence;
+
+    RenderingResourcesData() :
+      Framebuffer( VK_NULL_HANDLE ),
+      CommandBuffer( VK_NULL_HANDLE ),
+      ImageAvailableSemaphore( VK_NULL_HANDLE ),
+      FinishedRenderingSemaphore( VK_NULL_HANDLE ),
+      Fence( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // VulkanTutorial04Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial07Parameters {
+    VkRenderPass                          RenderPass;
+    ImageParameters                       Image;
+    BufferParameters                      UniformBuffer;
+    DescriptorSetParameters               DescriptorSet;
+    VkPipelineLayout                      PipelineLayout;
+    VkPipeline                            GraphicsPipeline;
+    BufferParameters                      VertexBuffer;
+    BufferParameters                      StagingBuffer;
+    VkCommandPool                         CommandPool;
+    std::vector<RenderingResourcesData>   RenderingResources;
+
+    static const size_t                   ResourcesCount = 3;
+
+    VulkanTutorial07Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      Image(),
+      DescriptorSet(),
+      PipelineLayout(),
+      GraphicsPipeline( VK_NULL_HANDLE ),
+      VertexBuffer(),
+      StagingBuffer(),
+      CommandPool( VK_NULL_HANDLE ),
+      RenderingResources( ResourcesCount ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial04                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial07 : public VulkanCommon {
+  public:
+    Tutorial07();
+    ~Tutorial07();
+
+    bool    CreateRenderingResources();
+    bool    CreateStagingBuffer();
+    bool    CreateTexture();
+    bool    CreateUniformBuffer();
+    bool    CreateDescriptorSetLayout();
+    bool    CreateDescriptorPool();
+    bool    AllocateDescriptorSet();
+    bool    UpdateDescriptorSet();
+    bool    CreateRenderPass();
+    bool    CreatePipelineLayout();
+    bool    CreatePipeline();
+    bool    CreateVertexBuffer();
+
+    bool    Draw() override;
+
+  private:
+    VulkanTutorial07Parameters  Vulkan;
+
+    bool                                                              CreateCommandBuffers();
+    bool                                                              CreateCommandPool(uint32_t queue_family_index, VkCommandPool *pool);
+    bool                                                              AllocateCommandBuffers(VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers);
+    bool                                                              CreateSemaphores();
+    bool                                                              CreateFences();
+    bool                                                              CreateBuffer(VkBufferUsageFlags usage, VkMemoryPropertyFlagBits memoryProperty, BufferParameters &buffer);
+    bool                                                              AllocateBufferMemory(VkBuffer buffer, VkMemoryPropertyFlagBits property, VkDeviceMemory *memory);
+    bool                                                              CreateImage( uint32_t width, uint32_t height, VkImage *image );
+    bool                                                              AllocateImageMemory( VkImage image, VkMemoryPropertyFlagBits property, VkDeviceMemory *memory );
+    bool                                                              CreateImageView( ImageParameters &image_parameters );
+    bool                                                              CreateSampler( VkSampler *sampler );
+    bool                                                              CopyTextureData( char *texture_data, uint32_t data_size, uint32_t width, uint32_t height );
+    const std::array<float, 16>                                       GetUniformBufferData() const;
+    bool                                                              CopyUniformBufferData();
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule>     CreateShaderModule( const char* filename );
+    const std::vector<float>&                                         GetVertexData() const;
+    bool                                                              CopyVertexData();
+    bool                                                              PrepareFrame( VkCommandBuffer command_buffer, const ImageParameters &image_parameters, VkFramebuffer &framebuffer );
+    bool                                                              CreateFramebuffer( VkFramebuffer &framebuffer, VkImageView image_view );
+    void                                                              DestroyBuffer( BufferParameters& buffer );
+
+    bool                                                              ChildOnWindowSizeChanged() override;
+    void                                                              ChildClear() override;
+  };
+
+} // namespace ApiWithoutSecrets
+
+#endif // TUTORIAL_07_HEADER

Project/Tutorials/07/main.cpp

@@ -0,0 +1,77 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations
+// under the License.
+////////////////////////////////////////////////////////////////////////////////
+
+#include "Tutorial07.h"
+
+int main( int argc, char **argv ) {
+  ApiWithoutSecrets::OS::Window window;
+  ApiWithoutSecrets::Tutorial07 tutorial07;
+
+  // Window creation
+  if( !window.Create( "07 - Uniform Buffers" ) ) {
+    return -1;
+  }
+
+  // Vulkan preparations and initialization
+  if( !tutorial07.PrepareVulkan( window.GetParameters() ) ) {
+    return -1;
+  }
+
+  // Tutorial 06
+  if( !tutorial07.CreateRenderingResources() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateStagingBuffer() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateTexture() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateUniformBuffer() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateDescriptorSetLayout() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateDescriptorPool() ) {
+    return -1;
+  }
+  if( !tutorial07.AllocateDescriptorSet() ) {
+    return -1;
+  }
+  if( !tutorial07.UpdateDescriptorSet() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateRenderPass() ) {
+    return -1;
+  }
+  if( !tutorial07.CreatePipelineLayout() ) {
+    return -1;
+  }
+  if( !tutorial07.CreatePipeline() ) {
+    return -1;
+  }
+  if( !tutorial07.CreateVertexBuffer() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial07 ) ) {
+    return -1;
+  }
+
+  return 0;
+}