Added license.txt file.

Added Project folder with source code examples Part 1, Part 2, Part 3 and Part 4.

Project/CMakeLists.txt

@@ -0,0 +1,125 @@
+# 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.
+
+cmake_minimum_required (VERSION 3.0)
+project( "IntroductionToVulkan" )
+
+if( CMAKE_BUILD_TYPE STREQUAL "" )
+	set( CMAKE_BUILD_TYPE "debug" )
+endif()
+
+if( NOT USE_PLATFORM MATCHES "VK_USE_PLATFORM_.*" )
+	if( WIN32 )
+		set( USE_PLATFORM "VK_USE_PLATFORM_WIN32_KHR" )
+	elseif( UNIX )
+		set( USE_PLATFORM "VK_USE_PLATFORM_XCB_KHR" )
+	endif()
+endif()
+
+if( USE_PLATFORM STREQUAL "VK_USE_PLATFORM_WIN32_KHR" )
+	set( CMAKE_C_FLAGS_RELWITHDEBINFO    "${CMAKE_C_FLAGS_RELWITHDEBINFO} /MT" )
+	set( CMAKE_C_FLAGS_RELEASE           "${CMAKE_C_FLAGS_RELEASE} /MT" )
+	set( CMAKE_C_FLAGS_DEBUG             "${CMAKE_C_FLAGS_DEBUG} /MTd" )
+	set( CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /MT" )
+	set( CMAKE_CXX_FLAGS_RELEASE         "${CMAKE_CXX_FLAGS_RELEASE} /MT" )
+	set( CMAKE_CXX_FLAGS_DEBUG           "${CMAKE_CXX_FLAGS_DEBUG} /MTd" )
+	set( PLATFORM_LIBRARY                "" )
+elseif( USE_PLATFORM STREQUAL "VK_USE_PLATFORM_XCB_KHR" )
+	add_definitions( -std=c++11 )
+	set( PLATFORM_LIBRARY dl xcb )
+elseif( USE_PLATFORM STREQUAL "VK_USE_PLATFORM_XLIB_KHR" )
+	add_definitions( -std=c++11 )
+	set( PLATFORM_LIBRARY dl X11 )
+endif()
+
+if( CMAKE_BUILD_TYPE STREQUAL "debug" )
+	add_definitions(-D_DEBUG)
+endif()
+
+macro( add_executable _name )
+	_add_executable( ${ARGV} )
+	target_compile_definitions( ${_name} PRIVATE USE_SWAPCHAIN_EXTENSIONS )
+	target_link_libraries( ${_name} ${PLATFORM_LIBRARY} )
+endmacro()
+
+add_definitions( -DVK_NO_PROTOTYPES )
+add_definitions( -D${USE_PLATFORM} )
+include_directories( Include )
+include_directories( Common )
+
+set( BASIC_SHARED_HEADER_FILES
+		"Common/OperatingSystem.h"
+		"Common/ListOfFunctions.inl"
+		"Common/VulkanFunctions.h" )
+
+set( BASIC_SHARED_SOURCE_FILES
+		"Common/OperatingSystem.cpp"
+		"Common/VulkanFunctions.cpp" )
+
+set( VULKAN_HEADER_FILES
+		"Include/vk_platform.h"
+		"Include/vulkan.h" )
+
+set( ALL_BASIC_SHARED_FILES
+		${BASIC_SHARED_HEADER_FILES}
+		${BASIC_SHARED_SOURCE_FILES}
+		${VULKAN_HEADER_FILES} )
+
+set( ADVANCED_SHARED_HEADER_FILES
+		"Common/Tools.h"
+		"Common/VulkanCommon.h" )
+
+set( ADVANCED_SHARED_SOURCE_FILES
+		"Common/Tools.cpp"
+		"Common/VulkanCommon.cpp" )
+
+set( ALL_BASIC_AND_ADVANCED_SHARED_FILES
+		${ALL_BASIC_SHARED_FILES}
+		${ADVANCED_SHARED_HEADER_FILES}
+		${ADVANCED_SHARED_SOURCE_FILES} )
+
+set( TUTORIAL_HEADER_FILES REGULAR_EXPRESSION
+		"Tutorial.*h" )
+
+set( TUTORIAL_SOURCE_FILES REGULAR_EXPRESSION
+		"Tutorial.*cpp" )
+
+source_group( "Header Files\\Common" FILES ${BASIC_SHARED_HEADER_FILES} )
+source_group( "Source Files\\Common" FILES ${BASIC_SHARED_SOURCE_FILES} )
+source_group( "Header Files\\Include" FILES ${VULKAN_HEADER_FILES} )
+source_group( "Header Files\\Common" FILES ${ADVANCED_SHARED_HEADER_FILES} )
+source_group( "Source Files\\Common" FILES ${ADVANCED_SHARED_SOURCE_FILES} )
+source_group( "Header Files" FILES ${TUTORIAL_HEADER_FILES} )
+source_group( "Source Files" FILES ${TUTORIAL_SOURCE_FILES} )
+
+_add_executable( "01-The_Beginning"
+	${ALL_BASIC_SHARED_FILES}
+	Tutorial01/Tutorial01.h
+	Tutorial01/main.cpp
+	Tutorial01/Tutorial01.cpp )
+	target_link_libraries( "01-The_Beginning" ${PLATFORM_LIBRARY} )
+
+add_executable( "02-Swapchain"
+	${ALL_BASIC_SHARED_FILES}
+	Tutorial02/Tutorial02.h
+	Tutorial02/main.cpp
+	Tutorial02/Tutorial02.cpp )
+
+add_executable( "03-First_Triangle"
+	${ALL_BASIC_AND_ADVANCED_SHARED_FILES}
+	Tutorial03/Tutorial03.h
+	Tutorial03/main.cpp
+	Tutorial03/Tutorial03.cpp )
+
+add_executable( "04-Vertex_Attributes"
+	${ALL_BASIC_AND_ADVANCED_SHARED_FILES}
+	Tutorial04/Tutorial04.h
+	Tutorial04/main.cpp
+	Tutorial04/Tutorial04.cpp )

Project/Common/ListOfFunctions.inl

@@ -0,0 +1,150 @@
+// 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.
+
+// ************************************************************ //
+// Exported functions                                           //
+//                                                              //
+// These functions are always exposed by vulkan libraries.      //
+// ************************************************************ //
+
+#if !defined(VK_EXPORTED_FUNCTION)
+#define VK_EXPORTED_FUNCTION( fun )
+#endif
+
+VK_EXPORTED_FUNCTION( vkGetInstanceProcAddr )
+
+#undef VK_EXPORTED_FUNCTION
+
+
+// ************************************************************ //
+// Global level functions                                       //
+//                                                              //
+// They allow checking what instance extensions are available   //
+// and allow creation of a Vulkan Instance.                     //
+// ************************************************************ //
+
+#if !defined(VK_GLOBAL_LEVEL_FUNCTION)
+#define VK_GLOBAL_LEVEL_FUNCTION( fun )
+#endif
+
+VK_GLOBAL_LEVEL_FUNCTION( vkCreateInstance )
+VK_GLOBAL_LEVEL_FUNCTION( vkEnumerateInstanceExtensionProperties )
+VK_GLOBAL_LEVEL_FUNCTION( vkEnumerateInstanceLayerProperties )
+
+#undef VK_GLOBAL_LEVEL_FUNCTION
+
+
+// ************************************************************ //
+// Instance level functions                                     //
+//                                                              //
+// These functions allow for device queries and creation.       //
+// They help choose which device is well suited for our needs.  //
+// ************************************************************ //
+
+#if !defined(VK_INSTANCE_LEVEL_FUNCTION)
+#define VK_INSTANCE_LEVEL_FUNCTION( fun )
+#endif
+
+VK_INSTANCE_LEVEL_FUNCTION( vkDestroyInstance )
+VK_INSTANCE_LEVEL_FUNCTION( vkEnumeratePhysicalDevices )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceProperties )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceFeatures )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceQueueFamilyProperties )
+VK_INSTANCE_LEVEL_FUNCTION( vkCreateDevice )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetDeviceProcAddr )
+VK_INSTANCE_LEVEL_FUNCTION( vkEnumerateDeviceExtensionProperties )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceMemoryProperties )
+// From extensions
+#if defined(USE_SWAPCHAIN_EXTENSIONS)
+VK_INSTANCE_LEVEL_FUNCTION( vkDestroySurfaceKHR )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceSurfaceSupportKHR )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceSurfaceCapabilitiesKHR )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceSurfaceFormatsKHR )
+VK_INSTANCE_LEVEL_FUNCTION( vkGetPhysicalDeviceSurfacePresentModesKHR )
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+VK_INSTANCE_LEVEL_FUNCTION( vkCreateWin32SurfaceKHR )
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+VK_INSTANCE_LEVEL_FUNCTION( vkCreateXcbSurfaceKHR )
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+VK_INSTANCE_LEVEL_FUNCTION( vkCreateXlibSurfaceKHR )
+#endif
+#endif
+
+#undef VK_INSTANCE_LEVEL_FUNCTION
+
+
+// ************************************************************ //
+// Device level functions                                       //
+//                                                              //
+// These functions are used mainly for drawing                  //
+// ************************************************************ //
+
+#if !defined(VK_DEVICE_LEVEL_FUNCTION)
+#define VK_DEVICE_LEVEL_FUNCTION( fun )
+#endif
+
+VK_DEVICE_LEVEL_FUNCTION( vkGetDeviceQueue )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyDevice )
+VK_DEVICE_LEVEL_FUNCTION( vkDeviceWaitIdle )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateCommandPool )
+VK_DEVICE_LEVEL_FUNCTION( vkAllocateCommandBuffers )
+VK_DEVICE_LEVEL_FUNCTION( vkBeginCommandBuffer )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdPipelineBarrier )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdClearColorImage )
+VK_DEVICE_LEVEL_FUNCTION( vkEndCommandBuffer )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateSemaphore )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroySemaphore )
+VK_DEVICE_LEVEL_FUNCTION( vkQueueSubmit )
+VK_DEVICE_LEVEL_FUNCTION( vkFreeCommandBuffers )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyCommandPool )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateRenderPass )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyRenderPass )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateImageView )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyImageView )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateFramebuffer )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyFramebuffer )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateShaderModule )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyShaderModule )
+VK_DEVICE_LEVEL_FUNCTION( vkCreatePipelineLayout )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyPipelineLayout )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateGraphicsPipelines )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyPipeline )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdBeginRenderPass )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdEndRenderPass )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdBindPipeline )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdDraw )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateImage )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdCopyImage )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyImage )
+VK_DEVICE_LEVEL_FUNCTION( vkGetImageMemoryRequirements )
+VK_DEVICE_LEVEL_FUNCTION( vkAllocateMemory )
+VK_DEVICE_LEVEL_FUNCTION( vkBindImageMemory )
+VK_DEVICE_LEVEL_FUNCTION( vkFreeMemory )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateBuffer )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyBuffer )
+VK_DEVICE_LEVEL_FUNCTION( vkGetBufferMemoryRequirements )
+VK_DEVICE_LEVEL_FUNCTION( vkBindBufferMemory )
+VK_DEVICE_LEVEL_FUNCTION( vkMapMemory )
+VK_DEVICE_LEVEL_FUNCTION( vkUnmapMemory )
+VK_DEVICE_LEVEL_FUNCTION( vkCmdBindVertexBuffers )
+VK_DEVICE_LEVEL_FUNCTION( vkCreateFence )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroyFence )
+VK_DEVICE_LEVEL_FUNCTION( vkResetFences )
+VK_DEVICE_LEVEL_FUNCTION( vkWaitForFences )
+// From extensions
+#if defined(USE_SWAPCHAIN_EXTENSIONS)
+VK_DEVICE_LEVEL_FUNCTION( vkCreateSwapchainKHR )
+VK_DEVICE_LEVEL_FUNCTION( vkDestroySwapchainKHR )
+VK_DEVICE_LEVEL_FUNCTION( vkGetSwapchainImagesKHR )
+VK_DEVICE_LEVEL_FUNCTION( vkAcquireNextImageKHR )
+VK_DEVICE_LEVEL_FUNCTION( vkQueuePresentKHR )
+#endif
+
+#undef VK_DEVICE_LEVEL_FUNCTION

Project/Common/OperatingSystem.cpp

@@ -0,0 +1,349 @@
+// 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.
+
+#include "OperatingSystem.h"
+
+namespace OS {
+
+  Window::Window() :
+    Parameters() {
+  }
+
+  WindowParameters Window::GetParameters() const {
+    return Parameters;
+  }
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+
+#define TUTORIAL_NAME "API without Secrets: Introduction to Vulkan"
+
+  LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) {
+    switch( message ) {
+      case WM_SIZE:
+      case WM_EXITSIZEMOVE:
+        PostMessage( hWnd, WM_USER + 1, wParam, lParam );
+        break;
+      case WM_KEYDOWN:
+      case WM_CLOSE:
+        PostMessage( hWnd, WM_USER + 2, wParam, lParam );
+        break;
+      default:
+        return DefWindowProc( hWnd, message, wParam, lParam );
+    }
+    return 0;
+  }
+
+  Window::~Window() {
+    if( Parameters.Handle ) {
+      DestroyWindow( Parameters.Handle );
+    }
+
+    if( Parameters.Instance ) {
+      UnregisterClass( TUTORIAL_NAME, Parameters.Instance );
+    }
+  }
+
+  bool Window::Create( const char *title ) {
+    Parameters.Instance = GetModuleHandle( nullptr );
+
+    // Register window class
+    WNDCLASSEX wcex;
+
+    wcex.cbSize = sizeof(WNDCLASSEX);
+
+    wcex.style = CS_HREDRAW | CS_VREDRAW;
+    wcex.lpfnWndProc = WndProc;
+    wcex.cbClsExtra = 0;
+    wcex.cbWndExtra = 0;
+    wcex.hInstance = Parameters.Instance;
+    wcex.hIcon = NULL;
+    wcex.hCursor = LoadCursor( NULL, IDC_ARROW );
+    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+    wcex.lpszMenuName = NULL;
+    wcex.lpszClassName = TUTORIAL_NAME;
+    wcex.hIconSm = NULL;
+
+    if( !RegisterClassEx( &wcex ) ) {
+      return false;
+    }
+
+    // Create window
+    Parameters.Handle = CreateWindow( TUTORIAL_NAME, title, WS_OVERLAPPEDWINDOW, 20, 20, 500, 500, nullptr, nullptr, Parameters.Instance, nullptr );
+    if( !Parameters.Handle ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Window::RenderingLoop( TutorialBase &tutorial ) const {
+    // Display window
+    ShowWindow( Parameters.Handle, SW_SHOWNORMAL );
+    UpdateWindow( Parameters.Handle );
+
+    // Main message loop
+    MSG message;
+    bool loop = true;
+    bool resize = false;
+
+    while( loop ) {
+      if( PeekMessage( &message, NULL, 0, 0, PM_REMOVE ) ) {
+        // Process events
+        switch( message.message ) {
+          // Resize
+          case WM_USER + 1:
+            resize = true;
+            break;
+            // Close
+          case WM_USER + 2:
+            loop = false;
+            break;
+        }
+        TranslateMessage( &message );
+        DispatchMessage( &message );
+      } else {
+        // Draw
+        if( resize ) {
+          resize = false;
+          if( !tutorial.OnWindowSizeChanged() ) {
+            loop = false;
+          }
+        }
+        if( !tutorial.Draw() ) {
+          loop = false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+
+  Window::~Window() {
+    xcb_destroy_window( Parameters.Connection, Parameters.Handle );
+    xcb_disconnect( Parameters.Connection );
+  }
+
+  bool Window::Create( const char *title ) {
+    int screen_index;
+    Parameters.Connection = xcb_connect( nullptr, &screen_index );
+
+    if( !Parameters.Connection ) {
+      return false;
+    }
+
+    const xcb_setup_t *setup = xcb_get_setup( Parameters.Connection );
+    xcb_screen_iterator_t screen_iterator = xcb_setup_roots_iterator( setup );
+
+    while( screen_index-- > 0 ) {
+      xcb_screen_next( &screen_iterator );
+    }
+
+    xcb_screen_t *screen = screen_iterator.data;
+
+    Parameters.Handle = xcb_generate_id( Parameters.Connection );
+
+    uint32_t value_list[] = {
+      screen->white_pixel,
+      XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_STRUCTURE_NOTIFY
+    };
+
+    xcb_create_window(
+      Parameters.Connection,
+      XCB_COPY_FROM_PARENT,
+      Parameters.Handle,
+      screen->root,
+      20,
+      20,
+      500,
+      500,
+      0,
+      XCB_WINDOW_CLASS_INPUT_OUTPUT,
+      screen->root_visual,
+      XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK,
+      value_list );
+
+    xcb_change_property(
+      Parameters.Connection,
+      XCB_PROP_MODE_REPLACE,
+      Parameters.Handle,
+      XCB_ATOM_WM_NAME,
+      XCB_ATOM_STRING,
+      8,
+      strlen( title ),
+      title );
+
+    return true;
+  }
+
+  bool Window::RenderingLoop( TutorialBase &tutorial ) const {
+    // Prepare notification for window destruction
+    xcb_intern_atom_cookie_t  protocols_cookie = xcb_intern_atom( Parameters.Connection, 1, 12, "WM_PROTOCOLS" );
+    xcb_intern_atom_reply_t  *protocols_reply  = xcb_intern_atom_reply( Parameters.Connection, protocols_cookie, 0 );
+    xcb_intern_atom_cookie_t  delete_cookie    = xcb_intern_atom( Parameters.Connection, 0, 16, "WM_DELETE_WINDOW" );
+    xcb_intern_atom_reply_t  *delete_reply     = xcb_intern_atom_reply( Parameters.Connection, delete_cookie, 0 );
+    xcb_change_property( Parameters.Connection, XCB_PROP_MODE_REPLACE, Parameters.Handle, (*protocols_reply).atom, 4, 32, 1, &(*delete_reply).atom );
+    free( protocols_reply );
+
+    // Display window
+    xcb_map_window( Parameters.Connection, Parameters.Handle );
+    xcb_flush( Parameters.Connection );
+
+    // Main message loop
+    xcb_generic_event_t *event;
+    bool loop = true;
+    bool resize = false;
+
+    while( loop ) {
+      event = xcb_poll_for_event( Parameters.Connection );
+
+      if( event ) {
+        // Process events
+        switch (event->response_type & 0x7f) {
+          // Resize
+          case XCB_CONFIGURE_NOTIFY: {
+            xcb_configure_notify_event_t *configure_event = (xcb_configure_notify_event_t*)event;
+            static uint16_t width = configure_event->width;
+            static uint16_t height = configure_event->height;
+
+            if( ((configure_event->width > 0) && (width != configure_event->width)) ||
+                ((configure_event->height > 0) && (height != configure_event->height)) ) {
+              resize = true;
+              width = configure_event->width;
+              height = configure_event->height;
+            }
+          }
+          break;
+          // Close
+          case XCB_CLIENT_MESSAGE:
+            if( (*(xcb_client_message_event_t*)event).data.data32[0] == (*delete_reply).atom ) {
+              loop = false;
+              free( delete_reply );
+            }
+            break;
+          case XCB_KEY_PRESS:
+            loop = false;
+            break;
+        }
+        free( event );
+      } else {
+        // Draw
+        if( resize ) {
+          resize = false;
+          if( !tutorial.OnWindowSizeChanged() ) {
+            loop = false;
+          }
+        }
+        if( !tutorial.Draw() ) {
+          loop = false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+
+  Window::~Window() {
+    XDestroyWindow( Parameters.DisplayPtr, Parameters.Handle );
+    XCloseDisplay( Parameters.DisplayPtr );
+  }
+
+  bool Window::Create( const char *title ) {
+    Parameters.DisplayPtr = XOpenDisplay( nullptr );
+    if( !Parameters.DisplayPtr ) {
+      return false;
+    }
+
+    int default_screen = DefaultScreen( Parameters.DisplayPtr );
+
+    Parameters.Handle = XCreateSimpleWindow(
+      Parameters.DisplayPtr,
+      DefaultRootWindow( Parameters.DisplayPtr ),
+      20,
+      20,
+      500,
+      500,
+      1,
+      BlackPixel( Parameters.DisplayPtr, default_screen ),
+      WhitePixel( Parameters.DisplayPtr, default_screen ) );
+
+    XSetStandardProperties( Parameters.DisplayPtr, Parameters.Handle, title, title, None, nullptr, 0, nullptr );
+    XSelectInput( Parameters.DisplayPtr, Parameters.Handle, ExposureMask | KeyPressMask | StructureNotifyMask );
+
+    return true;
+  }
+
+  bool Window::RenderingLoop( TutorialBase &tutorial ) const {
+    // Prepare notification for window destruction
+    Atom delete_window_atom;
+    delete_window_atom = XInternAtom( Parameters.DisplayPtr, "WM_DELETE_WINDOW", false );
+    XSetWMProtocols( Parameters.DisplayPtr, Parameters.Handle, &delete_window_atom, 1);
+
+    // Display window
+    XClearWindow( Parameters.DisplayPtr, Parameters.Handle );
+    XMapWindow( Parameters.DisplayPtr, Parameters.Handle );
+
+    // Main message loop
+    XEvent event;
+    bool loop = true;
+    bool resize = false;
+
+    while( loop ) {
+      if( XPending( Parameters.DisplayPtr ) ) {
+        XNextEvent( Parameters.DisplayPtr, &event );
+        switch( event.type ) {
+          //Process events
+          case ConfigureNotify: {
+            static int width = event.xconfigure.width;
+            static int height = event.xconfigure.height;
+
+            if( ((event.xconfigure.width > 0) && (event.xconfigure.width != width)) ||
+                ((event.xconfigure.height > 0) && (event.xconfigure.width != height)) ) {
+              width = event.xconfigure.width;
+              height = event.xconfigure.height;
+              resize = true;
+            }
+          }
+          break;
+          case KeyPress:
+            loop = false;
+            break;
+          case DestroyNotify:
+            loop = false;
+            break;
+          case ClientMessage:
+            if( static_cast<unsigned int>(event.xclient.data.l[0]) == delete_window_atom ) {
+              loop = false;
+            }
+            break;
+        }
+      } else {
+        // Draw
+        if( resize ) {
+          resize = false;
+          if( !tutorial.OnWindowSizeChanged() ) {
+            loop = false;
+          }
+        }
+        if( !tutorial.Draw() ) {
+          loop = false;
+        }
+      }
+    }
+
+    return true;
+  }
+
+#endif
+
+} // namespace OS

Project/Common/OperatingSystem.h

@@ -0,0 +1,120 @@
+// 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.
+
+#if !defined(OPERATING_SYSTEM_HEADER)
+#define OPERATING_SYSTEM_HEADER
+
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+#include <Windows.h>
+
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+#include <xcb/xcb.h>
+#include <dlfcn.h>
+#include <cstdlib>
+#include <cstring>
+
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <dlfcn.h>
+#include <cstdlib>
+#include <cstring>
+
+#endif
+
+#include <cstdio>
+
+namespace OS {
+
+  // ************************************************************ //
+  // LibraryHandle                                                //
+  //                                                              //
+  // Dynamic Library OS dependent type                            //
+  // ************************************************************ //
+  // 
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+  typedef HMODULE LibraryHandle;
+
+#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
+  typedef void* LibraryHandle;
+
+#endif
+
+  // ************************************************************ //
+  // OnWindowSizeChanged                                          //
+  //                                                              //
+  // Base class for handling window size changes                  //
+  // ************************************************************ //
+  class TutorialBase {
+  public:
+    virtual bool OnWindowSizeChanged() = 0;
+    virtual bool Draw() = 0;
+
+    virtual ~TutorialBase( ) {
+    }
+  };
+
+  // ************************************************************ //
+  // WindowParameters                                             //
+  //                                                              //
+  // OS dependent window parameters                               //
+  // ************************************************************ //
+  struct WindowParameters {
+#if defined(VK_USE_PLATFORM_WIN32_KHR)
+    HINSTANCE           Instance;
+    HWND                Handle;
+
+    WindowParameters() :
+      Instance(),
+      Handle() {
+    }
+
+#elif defined(VK_USE_PLATFORM_XCB_KHR)
+    xcb_connection_t   *Connection;
+    xcb_window_t        Handle;
+
+    WindowParameters() :
+      Connection(),
+      Handle() {
+    }
+
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+    Display            *DisplayPtr;
+    Window              Handle;
+
+    WindowParameters() :
+      DisplayPtr(),
+      Handle() {
+    }
+
+#endif
+  };
+
+  // ************************************************************ //
+  // Window                                                       //
+  //                                                              //
+  // OS dependent window creation and destruction class           //
+  // ************************************************************ //
+  class Window {
+  public:
+    Window();
+    ~Window();
+
+    bool              Create( const char *title );
+    bool              RenderingLoop( TutorialBase &tutorial ) const;
+    WindowParameters  GetParameters() const;
+
+  private:
+    WindowParameters  Parameters;
+  };
+
+}
+
+#endif // OPERATING_SYSTEM_HEADER

Project/Common/Tools.cpp

@@ -0,0 +1,36 @@
+// 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.
+
+#include "Tools.h"
+
+namespace Tools {
+
+    std::vector<char> GetBinaryFileContents( std::string const &filename ) {
+
+        std::ifstream file( filename, std::ios::binary );
+        if( file.fail() ) {
+            printf( "Could not open \"%s\" file!\n", filename.c_str() );
+            return std::vector<char>();
+        }
+
+        std::streampos begin, end;
+        begin = file.tellg();
+        file.seekg( 0, std::ios::end );
+        end = file.tellg();
+
+        std::vector<char> result( static_cast<size_t>(end - begin) );
+        file.seekg( 0, std::ios::beg );
+        file.read( &result[0], end - begin );
+        file.close();
+
+        return result;
+    }
+
+}

Project/Common/Tools.h

@@ -0,0 +1,88 @@
+// 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.
+
+#if !defined(TOOLS_HEADER)
+#define TOOLS_HEADER
+
+#include <string>
+#include <vector>
+#include <fstream>
+#include "vulkan.h"
+
+namespace Tools {
+
+  // ************************************************************ //
+  // AutoDeleter                                                  //
+  //                                                              //
+  // Auto-deleter helper template class responsible for calling   //
+  // provided function which deletes given object of type T       //
+  // ************************************************************ //
+  template<class T, class F>
+  class AutoDeleter {
+  public:
+    AutoDeleter() :
+      Object( VK_NULL_HANDLE ),
+      Deleter( nullptr ),
+      Device( VK_NULL_HANDLE ) {
+    }
+
+    AutoDeleter( T object, F deleter, VkDevice device ) :
+      Object( object ),
+      Deleter( deleter ),
+      Device( device ) {
+    }
+
+    AutoDeleter( AutoDeleter&& other ) {
+      *this = std::move( other );
+    }
+
+    ~AutoDeleter() {
+      if( (Object != VK_NULL_HANDLE) && (Deleter != nullptr) && (Device != VK_NULL_HANDLE) ) {
+        Deleter( Device, Object, nullptr );
+      }
+    }
+
+    AutoDeleter& operator=( AutoDeleter&& other ) {
+      if( this != &other ) {
+        Object = other.Object;
+        Deleter = other.Deleter;
+        Device = other.Device;
+        other.Object = VK_NULL_HANDLE;
+      }
+      return *this;
+    }
+
+    T Get() {
+      return Object;
+    }
+
+    bool operator !() const {
+      return Object == VK_NULL_HANDLE;
+    }
+
+  private:
+    AutoDeleter( const AutoDeleter& );
+    AutoDeleter& operator=( const AutoDeleter& );
+    T         Object;
+    F         Deleter;
+    VkDevice  Device;
+  };
+
+  // ************************************************************ //
+  // GetBinaryFileContents                                        //
+  //                                                              //
+  // Function reading binary contents of a file                   //
+  // ************************************************************ //
+  std::vector<char> GetBinaryFileContents( std::string const &filename );
+
+}
+
+
+#endif // TOOLS_HEADER

Project/Common/VulkanCommon.cpp

@@ -0,0 +1,692 @@
+// 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.
+
+#include <cstring>
+#include "VulkanCommon.h"
+#include "VulkanFunctions.h"
+
+namespace Tutorial {
+
+  VulkanCommon::VulkanCommon() :
+    VulkanLibrary(),
+    Window(),
+    Vulkan() {
+  }
+
+  bool VulkanCommon::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( !CreateSwapChain() ) {
+      return false;
+    }
+    if( !CreateSemaphores() ) {
+      return false;
+    }
+    return true;
+  }
+
+  bool VulkanCommon::OnWindowSizeChanged() {
+    ChildClear();
+
+    if( !CreateSwapChain() ) {
+      return false;
+    }
+    return ChildOnWindowSizeChanged();
+  }
+
+  VkPhysicalDevice VulkanCommon::GetPhysicalDevice() const {
+    return Vulkan.PhysicalDevice;
+  }
+
+  VkDevice VulkanCommon::GetDevice() const {
+    return Vulkan.Device;
+  }
+
+  const QueueParameters VulkanCommon::GetGraphicsQueue() const {
+    return Vulkan.GraphicsQueue;
+  }
+
+  const QueueParameters VulkanCommon::GetPresentQueue() const {
+    return Vulkan.PresentQueue;
+  }
+
+  const SwapChainParameters VulkanCommon::GetSwapChain() const {
+    return Vulkan.SwapChain;
+  }
+
+  const VkSemaphore VulkanCommon::GetImageAvailableSemaphore() const {
+    return Vulkan.ImageAvailableSemaphore;
+  }
+
+  const VkSemaphore VulkanCommon::GetRenderingFinishedSemaphore() const {
+    return Vulkan.RenderingFinishedSemaphore;
+  }
+
+  bool VulkanCommon::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", RTLD_NOW );
+#endif
+
+    if( VulkanLibrary == nullptr ) {
+      printf( "Could not load Vulkan library!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool VulkanCommon::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 )) ) {  \
+      printf( "Could not load exported function: " #fun "!\n" );        \
+      return false;                                                     \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool VulkanCommon::LoadGlobalLevelEntryPoints() {
+#define VK_GLOBAL_LEVEL_FUNCTION( fun )                                 \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( nullptr, #fun )) ) {  \
+      printf( "Could not load global level function: " #fun "!\n" );    \
+      return false;                                                     \
+    }
+
+#include "ListOfFunctions.inl"
+
+      return true;
+  }
+
+  bool VulkanCommon::CreateInstance() {
+    uint32_t extensions_count = 0;
+    if( (vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, nullptr ) != VK_SUCCESS) ||
+        (extensions_count == 0) ) {
+      printf( "Error occurred during instance extensions enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkExtensionProperties> available_extensions( extensions_count );
+    if( vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during instance extensions enumeration!\n" );
+      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 ) ) {
+        printf( "Could not find instance extension named \"%s\"!\n", extensions[i] );
+        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_API_VERSION                                  // 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 ) {
+      printf( "Could not create Vulkan instance!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool VulkanCommon::LoadInstanceLevelEntryPoints() {
+#define VK_INSTANCE_LEVEL_FUNCTION( fun )                                       \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( Vulkan.Instance, #fun )) ) {  \
+      printf( "Could not load instance level function: " #fun "\n" );           \
+      return false;                                                             \
+    }
+
+#include "ListOfFunctions.inl"
+
+      return true;
+  }
+
+  bool VulkanCommon::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
+
+    printf( "Could not create presentation surface!\n" );
+    return false;
+  }
+
+  bool VulkanCommon::CreateDevice() {
+    uint32_t num_devices = 0;
+    if( (vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, nullptr ) != VK_SUCCESS) ||
+        (num_devices == 0) ) {
+      printf( "Error occurred during physical devices enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkPhysicalDevice> physical_devices( num_devices );
+    if( vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, &physical_devices[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during physical devices enumeration!\n" );
+      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];
+      }
+    }
+    if( Vulkan.PhysicalDevice == VK_NULL_HANDLE ) {
+      printf( "Could not select physical device based on the chosen properties!\n" );
+      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
+      1,                                                // 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 ) {
+      printf( "Could not create Vulkan device!\n" );
+      return false;
+    }
+
+    Vulkan.GraphicsQueue.FamilyIndex = selected_graphics_queue_family_index;
+    Vulkan.PresentQueue.FamilyIndex = selected_present_queue_family_index;
+    return true;
+  }
+
+  bool VulkanCommon::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) ) {
+      printf( "Error occurred during physical device %p extensions enumeration!\n", physical_device );
+      return false;
+    }
+
+    std::vector<VkExtensionProperties> available_extensions( extensions_count );
+    if( vkEnumerateDeviceExtensionProperties( physical_device, nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during physical device %p extensions enumeration!\n", physical_device );
+      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 ) ) {
+        printf( "Physical device %p doesn't support extension named \"%s\"!\n", physical_device, device_extensions[i] );
+        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) ) {
+      printf( "Physical device %p doesn't support required parameters!\n", physical_device );
+      return false;
+    }
+
+    uint32_t queue_families_count = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
+    if( queue_families_count == 0 ) {
+      printf( "Physical device %p doesn't have any queue families!\n", physical_device );
+      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) ) {
+      printf( "Could not find queue families with required properties on physical device %p!\n", physical_device );
+      return false;
+    }
+
+    selected_graphics_queue_family_index = graphics_queue_family_index;
+    selected_present_queue_family_index = present_queue_family_index;
+    return true;
+  }
+
+  bool VulkanCommon::LoadDeviceLevelEntryPoints() {
+#define VK_DEVICE_LEVEL_FUNCTION( fun )                                     \
+    if( !(fun = (PFN_##fun)vkGetDeviceProcAddr( Vulkan.Device, #fun )) ) {  \
+      printf( "Could not load device level function: " #fun "!\n" );        \
+      return false;                                                         \
+    }
+
+#include "ListOfFunctions.inl"
+
+      return true;
+  }
+
+  bool VulkanCommon::GetDeviceQueue() {
+    vkGetDeviceQueue( Vulkan.Device, Vulkan.GraphicsQueue.FamilyIndex, 0, &Vulkan.GraphicsQueue.Handle );
+    vkGetDeviceQueue( Vulkan.Device, Vulkan.PresentQueue.FamilyIndex, 0, &Vulkan.PresentQueue.Handle );
+    return true;
+  }
+
+  bool VulkanCommon::CreateSwapChain() {
+    if( Vulkan.Device != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( Vulkan.Device );
+    }
+
+    VkSurfaceCapabilitiesKHR surface_capabilities;
+    if( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &surface_capabilities ) != VK_SUCCESS ) {
+      printf( "Could not check presentation surface capabilities!\n" );
+      return false;
+    }
+
+    uint32_t formats_count;
+    if( (vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, nullptr ) != VK_SUCCESS) ||
+        (formats_count == 0) ) {
+      printf( "Error occurred during presentation surface formats enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkSurfaceFormatKHR> surface_formats( formats_count );
+    if( vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, &surface_formats[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during presentation surface formats enumeration!\n" );
+      return false;
+    }
+
+    uint32_t present_modes_count;
+    if( (vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, nullptr ) != VK_SUCCESS) ||
+        (present_modes_count == 0) ) {
+      printf( "Error occurred during presentation surface present modes enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkPresentModeKHR> present_modes( present_modes_count );
+    if( vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, &present_modes[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during presentation surface present modes enumeration!\n" );
+      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.Handle;
+
+    if( static_cast<int>(desired_usage) == 0 ) {
+      printf( "TRANSFER_DST image usage is not supported by the swap chain!" );
+      return false;
+    }
+
+    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.Handle ) != VK_SUCCESS ) {
+      printf( "Could not create swap chain!\n" );
+      return false;
+    }
+    if( old_swap_chain != VK_NULL_HANDLE ) {
+      vkDestroySwapchainKHR( Vulkan.Device, old_swap_chain, nullptr );
+    }
+
+    Vulkan.SwapChain.Format = desired_format.format;
+
+    uint32_t image_count = 0;
+    if( (vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain.Handle, &image_count, nullptr ) != VK_SUCCESS) ||
+        (image_count == 0) ) {
+      printf( "Could not get swap chain images!\n" );
+      return false;
+    }
+    Vulkan.SwapChain.Images.resize( image_count );
+    if( vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain.Handle, &image_count, &Vulkan.SwapChain.Images[0] ) != VK_SUCCESS ) {
+      printf( "Could not get swap chain images!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool VulkanCommon::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) ) {
+      printf( "Could not create semaphores!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool VulkanCommon::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;
+  }
+
+  uint32_t VulkanCommon::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 VulkanCommon::GetSwapChainFormat( std::vector<VkSurfaceFormatKHR> &surface_formats ) {
+    // If the list contains only one entry with undefined format
+    // it mean that there are no preferred surface formats and any can be choosen
+    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 VulkanCommon::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 VulkanCommon::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;
+    }
+    return 0;
+  }
+
+  VkSurfaceTransformFlagBitsKHR VulkanCommon::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 no 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 VulkanCommon::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;
+      }
+    }
+    return VK_PRESENT_MODE_FIFO_KHR;
+  }
+
+  VulkanCommon::~VulkanCommon() {
+    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.Handle != VK_NULL_HANDLE ) {
+        vkDestroySwapchainKHR( Vulkan.Device, Vulkan.SwapChain.Handle, 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 Tutorial

Project/Common/VulkanCommon.h

@@ -0,0 +1,134 @@
+// 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.
+
+#if !defined(VULKAN_COMMON_HEADER)
+#define VULKAN_COMMON_HEADER
+
+#include <vector>
+#include "vulkan.h"
+#include "OperatingSystem.h"
+
+namespace Tutorial {
+
+  // ************************************************************ //
+  // QueueParameters                                              //
+  //                                                              //
+  // Vulkan Queue's parameters container class                    //
+  // ************************************************************ //
+  struct QueueParameters {
+    VkQueue                       Handle;
+    uint32_t                      FamilyIndex;
+
+    QueueParameters() :
+      Handle( VK_NULL_HANDLE ),
+      FamilyIndex( 0 ) {
+    }
+  };
+
+  // ************************************************************ //
+  // SwapChainParameters                                          //
+  //                                                              //
+  // Vulkan SwapChain's parameters container class                //
+  // ************************************************************ //
+  struct SwapChainParameters {
+    VkSwapchainKHR                Handle;
+    VkFormat                      Format;
+    std::vector<VkImage>          Images;
+
+    SwapChainParameters() :
+      Handle( VK_NULL_HANDLE ),
+      Format( VK_FORMAT_UNDEFINED ),
+      Images() {
+    }
+  };
+
+  // ************************************************************ //
+  // VulkanCommonParameters                                       //
+  //                                                              //
+  // General Vulkan parameters' container class                   //
+  // ************************************************************ //
+  struct VulkanCommonParameters {
+    VkInstance                    Instance;
+    VkPhysicalDevice              PhysicalDevice;
+    VkDevice                      Device;
+    QueueParameters               GraphicsQueue;
+    QueueParameters               PresentQueue;
+    VkSurfaceKHR                  PresentationSurface;
+    SwapChainParameters           SwapChain;
+    VkSemaphore                   ImageAvailableSemaphore;
+    VkSemaphore                   RenderingFinishedSemaphore;
+
+    VulkanCommonParameters() :
+      Instance( VK_NULL_HANDLE ),
+      PhysicalDevice( VK_NULL_HANDLE ),
+      Device( VK_NULL_HANDLE ),
+      GraphicsQueue(),
+      PresentQueue(),
+      PresentationSurface( VK_NULL_HANDLE ),
+      SwapChain() {
+    }
+  };
+
+  // ************************************************************ //
+  // VulkanCommon                                                 //
+  //                                                              //
+  // Base class for Vulkan more advanced tutorial classes         //
+  // ************************************************************ //
+  class VulkanCommon : public OS::TutorialBase {
+  public:
+    VulkanCommon();
+    virtual ~VulkanCommon();
+
+    bool                          PrepareVulkan( OS::WindowParameters parameters );
+    virtual bool                  OnWindowSizeChanged() final override;
+
+  protected:
+    VkPhysicalDevice              GetPhysicalDevice() const;
+    VkDevice                      GetDevice() const;
+
+    const QueueParameters         GetGraphicsQueue() const;
+    const QueueParameters         GetPresentQueue() const;
+
+    const SwapChainParameters     GetSwapChain() const;
+    const VkSemaphore             GetImageAvailableSemaphore() const;
+    const VkSemaphore             GetRenderingFinishedSemaphore() const;
+
+  private:
+    OS::LibraryHandle       VulkanLibrary;
+    OS::WindowParameters    Window;
+    VulkanCommonParameters  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                          CreateSwapChain();
+    bool                          CreateSemaphores();
+    virtual bool                  ChildOnWindowSizeChanged() = 0;
+    virtual void                  ChildClear() = 0;
+
+    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 Tutorial
+
+#endif // VULKAN_COMMON_HEADER

Project/Common/VulkanFunctions.cpp

@@ -0,0 +1,18 @@
+// 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.
+
+#include "vulkan.h"
+
+#define VK_EXPORTED_FUNCTION( fun ) PFN_##fun fun;
+#define VK_GLOBAL_LEVEL_FUNCTION( fun ) PFN_##fun fun;
+#define VK_INSTANCE_LEVEL_FUNCTION( fun ) PFN_##fun fun;
+#define VK_DEVICE_LEVEL_FUNCTION( fun ) PFN_##fun fun;
+
+#include "ListOfFunctions.inl"

Project/Common/VulkanFunctions.h

@@ -0,0 +1,23 @@
+// 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.
+
+#if !defined(VULKAN_FUNCTIONS_HEADER)
+#define VULKAN_FUNCTIONS_HEADER
+
+#include "vulkan.h"
+
+#define VK_EXPORTED_FUNCTION( fun ) extern PFN_##fun fun;
+#define VK_GLOBAL_LEVEL_FUNCTION( fun) extern PFN_##fun fun;
+#define VK_INSTANCE_LEVEL_FUNCTION( fun ) extern PFN_##fun fun;
+#define VK_DEVICE_LEVEL_FUNCTION( fun ) extern PFN_##fun fun;
+
+#include "ListOfFunctions.inl"
+
+#endif

Project/Include/vk_platform.h

@@ -0,0 +1,127 @@
+//
+// File: vk_platform.h
+//
+/*
+** Copyright (c) 2014-2015 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+
+#ifndef __VK_PLATFORM_H__
+#define __VK_PLATFORM_H__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif // __cplusplus
+
+/*
+***************************************************************************************************
+*   Platform-specific directives and type declarations
+***************************************************************************************************
+*/
+
+/* Platform-specific calling convention macros.
+ *
+ * Platforms should define these so that Vulkan clients call Vulkan commands
+ * with the same calling conventions that the Vulkan implementation expects.
+ *
+ * VKAPI_ATTR - Placed before the return type in function declarations.
+ *              Useful for C++11 and GCC/Clang-style function attribute syntax.
+ * VKAPI_CALL - Placed after the return type in function declarations.
+ *              Useful for MSVC-style calling convention syntax.
+ * VKAPI_PTR  - Placed between the '(' and '*' in function pointer types.
+ *
+ * Function declaration:  VKAPI_ATTR void VKAPI_CALL vkCommand(void);
+ * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void);
+ */
+#if defined(_WIN32)
+    // On Windows, Vulkan commands use the stdcall convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL __stdcall
+    #define VKAPI_PTR  VKAPI_CALL
+#elif defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
+    // Android does not support Vulkan in native code using the "armeabi" ABI.
+    #error "Vulkan requires the 'armeabi-v7a' or 'armeabi-v7a-hard' ABI on 32-bit ARM CPUs"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH_7A__)
+    // On Android/ARMv7a, Vulkan functions use the armeabi-v7a-hard calling
+    // convention, even if the application's native code is compiled with the
+    // armeabi-v7a calling convention.
+    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
+    #define VKAPI_CALL
+    #define VKAPI_PTR  VKAPI_ATTR
+#else
+    // On other platforms, use the default calling convention
+    #define VKAPI_ATTR
+    #define VKAPI_CALL
+    #define VKAPI_PTR
+#endif
+
+#include <stddef.h>
+
+#if !defined(VK_NO_STDINT_H)
+    #if defined(_MSC_VER) && (_MSC_VER < 1600)
+        typedef signed   __int8  int8_t;
+        typedef unsigned __int8  uint8_t;
+        typedef signed   __int16 int16_t;
+        typedef unsigned __int16 uint16_t;
+        typedef signed   __int32 int32_t;
+        typedef unsigned __int32 uint32_t;
+        typedef signed   __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
+    #else
+        #include <stdint.h>
+    #endif
+#endif // !defined(VK_NO_STDINT_H)
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+// Platform-specific headers required by platform window system extensions.
+// These are enabled prior to #including "vulkan.h". The same enable then
+// controls inclusion of the extension interfaces in vulkan.h.
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#include <android/native_window.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_MIR_KHR
+#include <mir_toolkit/client_types.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#endif
+
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#endif
+
+#endif // __VK_PLATFORM_H__

Project/Tutorial01/Tutorial01.cpp

@@ -0,0 +1,276 @@
+// 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.
+
+#include <vector>
+#include "Tutorial01.h"
+#include "VulkanFunctions.h"
+
+namespace Tutorial {
+
+  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", RTLD_NOW );
+#endif
+
+    if( VulkanLibrary == nullptr ) {
+      printf( "Could not load Vulkan library!\n" );
+      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 )) ) {  \
+    printf( "Could not load exported function: " #fun "!\n" );          \
+    return false;                                                       \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial01::LoadGlobalLevelEntryPoints() {
+#define VK_GLOBAL_LEVEL_FUNCTION( fun )                                 \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( nullptr, #fun )) ) {  \
+      printf( "Could not load global level function: " #fun "!\n" );    \
+      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_API_VERSION                                  // 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 ) {
+      printf( "Could not create Vulkan instance!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial01::LoadInstanceLevelEntryPoints() {
+#define VK_INSTANCE_LEVEL_FUNCTION( fun )                                       \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( Vulkan.Instance, #fun )) ) {  \
+      printf( "Could not load instance level function: " #fun "\n" );           \
+      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) ) {
+      printf( "Error occurred during physical devices enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkPhysicalDevice> physical_devices( num_devices );
+    if( vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, &physical_devices[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during physical devices enumeration!\n" );
+      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];
+      }
+    }
+    if( selected_physical_device == VK_NULL_HANDLE ) {
+      printf( "Could not select physical device based on the chosen properties!\n" );
+      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 ) {
+      printf( "Could not create Vulkan device!\n" );
+      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) ) {
+      printf( "Physical device %p doesn't support required parameters!\n", physical_device );
+      return false;
+    }
+
+    uint32_t queue_families_count = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
+    if( queue_families_count == 0 ) {
+      printf( "Physical device %p doesn't have any queue families!\n", physical_device );
+      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;
+        return true;
+      }
+    }
+
+    printf( "Could not find queue family with required properties on physical device %p!\n", physical_device );
+    return false;
+  }
+
+  bool Tutorial01::LoadDeviceLevelEntryPoints() {
+#define VK_DEVICE_LEVEL_FUNCTION( fun )                                     \
+    if( !(fun = (PFN_##fun)vkGetDeviceProcAddr( Vulkan.Device, #fun )) ) {  \
+      printf( "Could not load device level function: " #fun "!\n" );        \
+      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 Tutorial

Project/Tutorial01/Tutorial01.h

@@ -0,0 +1,70 @@
+// 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.
+
+#if !defined(TUTORIAL_01_HEADER)
+#define TUTORIAL_01_HEADER
+
+#include "vulkan.h"
+#include "OperatingSystem.h"
+
+namespace Tutorial {
+
+  // ************************************************************ //
+  // 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 Tutorial
+
+#endif // TUTORIAL_01_HEADER

Project/Tutorial01/main.cpp

@@ -0,0 +1,33 @@
+// 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.
+
+#include "Tutorial01.h"
+
+int main( int argc, char **argv ) {
+  OS::Window            window;
+  Tutorial::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/Tutorial02/Tutorial02.cpp

@@ -0,0 +1,836 @@
+// 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.
+
+#include <cstring>
+#include "Tutorial02.h"
+#include "VulkanFunctions.h"
+
+namespace Tutorial {
+
+  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", RTLD_NOW );
+#endif
+
+    if( VulkanLibrary == nullptr ) {
+      printf( "Could not load Vulkan library!\n" );
+      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 )) ) {  \
+      printf( "Could not load exported function: " #fun "!\n" );        \
+      return false;                                                     \
+    }
+
+#include "ListOfFunctions.inl"
+
+    return true;
+  }
+
+  bool Tutorial02::LoadGlobalLevelEntryPoints() {
+#define VK_GLOBAL_LEVEL_FUNCTION( fun )                                 \
+    if( !(fun = (PFN_##fun)vkGetInstanceProcAddr( nullptr, #fun )) ) {  \
+      printf( "Could not load global level function: " #fun "!\n" );    \
+      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) ) {
+      printf( "Error occurred during instance extensions enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkExtensionProperties> available_extensions( extensions_count );
+    if( vkEnumerateInstanceExtensionProperties( nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during instance extensions enumeration!\n" );
+      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 ) ) {
+        printf( "Could not find instance extension named \"%s\"!\n", extensions[i] );
+        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_API_VERSION                                  // 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 ) {
+      printf( "Could not create Vulkan instance!\n" );
+      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 )) ) {  \
+      printf( "Could not load instance level function: " #fun "\n" );           \
+      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
+
+    printf( "Could not create presentation surface!\n" );
+    return false;
+  }
+
+  bool Tutorial02::CreateDevice() {
+    uint32_t num_devices = 0;
+    if( (vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, nullptr ) != VK_SUCCESS) ||
+        (num_devices == 0) ) {
+      printf( "Error occurred during physical devices enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkPhysicalDevice> physical_devices( num_devices );
+    if( vkEnumeratePhysicalDevices( Vulkan.Instance, &num_devices, &physical_devices[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during physical devices enumeration!\n" );
+      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];
+      }
+    }
+    if( Vulkan.PhysicalDevice == VK_NULL_HANDLE ) {
+      printf( "Could not select physical device based on the chosen properties!\n" );
+      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
+      1,                                                // 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 ) {
+      printf( "Could not create Vulkan device!\n" );
+      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) ) {
+      printf( "Error occurred during physical device %p extensions enumeration!\n", physical_device );
+      return false;
+    }
+
+    std::vector<VkExtensionProperties> available_extensions( extensions_count );
+    if( vkEnumerateDeviceExtensionProperties( physical_device, nullptr, &extensions_count, &available_extensions[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during physical device %p extensions enumeration!\n", physical_device );
+      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 ) ) {
+        printf( "Physical device %p doesn't support extension named \"%s\"!\n", physical_device, device_extensions[i] );
+        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) ) {
+      printf( "Physical device %p doesn't support required parameters!\n", physical_device );
+      return false;
+    }
+
+    uint32_t queue_families_count = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties( physical_device, &queue_families_count, nullptr );
+    if( queue_families_count == 0 ) {
+      printf( "Physical device %p doesn't have any queue families!\n", physical_device );
+      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) ) {
+      printf( "Could not find queue families with required properties on physical device %p!\n", physical_device );
+      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 )) ) {  \
+      printf( "Could not load device level function: " #fun "!\n" );        \
+      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) ) {
+      printf( "Could not create semaphores!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial02::CreateSwapChain() {
+    if( Vulkan.Device != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( Vulkan.Device );
+    }
+
+    VkSurfaceCapabilitiesKHR surface_capabilities;
+    if( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &surface_capabilities ) != VK_SUCCESS ) {
+      printf( "Could not check presentation surface capabilities!\n" );
+      return false;
+    }
+
+    uint32_t formats_count;
+    if( (vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, nullptr ) != VK_SUCCESS) ||
+        (formats_count == 0) ) {
+      printf( "Error occurred during presentation surface formats enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkSurfaceFormatKHR> surface_formats( formats_count );
+    if( vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, &surface_formats[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during presentation surface formats enumeration!\n" );
+      return false;
+    }
+
+    uint32_t present_modes_count;
+    if( (vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, nullptr ) != VK_SUCCESS) ||
+        (present_modes_count == 0) ) {
+      printf( "Error occurred during presentation surface present modes enumeration!\n" );
+      return false;
+    }
+
+    std::vector<VkPresentModeKHR> present_modes( present_modes_count );
+    if( vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, &present_modes[0] ) != VK_SUCCESS ) {
+      printf( "Error occurred during presentation surface present modes enumeration!\n" );
+      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) == 0 ) {
+      printf( "TRANSFER_DST image usage is not supported by the swap chain!" );
+      return false;
+    }
+
+    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 ) {
+      printf( "Could not create swap chain!\n" );
+      return false;
+    }
+    if( old_swap_chain != VK_NULL_HANDLE ) {
+      vkDestroySwapchainKHR( Vulkan.Device, old_swap_chain, nullptr );
+    }
+
+    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 mean that there are no preferred surface formats and any can be choosen
+    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;
+    }
+    return 0;
+  }
+
+  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;
+      }
+    }
+    return VK_PRESENT_MODE_FIFO_KHR;
+  }
+
+  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 ) {
+      printf( "Could not create a command pool!\n" );
+      return false;
+    }
+
+    uint32_t image_count = 0;
+    if( (vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain, &image_count, nullptr ) != VK_SUCCESS) ||
+        (image_count == 0) ) {
+      printf( "Could not get the number of swap chain images!\n" );
+      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 ) {
+      printf( "Could not allocate command buffers!\n" );
+      return false;
+    }
+
+    if( !RecordCommandBuffers() ) {
+      printf( "Could not record command buffers!\n" );
+      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 ) {
+      printf( "Could not get swap chain images!\n" );
+      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
+        Vulkan.PresentQueueFamilyIndex,             // uint32_t                               srcQueueFamilyIndex
+        Vulkan.PresentQueueFamilyIndex,             // 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
+        Vulkan.PresentQueueFamilyIndex,             // uint32_t                               srcQueueFamilyIndex
+        Vulkan.PresentQueueFamilyIndex,             // 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 ) {
+        printf( "Could not record command buffers!\n" );
+        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:
+        printf( "Problem occurred during swap chain image acquisition!\n" );
+        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:
+        printf( "Problem occurred during image presentation!\n" );
+        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 Tutorial

Project/Tutorial02/Tutorial02.h

@@ -0,0 +1,101 @@
+// 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.
+
+#if !defined(TUTORIAL_02_HEADER)
+#define TUTORIAL_02_HEADER
+
+#include <vector>
+#include "vulkan.h"
+#include "OperatingSystem.h"
+
+namespace Tutorial {
+
+  // ************************************************************ //
+  // 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 Tutorial
+
+#endif // TUTORIAL_02_HEADER

Project/Tutorial02/main.cpp

@@ -0,0 +1,39 @@
+// 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.
+
+#include "Tutorial02.h"
+
+int main( int argc, char **argv ) {
+  OS::Window            window;
+  Tutorial::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/Tutorial03/Data03/frag.spv.txt

@@ -0,0 +1,35 @@
+shader.frag
+Warning, version 400 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 400
+                              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/Tutorial03/Data03/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 400
+
+layout(location = 0) out vec4 out_Color;
+
+void main() {
+  out_Color = vec4( 0.0, 0.4, 1.0, 1.0 );
+}

Project/Tutorial03/Data03/shader.vert

@@ -0,0 +1,16 @@
+// 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 400
+
+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/Tutorial03/Data03/vert.spv.txt

@@ -0,0 +1,72 @@
+shader.vert
+Warning, version 400 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 40
+
+                              Capability Shader
+                              Capability ClipDistance
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 25 29
+                              Source GLSL 400
+                              Name 4  "main"
+                              Name 12  "pos"
+                              Name 23  "gl_PerVertex"
+                              MemberName 23(gl_PerVertex) 0  "gl_Position"
+                              MemberName 23(gl_PerVertex) 1  "gl_PointSize"
+                              MemberName 23(gl_PerVertex) 2  "gl_ClipDistance"
+                              Name 25  ""
+                              Name 29  "gl_VertexIndex"
+                              MemberDecorate 23(gl_PerVertex) 0 BuiltIn Position
+                              MemberDecorate 23(gl_PerVertex) 1 BuiltIn PointSize
+                              MemberDecorate 23(gl_PerVertex) 2 BuiltIn ClipDistance
+                              Decorate 23(gl_PerVertex) Block
+                              Decorate 29(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:      8(int) Constant 1
+              22:             TypeArray 6(float) 21
+23(gl_PerVertex):             TypeStruct 20(fvec4) 6(float) 22
+              24:             TypePointer Output 23(gl_PerVertex)
+              25:     24(ptr) Variable Output
+              26:             TypeInt 32 1
+              27:     26(int) Constant 0
+              28:             TypePointer Input 26(int)
+29(gl_VertexIndex):     28(ptr) Variable Input
+              31:             TypePointer Function 7(fvec2)
+              34:    6(float) Constant 1065353216
+              38:             TypePointer Output 20(fvec4)
+         4(main):           2 Function None 3
+               5:             Label
+         12(pos):     11(ptr) Variable Function
+                              Store 12(pos) 19
+              30:     26(int) Load 29(gl_VertexIndex)
+              32:     31(ptr) AccessChain 12(pos) 30
+              33:    7(fvec2) Load 32
+              35:    6(float) CompositeExtract 33 0
+              36:    6(float) CompositeExtract 33 1
+              37:   20(fvec4) CompositeConstruct 35 36 17 34
+              39:     38(ptr) AccessChain 25 27
+                              Store 39 37
+                              Return
+                              FunctionEnd

Project/Tutorial03/Tutorial03.cpp

@@ -0,0 +1,596 @@
+// 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.
+
+#include "Tutorial03.h"
+#include "VulkanFunctions.h"
+
+namespace Tutorial {
+
+  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_PRESENT_SRC_KHR,            // 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 ) {
+      printf( "Could not create render pass!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial03::CreateFramebuffers() {
+    const std::vector<VkImage> &swap_chain_images = GetSwapChain().Images;
+    Vulkan.FramebufferObjects.resize( swap_chain_images.size() );
+
+    for( size_t i = 0; i < swap_chain_images.size(); ++i ) {
+      VkImageViewCreateInfo image_view_create_info = {
+        VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,   // VkStructureType                sType
+        nullptr,                                    // const void                    *pNext
+        0,                                          // VkImageViewCreateFlags         flags
+        swap_chain_images[i],                       // VkImage                        image
+        VK_IMAGE_VIEW_TYPE_2D,                      // VkImageViewType                viewType
+        GetSwapChain().Format,                      // VkFormat                       format
+        {                                           // VkComponentMapping             components
+          VK_COMPONENT_SWIZZLE_IDENTITY,              // VkComponentSwizzle             r
+          VK_COMPONENT_SWIZZLE_IDENTITY,              // VkComponentSwizzle             g
+          VK_COMPONENT_SWIZZLE_IDENTITY,              // VkComponentSwizzle             b
+          VK_COMPONENT_SWIZZLE_IDENTITY               // VkComponentSwizzle             a
+        },
+        {                                           // VkImageSubresourceRange        subresourceRange
+          VK_IMAGE_ASPECT_COLOR_BIT,                  // VkImageAspectFlags             aspectMask
+          0,                                          // uint32_t                       baseMipLevel
+          1,                                          // uint32_t                       levelCount
+          0,                                          // uint32_t                       baseArrayLayer
+          1                                           // uint32_t                       layerCount
+        }
+      };
+
+      if( vkCreateImageView( GetDevice(), &image_view_create_info, nullptr, &Vulkan.FramebufferObjects[i].ImageView ) != VK_SUCCESS ) {
+        printf( "Could not create image view for framebuffer!\n" );
+        return false;
+      }
+
+      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
+        &Vulkan.FramebufferObjects[i].ImageView,    // const VkImageView             *pAttachments
+        300,                                        // uint32_t                       width
+        300,                                        // uint32_t                       height
+        1                                           // uint32_t                       layers
+      };
+
+      if( vkCreateFramebuffer( GetDevice(), &framebuffer_create_info, nullptr, &Vulkan.FramebufferObjects[i].Handle ) != VK_SUCCESS ) {
+        printf( "Could not create a framebuffer!\n" );
+        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 ) {
+      printf( "Could not create shader module from a %s file!\n", filename );
+      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 ) {
+      printf( "Could not create pipeline layout!\n" );
+      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( "Data03/vert.spv" );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> fragment_shader_module = CreateShaderModule( "Data03/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 ) {
+      printf( "Could not create graphics pipeline!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial03::CreateCommandBuffers() {
+    if( !CreateCommandPool( GetGraphicsQueue().FamilyIndex, &Vulkan.GraphicsCommandPool ) ) {
+      printf( "Could not create command pool!\n" );
+      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] ) ) {
+      printf( "Could not allocate command buffers!\n" );
+      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<VkImage>& 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_PRESENT_SRC_KHR,            // VkImageLayout                  oldLayout
+          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,            // VkImageLayout                  newLayout
+          GetPresentQueue().FamilyIndex,              // uint32_t                       srcQueueFamilyIndex
+          GetGraphicsQueue().FamilyIndex,             // uint32_t                       dstQueueFamilyIndex
+          swap_chain_images[i],                       // 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.FramebufferObjects[i].Handle,          // 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],                         // 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 ) {
+        printf( "Could not record command buffer!\n" );
+        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() {
+    VkSemaphore image_available_semaphore = GetImageAvailableSemaphore();
+    VkSemaphore rendering_finished_semaphore = GetRenderingFinishedSemaphore();
+    VkSwapchainKHR swap_chain = GetSwapChain().Handle;
+    uint32_t image_index;
+
+    VkResult result = vkAcquireNextImageKHR( GetDevice(), swap_chain, UINT64_MAX, image_available_semaphore, 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:
+        printf( "Problem occurred during swap chain image acquisition!\n" );
+        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
+      &image_available_semaphore,                   // 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
+      &rendering_finished_semaphore                 // 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
+      &rendering_finished_semaphore,                // 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:
+        printf( "Problem occurred during image presentation!\n" );
+        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.FramebufferObjects.size(); ++i ) {
+        if( Vulkan.FramebufferObjects[i].Handle != VK_NULL_HANDLE ) {
+          vkDestroyFramebuffer( GetDevice(), Vulkan.FramebufferObjects[i].Handle, nullptr );
+          Vulkan.FramebufferObjects[i].Handle = VK_NULL_HANDLE;
+        }
+
+        if( Vulkan.FramebufferObjects[i].ImageView != VK_NULL_HANDLE ) {
+          vkDestroyImageView( GetDevice(), Vulkan.FramebufferObjects[i].ImageView, nullptr );
+          Vulkan.FramebufferObjects[i].ImageView = VK_NULL_HANDLE;
+        }
+      }
+      Vulkan.FramebufferObjects.clear();
+    }
+  }
+
+  Tutorial03::~Tutorial03() {
+    ChildClear();
+  }
+
+} // namespace Tutorial

Project/Tutorial03/Tutorial03.h

@@ -0,0 +1,82 @@
+// 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.
+
+#if !defined(TUTORIAL_03_HEADER)
+#define TUTORIAL_03_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace Tutorial {
+
+  // ************************************************************ //
+  // FramebufferObject                                            //
+  //                                                              //
+  // Vulkan Framebuffer's parameters container class              //
+  // ************************************************************ //
+  struct FramebufferParameters {
+    VkImageView     ImageView;
+    VkFramebuffer   Handle;
+  };
+
+  // ************************************************************ //
+  // VulkanTutorial03Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial03Parameters {
+    VkRenderPass                        RenderPass;
+    std::vector<FramebufferParameters>  FramebufferObjects;
+    VkCommandPool                       GraphicsCommandPool;
+    std::vector<VkCommandBuffer>        GraphicsCommandBuffers;
+    VkPipeline                          GraphicsPipeline;
+
+    VulkanTutorial03Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      FramebufferObjects(),
+      GraphicsCommandPool( VK_NULL_HANDLE ),
+      GraphicsCommandBuffers(),
+      GraphicsPipeline( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial03                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial03 : public VulkanCommon {
+  public:
+    Tutorial03();
+    ~Tutorial03();
+
+    bool    CreateRenderPass();
+    bool    CreateFramebuffers();
+    bool    CreatePipeline();
+    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 Tutorial
+
+#endif // TUTORIAL_03_HEADER

Project/Tutorial03/main.cpp

@@ -0,0 +1,50 @@
+// 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.
+
+#include "Tutorial03.h"
+
+int main( int argc, char **argv ) {
+  OS::Window            window;
+  Tutorial::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.CreateCommandBuffers() ) {
+    return -1;
+  }
+  if( !tutorial03.RecordCommandBuffers() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial03 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/Tutorial04/Data04/frag.spv.txt

@@ -0,0 +1,36 @@
+shader.frag
+Warning, version 430 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 430
+                              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/Tutorial04/Data04/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 430
+
+layout(location = 0) in vec4 v_Color;
+
+layout(location = 0) out vec4 o_Color;
+
+void main() {
+  o_Color = v_Color;
+}

Project/Tutorial04/Data04/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 430
+
+layout(location = 0) in vec4 i_Position;
+layout(location = 1) in vec4 i_Color;
+
+layout(location = 0) out vec4 v_Color;
+
+void main() {
+    gl_Position = i_Position;
+    v_Color = i_Color;
+}

Project/Tutorial04/Data04/vert.spv.txt

@@ -0,0 +1,59 @@
+shader.vert
+Warning, version 430 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
+                              Capability ClipDistance
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Vertex 4  "main" 13 17 21 22
+                              Source GLSL 430
+                              Name 4  "main"
+                              Name 11  "gl_PerVertex"
+                              MemberName 11(gl_PerVertex) 0  "gl_Position"
+                              MemberName 11(gl_PerVertex) 1  "gl_PointSize"
+                              MemberName 11(gl_PerVertex) 2  "gl_ClipDistance"
+                              Name 13  ""
+                              Name 17  "i_Position"
+                              Name 21  "v_Color"
+                              Name 22  "i_Color"
+                              MemberDecorate 11(gl_PerVertex) 0 BuiltIn Position
+                              MemberDecorate 11(gl_PerVertex) 1 BuiltIn PointSize
+                              MemberDecorate 11(gl_PerVertex) 2 BuiltIn ClipDistance
+                              Decorate 11(gl_PerVertex) Block
+                              Decorate 17(i_Position) Location 0
+                              Decorate 21(v_Color) Location 0
+                              Decorate 22(i_Color) Location 1
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 32
+               7:             TypeVector 6(float) 4
+               8:             TypeInt 32 0
+               9:      8(int) Constant 1
+              10:             TypeArray 6(float) 9
+11(gl_PerVertex):             TypeStruct 7(fvec4) 6(float) 10
+              12:             TypePointer Output 11(gl_PerVertex)
+              13:     12(ptr) Variable Output
+              14:             TypeInt 32 1
+              15:     14(int) Constant 0
+              16:             TypePointer Input 7(fvec4)
+  17(i_Position):     16(ptr) Variable Input
+              19:             TypePointer Output 7(fvec4)
+     21(v_Color):     19(ptr) Variable Output
+     22(i_Color):     16(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+              18:    7(fvec4) Load 17(i_Position)
+              20:     19(ptr) AccessChain 13 15
+                              Store 20 18
+              23:    7(fvec4) Load 22(i_Color)
+                              Store 21(v_Color) 23
+                              Return
+                              FunctionEnd

Project/Tutorial04/Tutorial04.cpp

@@ -0,0 +1,918 @@
+// 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.
+
+#include "Tutorial04.h"
+#include "VulkanFunctions.h"
+
+namespace Tutorial {
+
+  Tutorial04::Tutorial04() :
+    Vulkan() {
+  }
+
+  bool Tutorial04::CreateRenderPass() {
+    VkAttachmentDescription attachment_descriptions[] = {
+      {
+        0,                                          // VkAttachmentDescriptionFlags   flags
+        Vulkan.Image.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_TRANSFER_SRC_OPTIMAL,       // VkImageLayout                  initialLayout;
+        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL        // 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 ) {
+      printf( "Could not create render pass!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial04::CreateImage() {
+    VkImageCreateInfo image_create_info = {
+      VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,          //  VkStructureType           sType
+      nullptr,                                      // const void                *pNext
+      0,                                            // VkImageCreateFlags         flags
+      VK_IMAGE_TYPE_2D,                             // VkImageType                imageType
+      Vulkan.Image.Format,                          // VkFormat                   format
+      {                                             // VkExtent3D                 extent
+        300,                                          // uint32_t                   width
+        300,                                          // uint32_t                   height
+        1                                             // uint32_t                   depth
+      },
+      1,                                            // uint32_t                   mipLevels
+      1,                                            // uint32_t                   arrayLayers
+      VK_SAMPLE_COUNT_1_BIT,                        // VkSampleCountFlagBits      samples
+      VK_IMAGE_TILING_OPTIMAL,                      // VkImageTiling              tiling
+      VK_IMAGE_USAGE_TRANSFER_SRC_BIT |             // VkImageUsageFlags          usage
+      VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+      VK_SHARING_MODE_EXCLUSIVE,                    // VkSharingMode              sharingMode
+      0,                                            // uint32_t                   queueFamilyIndexCount
+      nullptr,                                      // const uint32_t            *pQueueFamilyIndices
+      VK_IMAGE_LAYOUT_UNDEFINED                     // VkImageLayout              initialLayout
+    };
+
+    if( vkCreateImage( GetDevice(), &image_create_info, nullptr, &Vulkan.Image.Handle ) != VK_SUCCESS ) {
+      printf( "Could not create an image!\n" );
+      return false;
+    }
+
+    if( !AllocateImageMemory( Vulkan.Image.Handle, &Vulkan.Image.Memory ) ) {
+      printf( "Could not allocate memory for an image!\n" );
+      return false;
+    }
+
+    if( vkBindImageMemory( GetDevice(), Vulkan.Image.Handle, Vulkan.Image.Memory, 0 ) != VK_SUCCESS ) {
+      printf( "Could not bind memory for an image!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial04::AllocateImageMemory( VkImage image, VkDeviceMemory *memory ) {
+    VkMemoryRequirements image_memory_requirements;
+    vkGetImageMemoryRequirements( GetDevice(), Vulkan.Image.Handle, &image_memory_requirements );
+
+    VkPhysicalDeviceMemoryProperties memory_properties;
+    vkGetPhysicalDeviceMemoryProperties( GetPhysicalDevice(), &memory_properties );
+
+    for( uint32_t i = 0; i < memory_properties.memoryTypeCount; ++i ) {
+      if( image_memory_requirements.memoryTypeBits & (1 << i) ) {
+
+        VkMemoryAllocateInfo memory_allocate_info = {
+          VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,   // VkStructureType            sType
+          nullptr,                                  // const void                *pNext
+          image_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::CreateFramebuffer() {
+    VkImageViewCreateInfo image_view_create_info = {
+      VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,   // VkStructureType                sType
+      nullptr,                                    // const void                    *pNext
+      0,                                          // VkImageViewCreateFlags         flags
+      Vulkan.Image.Handle,                        // VkImage                        image
+      VK_IMAGE_VIEW_TYPE_2D,                      // VkImageViewType                viewType
+      Vulkan.Image.Format,                        // VkFormat                       format
+      {                                           // VkComponentMapping             components
+        VK_COMPONENT_SWIZZLE_IDENTITY,              // VkComponentSwizzle             r
+        VK_COMPONENT_SWIZZLE_IDENTITY,              // VkComponentSwizzle             g
+        VK_COMPONENT_SWIZZLE_IDENTITY,              // VkComponentSwizzle             b
+        VK_COMPONENT_SWIZZLE_IDENTITY               // VkComponentSwizzle             a
+      },
+      {                                           // VkImageSubresourceRange        subresourceRange
+        VK_IMAGE_ASPECT_COLOR_BIT,                  // VkImageAspectFlags             aspectMask
+        0,                                          // uint32_t                       baseMipLevel
+        1,                                          // uint32_t                       levelCount
+        0,                                          // uint32_t                       baseArrayLayer
+        1                                           // uint32_t                       layerCount
+      }
+    };
+
+    if( vkCreateImageView( GetDevice(), &image_view_create_info, nullptr, &Vulkan.Image.View ) != VK_SUCCESS ) {
+      printf( "Could not create an image view!\n" );
+      return false;
+    }
+
+    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
+      &Vulkan.Image.View,                         // const VkImageView             *pAttachments
+      300,                                        // uint32_t                       width
+      300,                                        // uint32_t                       height
+      1                                           // uint32_t                       layers
+    };
+
+    if( vkCreateFramebuffer( GetDevice(), &framebuffer_create_info, nullptr, &Vulkan.Framebuffer ) != VK_SUCCESS ) {
+      printf( "Could not create a framebuffer!\n" );
+      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 ) {
+      printf( "Could not create shader module from a %s file!\n", filename );
+      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 ) {
+      printf( "Could not create pipeline layout!\n" );
+      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( "Data04/vert.spv" );
+    Tools::AutoDeleter<VkShaderModule, PFN_vkDestroyShaderModule> fragment_shader_module = CreateShaderModule( "Data04/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
+      }
+    };
+
+    VkVertexInputBindingDescription vertex_binding_description = {
+      0,                                                            // uint32_t                                       binding
+      sizeof(VertexData),                                           // uint32_t                                       stride
+      VK_VERTEX_INPUT_RATE_VERTEX                                   // VkVertexInputRate                              inputRate
+    };
+
+    VkVertexInputAttributeDescription vertex_attribute_descriptions[] = {
+      {
+        0,                                                          // uint32_t                                       location
+        vertex_binding_description.binding,                         // uint32_t                                       binding
+        VK_FORMAT_R32G32B32A32_SFLOAT,                              // VkFormat                                       format
+        0                                                           // uint32_t                                       offset
+      },
+      {
+        1,                                                          // uint32_t                                       location
+        vertex_binding_description.binding,                         // uint32_t                                       binding
+        VK_FORMAT_R32G32B32A32_SFLOAT,                              // VkFormat                                       format
+        4 * sizeof(float)                                           // 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;
+      1,                                                            // uint32_t                                       vertexBindingDescriptionCount
+      &vertex_binding_description,                                  // const VkVertexInputBindingDescription         *pVertexBindingDescriptions
+      2,                                                            // uint32_t                                       vertexAttributeDescriptionCount
+      vertex_attribute_descriptions                                 // 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
+    };
+
+    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 ) {
+      printf( "Could not create graphics pipeline!\n" );
+      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 ) {
+      printf( "Could not create a vertex buffer!\n" );
+      return false;
+    }
+
+    if( !AllocateBufferMemory( Vulkan.VertexBuffer.Handle, &Vulkan.VertexBuffer.Memory ) ) {
+      printf( "Could not allocate memory for a vertex buffer!\n" );
+      return false;
+    }
+
+    if( vkBindBufferMemory( GetDevice(), Vulkan.VertexBuffer.Handle, Vulkan.VertexBuffer.Memory, 0 ) != VK_SUCCESS ) {
+      printf( "Could not bind memory for a vertex buffer!\n" );
+      return false;
+    }
+
+    void *vertex_buffer_memory_pointer;
+    if( vkMapMemory( GetDevice(), Vulkan.VertexBuffer.Memory, 0, Vulkan.VertexBuffer.Size, 0, &vertex_buffer_memory_pointer ) != VK_SUCCESS ) {
+      printf( "Could not map memory and upload data to a vertex buffer!\n" );
+      return false;
+    }
+
+    memcpy( vertex_buffer_memory_pointer, vertex_data, Vulkan.VertexBuffer.Size );
+
+    vkUnmapMemory( GetDevice(), Vulkan.VertexBuffer.Memory );
+
+    if( !CommitMemoryChanges( Vulkan.VertexBuffer.Handle, Vulkan.VertexBuffer.Size ) ) {
+      printf( "Could not setup a barrier for a vertex buffer!\n" );
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Tutorial04::AllocateBufferMemory( VkBuffer buffer, VkDeviceMemory *memory ) {
+    VkMemoryRequirements buffer_memory_requirements;
+    vkGetBufferMemoryRequirements( GetDevice(), Vulkan.VertexBuffer.Handle, &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::CommitMemoryChanges( VkBuffer buffer, VkDeviceSize size ) {
+    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
+    };
+
+    VkBufferMemoryBarrier barrier_from_host_write_to_attribute_read = {
+      VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,        // VkStructureType                      sType
+      nullptr,                                        // const void                          *pNext
+      VK_ACCESS_HOST_WRITE_BIT,                       // VkAccessFlags                        srcAccessMask
+      VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,            // VkAccessFlags                        dstAccessMask
+      GetGraphicsQueue().FamilyIndex,                 // uint32_t                             srcQueueFamilyIndex
+      GetGraphicsQueue().FamilyIndex,                 // uint32_t                             dstQueueFamilyIndex
+      buffer,                                         // VkBuffer                             buffer
+      0,                                              // VkDeviceSize                         offset
+      size                                            // VkDeviceSize                         size
+    };
+
+    vkBeginCommandBuffer( Vulkan.CopyingCommandBuffer, &command_buffer_begin_info );
+
+    vkCmdPipelineBarrier( Vulkan.CopyingCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1, &barrier_from_host_write_to_attribute_read, 0, nullptr );
+
+    if( vkEndCommandBuffer( Vulkan.CopyingCommandBuffer ) != VK_SUCCESS ) {
+      printf( "Could not record command with buffer barrier!\n" );
+      return false;
+    }
+
+    VkSubmitInfo submit_rendering_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
+      &Vulkan.CopyingCommandBuffer,                 // const VkCommandBuffer       *pCommandBuffers
+      0,                                            // uint32_t                     signalSemaphoreCount
+      nullptr                                       // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_rendering_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {
+      printf( "Error occured during submition of command buffer with vertex buffer barrier!!\n" );
+      return false;
+    }
+
+    vkDeviceWaitIdle( GetDevice() );
+
+    return true;
+  }
+
+  bool Tutorial04::CreateFence() {
+    VkFenceCreateInfo fence_create_info = {
+      VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,          // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      VK_FENCE_CREATE_SIGNALED_BIT                  // VkFenceCreateFlags           flags
+    };
+    if( vkCreateFence( GetDevice(), &fence_create_info, nullptr, &Vulkan.Fence ) != VK_SUCCESS ) {
+      printf( "Could not create a fence!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::CreateCommandBuffers() {
+    if( !CreateCommandPool( GetGraphicsQueue().FamilyIndex, &Vulkan.GraphicsCommandPool ) ) {
+      printf( "Could not create command pool!\n" );
+      return false;
+    }
+    if( !AllocateCommandBuffers( Vulkan.GraphicsCommandPool, 1, &Vulkan.RenderingCommandBuffer ) ) {
+      printf( "Could not allocate rendering command buffer!\n" );
+      return false;
+    }
+    if( !AllocateCommandBuffers( Vulkan.GraphicsCommandPool, 1, &Vulkan.CopyingCommandBuffer ) ) {
+      printf( "Could not allocate copying command buffer!\n" );
+      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
+      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::RecordRenderingCommandBuffer() {
+    VkCommandBufferBeginInfo command_buffer_begin_info = {
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                        sType
+      nullptr,                                        // const void                            *pNext
+      0,                                              // VkCommandBufferUsageFlags              flags
+      nullptr                                         // const VkCommandBufferInheritanceInfo  *pInheritanceInfo
+    };
+
+    vkBeginCommandBuffer( Vulkan.RenderingCommandBuffer, &command_buffer_begin_info );
+
+    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
+      Vulkan.Framebuffer,                             // 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.RenderingCommandBuffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE );
+
+    vkCmdBindPipeline( Vulkan.RenderingCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, Vulkan.GraphicsPipeline );
+
+    VkDeviceSize offset = 0;
+    vkCmdBindVertexBuffers( Vulkan.RenderingCommandBuffer, 0, 1, &Vulkan.VertexBuffer.Handle, &offset );
+
+    vkCmdDraw( Vulkan.RenderingCommandBuffer, 4, 1, 0, 0 );
+
+    vkCmdEndRenderPass( Vulkan.RenderingCommandBuffer );
+
+    if( vkEndCommandBuffer( Vulkan.RenderingCommandBuffer ) != VK_SUCCESS ) {
+      printf( "Could not record drawing command buffer!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::RecordCopyingCommandBuffer( VkImage swap_chain_image ) {
+    if( vkWaitForFences( GetDevice(), 1, &Vulkan.Fence, VK_FALSE, 1000000000 ) != VK_SUCCESS ) {
+      printf( "Waiting for fence takes too long!\n" );
+      return false;
+    }
+    vkResetFences( GetDevice(), 1, &Vulkan.Fence );
+
+    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( Vulkan.CopyingCommandBuffer, &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
+    };
+
+    VkImageMemoryBarrier barrier_from_present_to_transfer_dst = {
+      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
+      GetPresentQueue().FamilyIndex,                  // uint32_t                     srcQueueFamilyIndex
+      GetGraphicsQueue().FamilyIndex,                 // uint32_t                     dstQueueFamilyIndex
+      swap_chain_image,                               // VkImage                      image
+      image_subresource_range                         // VkImageSubresourceRange      subresourceRange
+    };
+
+    vkCmdPipelineBarrier( Vulkan.CopyingCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_transfer_dst );
+
+    VkImageCopy image_copy = {
+      {                                               // VkImageSubresourceLayers     srcSubresource
+        VK_IMAGE_ASPECT_COLOR_BIT,                      // VkImageAspectFlags           aspectMask
+        0,                                              // uint32_t                     mipLevel
+        0,                                              // uint32_t                     baseArrayLayer
+        1                                               // uint32_t                     layerCount
+      },
+      {                                               // VkOffset3D                   srcOffset
+        0,                                              // int32_t                      x
+        0,                                              // int32_t                      y
+        0                                               // int32_t                      z
+      },
+      {                                               // VkImageSubresourceLayers     dstSubresource
+        VK_IMAGE_ASPECT_COLOR_BIT,                      // VkImageAspectFlags           aspectMask
+        0,                                              // uint32_t                     mipLevel
+        0,                                              // uint32_t                     baseArrayLayer
+        1                                               // uint32_t                     layerCount
+      },
+      {                                               // VkOffset3D                   dstOffset
+        0,                                              // int32_t                      x
+        0,                                              // int32_t                      y
+        0                                               // int32_t                      z
+      },
+      {                                               // VkExtent3D                   extent
+        300,                                            // uint32_t                     width
+        300,                                            // uint32_t                     height
+        1                                               // uint32_t                     depth
+      }
+    };
+
+    vkCmdCopyImage( Vulkan.CopyingCommandBuffer, Vulkan.Image.Handle, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, swap_chain_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &image_copy );
+
+    VkImageMemoryBarrier barrier_from_transfer_dst_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
+      GetGraphicsQueue().FamilyIndex,                 // uint32_t                               srcQueueFamilyIndex
+      GetPresentQueue().FamilyIndex,                  // uint32_t                               dstQueueFamilyIndex
+      swap_chain_image,                               // VkImage                                image
+      image_subresource_range                         // VkImageSubresourceRange                subresourceRange
+    };
+
+    vkCmdPipelineBarrier( Vulkan.CopyingCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_transfer_dst_to_present );
+
+    if( vkEndCommandBuffer( Vulkan.CopyingCommandBuffer ) != VK_SUCCESS ) {
+      printf( "Could not record copying command buffer!\n" );
+      return false;
+    }
+    return true;
+  }
+
+  bool Tutorial04::ChildOnWindowSizeChanged() {
+    return true;
+  }
+
+  bool Tutorial04::Draw() {
+    VkSemaphore image_available_semaphore = GetImageAvailableSemaphore();
+    VkSemaphore rendering_finished_semaphore = GetRenderingFinishedSemaphore();
+    VkSwapchainKHR swap_chain = GetSwapChain().Handle;
+    uint32_t image_index;
+
+    VkResult result = vkAcquireNextImageKHR( GetDevice(), swap_chain, UINT64_MAX, image_available_semaphore, 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:
+        printf( "Problem occurred during swap chain image acquisition!\n" );
+        return false;
+    }
+
+    VkSubmitInfo submit_rendering_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
+      &Vulkan.RenderingCommandBuffer,               // const VkCommandBuffer       *pCommandBuffers
+      0,                                            // uint32_t                     signalSemaphoreCount
+      nullptr                                       // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_rendering_info, VK_NULL_HANDLE ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    if( !RecordCopyingCommandBuffer( GetSwapChain().Images[image_index] ) ) {
+      return false;
+    }
+
+    VkPipelineStageFlags wait_dst_stage_mask = VK_PIPELINE_STAGE_TRANSFER_BIT;
+    VkSubmitInfo submit_copying_info = {
+      VK_STRUCTURE_TYPE_SUBMIT_INFO,                // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      1,                                            // uint32_t                     waitSemaphoreCount
+      &image_available_semaphore,                   // const VkSemaphore           *pWaitSemaphores
+      &wait_dst_stage_mask,                         // const VkPipelineStageFlags  *pWaitDstStageMask;
+      1,                                            // uint32_t                     commandBufferCount
+      &Vulkan.CopyingCommandBuffer,                 // const VkCommandBuffer       *pCommandBuffers
+      1,                                            // uint32_t                     signalSemaphoreCount
+      &rendering_finished_semaphore                 // const VkSemaphore           *pSignalSemaphores
+    };
+
+    if( vkQueueSubmit( GetGraphicsQueue().Handle, 1, &submit_copying_info, Vulkan.Fence ) != VK_SUCCESS ) {
+      return false;
+    }
+
+    VkPresentInfoKHR present_info = {
+      VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,           // VkStructureType              sType
+      nullptr,                                      // const void                  *pNext
+      1,                                            // uint32_t                     waitSemaphoreCount
+      &rendering_finished_semaphore,                // 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:
+        printf( "Problem occurred during image presentation!\n" );
+        return false;
+    }
+
+    return true;
+  }
+
+  void Tutorial04::ChildClear() {
+  }
+
+  Tutorial04::~Tutorial04() {
+    if( GetDevice() != VK_NULL_HANDLE ) {
+      vkDeviceWaitIdle( GetDevice() );
+
+      if( Vulkan.RenderingCommandBuffer != VK_NULL_HANDLE ) {
+        vkFreeCommandBuffers( GetDevice(), Vulkan.GraphicsCommandPool, 1, &Vulkan.RenderingCommandBuffer );
+        Vulkan.RenderingCommandBuffer = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.CopyingCommandBuffer != VK_NULL_HANDLE ) {
+        vkFreeCommandBuffers( GetDevice(), Vulkan.GraphicsCommandPool, 1, &Vulkan.CopyingCommandBuffer );
+        Vulkan.CopyingCommandBuffer = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.GraphicsCommandPool != VK_NULL_HANDLE ) {
+        vkDestroyCommandPool( GetDevice(), Vulkan.GraphicsCommandPool, nullptr );
+        Vulkan.GraphicsCommandPool = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.Fence != VK_NULL_HANDLE ) {
+        vkDestroyFence( GetDevice(), Vulkan.Fence, nullptr );
+        Vulkan.Fence = 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.Framebuffer != VK_NULL_HANDLE ) {
+        vkDestroyFramebuffer( GetDevice(), Vulkan.Framebuffer, nullptr );
+        Vulkan.Framebuffer = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.Image.View != VK_NULL_HANDLE ) {
+        vkDestroyImageView( GetDevice(), Vulkan.Image.View, nullptr );
+        Vulkan.Image.View = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.Image.Handle != VK_NULL_HANDLE ) {
+        vkDestroyImage( GetDevice(), Vulkan.Image.Handle, nullptr );
+        Vulkan.Image.Handle = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.Image.Memory != VK_NULL_HANDLE ) {
+        vkFreeMemory( GetDevice(), Vulkan.Image.Memory, nullptr );
+        Vulkan.Image.Memory = VK_NULL_HANDLE;
+      }
+
+      if( Vulkan.RenderPass != VK_NULL_HANDLE ) {
+        vkDestroyRenderPass( GetDevice(), Vulkan.RenderPass, nullptr );
+        Vulkan.RenderPass = VK_NULL_HANDLE;
+      }
+    }
+  }
+
+} // namespace Tutorial

Project/Tutorial04/Tutorial04.h

@@ -0,0 +1,132 @@
+// 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.
+
+#if !defined(TUTORIAL_03_HEADER)
+#define TUTORIAL_03_HEADER
+
+#include "VulkanCommon.h"
+#include "Tools.h"
+
+namespace Tutorial {
+
+  // ************************************************************ //
+  // ImageParameters                                              //
+  //                                                              //
+  // Vulkan Image's parameters container class                    //
+  // ************************************************************ //
+  struct ImageParameters {
+    VkFormat                        Format;
+    VkImage                         Handle;
+    VkDeviceMemory                  Memory;
+    VkImageView                     View;
+
+    ImageParameters() :
+      Format( VK_FORMAT_R8G8B8A8_UNORM ),
+      Handle( VK_NULL_HANDLE ),
+      Memory( VK_NULL_HANDLE ),
+      View( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // 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;
+  };
+
+  // ************************************************************ //
+  // VulkanTutorial04Parameters                                   //
+  //                                                              //
+  // Vulkan specific parameters                                   //
+  // ************************************************************ //
+  struct VulkanTutorial04Parameters {
+    VkRenderPass                    RenderPass;
+    ImageParameters                 Image;
+    VkFramebuffer                   Framebuffer;
+    VkPipeline                      GraphicsPipeline;
+    BufferParameters                VertexBuffer;
+    VkFence                         Fence;
+    VkCommandPool                   GraphicsCommandPool;
+    VkCommandBuffer                 RenderingCommandBuffer;
+    VkCommandBuffer                 CopyingCommandBuffer;
+
+    VulkanTutorial04Parameters() :
+      RenderPass( VK_NULL_HANDLE ),
+      Image(),
+      GraphicsPipeline( VK_NULL_HANDLE ),
+      VertexBuffer(),
+      Fence( VK_NULL_HANDLE ),
+      GraphicsCommandPool( VK_NULL_HANDLE ),
+      RenderingCommandBuffer( VK_NULL_HANDLE ),
+      CopyingCommandBuffer( VK_NULL_HANDLE ) {
+    }
+  };
+
+  // ************************************************************ //
+  // Tutorial04                                                   //
+  //                                                              //
+  // Class for presenting Vulkan usage topics                     //
+  // ************************************************************ //
+  class Tutorial04 : public VulkanCommon {
+  public:
+    Tutorial04();
+    ~Tutorial04();
+
+    bool    CreateRenderPass();
+    bool    CreateImage();
+    bool    CreateFramebuffer();
+    bool    CreatePipeline();
+    bool    CreateVertexBuffer();
+    bool    CreateFence();
+    bool    CreateCommandBuffers();
+    bool    RecordRenderingCommandBuffer();
+
+    bool    Draw() override;
+
+  private:
+    VulkanTutorial04Parameters  Vulkan;
+
+    bool                                                              AllocateImageMemory( VkImage image, VkDeviceMemory *memory );
+    bool                                                              AllocateBufferMemory( VkBuffer buffer, VkDeviceMemory *memory );
+    bool                                                              CommitMemoryChanges( VkBuffer buffer, VkDeviceSize size );
+    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 );
+    bool                                                              RecordCopyingCommandBuffer( VkImage swap_chain_image );
+
+    void                                                              ChildClear() override;
+    bool                                                              ChildOnWindowSizeChanged() override;
+  };
+
+} // namespace Tutorial
+
+#endif // TUTORIAL_03_HEADER

Project/Tutorial04/main.cpp

@@ -0,0 +1,59 @@
+// 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.
+
+#include "Tutorial04.h"
+
+int main( int argc, char **argv ) {
+  OS::Window            window;
+  Tutorial::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.CreateImage() ) {
+    return -1;
+  }
+  if( !tutorial04.CreateFramebuffer() ) {
+    return -1;
+  }
+  if( !tutorial04.CreatePipeline() ) {
+    return -1;
+  }
+  if( !tutorial04.CreateCommandBuffers( ) ) {
+    return -1;
+  }
+  if( !tutorial04.CreateVertexBuffer() ) {
+    return -1;
+  }
+  if( !tutorial04.CreateFence() ) {
+    return -1;
+  }
+  if( !tutorial04.RecordRenderingCommandBuffer() ) {
+    return -1;
+  }
+
+  // Rendering loop
+  if( !window.RenderingLoop( tutorial04 ) ) {
+    return -1;
+  }
+
+  return 0;
+}

Project/build.bat

@@ -0,0 +1,22 @@
+@ECHO OFF
+
+REM Copyright 2016 Intel Corporation All Rights Reserved
+REM 
+REM Intel makes no representations about the suitability of this software for any purpose.
+REM THIS SOFTWARE IS PROVIDED ""AS IS."" INTEL SPECIFICALLY DISCLAIMS ALL WARRANTIES,
+REM EXPRESS OR IMPLIED, AND ALL LIABILITY, INCLUDING CONSEQUENTIAL AND OTHER INDIRECT DAMAGES,
+REM FOR THE USE OF THIS SOFTWARE, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PROPRIETARY
+REM RIGHTS, AND INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+REM Intel does not assume any responsibility for any errors which may appear in this software
+REM nor any responsibility to update it.
+
+echo Preparing 'IntroductionToVulkan' solution...
+
+mkdir build
+cd build
+
+cmake.exe .. -DUSE_PLATFORM=VK_USE_PLATFORM_WIN32_KHR -G "Visual Studio 12 2013 Win64"
+
+start "" "IntroductionToVulkan.sln"
+
+cd ..

Project/build.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+# 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.
+
+function build {
+  echo "Compiling 'IntroductionToVulkan' examples..."
+
+  mkdir build
+  cd build
+
+  if [ "$1" == "xcb" ]; then
+    USE_PLATFORM=VK_USE_PLATFORM_XCB_KHR
+  else
+    USE_PLATFORM=VK_USE_PLATFORM_XLIB_KHR
+  fi
+
+  if [ "$2" == "release" ]; then
+    BUILD_TYPE=release
+  else
+    BUILD_TYPE=debug
+  fi
+
+cmake ../ -DUSE_PLATFORM=$USE_PLATFORM -DCMAKE_BUILD_TYPE=$BUILD_TYPE && make -j 8 2> >(tee build.log 1>&2)
+
+cd ..
+}
+
+if [ "$1" != "xcb" ] && [ "$1" != "x11" ]; then
+  echo "Valid Usage: ./build.sh <platform> <build type>"
+  echo "             <platform>   - xcb | x11"
+  echo "             <build type> - release | debug (optional, default is debug)"
+else
+  build $1 $2
+fi
+

license.txt

@@ -0,0 +1,258 @@
+Code Samples License Agreement (Version December 2015)
+
+IMPORTANT - READ BEFORE COPYING, INSTALLING OR USING.  Do not copy, install or
+use the Materials (as defined below) provided under this license agreement
+("Agreement") from Intel Corporation ("Intel"), until you ("You") have carefully
+read the following terms and conditions. By copying, installing or otherwise
+using the Materials, You agree to be bound by the terms of this Agreement. If
+You do not agree to the terms of this Agreement, do not copy, install or use the
+Materials. 
+
+If You are agreeing to the terms and conditions of this Agreement on behalf of a
+company or other legal entity ("Legal Entity"), You represent and warrant that
+You have the legal authority to bind that Legal Entity to the Agreement, in
+which case, "You" or "Your" will mean such Legal Entity.
+
+By agreeing to this Agreement, You affirm that You are of legal age (18 years
+old or older) to enter into this Agreement.  If You are not of legal age You may
+not enter into this Agreement, and either Your parent, legal guardian or Legal
+Entity must agree to the terms and conditions of this Agreement and enter into
+this Agreement, in which case, "You" or "Your" will mean such parent, legal
+guardian, or Legal Entity.
+
+Third Party Programs (as defined below), even if included with the distribution
+of the Materials, are governed by separate third party license terms, including
+without limitation, open source software license terms. Such third party license
+terms (and not this Agreement) govern Your use of the Third Party Programs, and
+Intel is not liable for the Third Party Programs.
+
+1.  LICENSE DEFINITIONS: 
+
+"Licensed Patent Claims" means the claims of Intel's patents that are
+necessarily and directly infringed by the reproduction and distribution of the
+Materials that is authorized in Section 2 below, when the Materials are in its
+unmodified form as delivered by Intel to You and not modified or combined with
+anything else.  Licensed Patent Claims are only those claims that Intel can
+license without paying, or getting the consent of, a third party.
+
+"Materials" means Sample Source Code, Redistributables, and End-User
+Documentation but do not include Third Party Programs. 
+
+"Sample Source Code" means Source Code files that are identified as sample code
+and which may include example interface or application source code, and any
+updates, provided under this Agreement. 
+
+"Source Code" is defined as the software (and not documentation or text) portion
+of the Materials provided in human readable format, and includes modifications
+that You make or are made on Your behalf as expressly permitted under the terms
+of this Agreement.
+
+"Redistributables" means header, library, and dynamically linkable library
+files, and any updates, provided under this Agreement. 
+
+"Third Party Programs" (if any) are the third party software files that may be
+included with the Materials for the applicable software that include a separate
+third party license agreement in an attached text file.
+
+"End-User Documentation" means textual materials intended for end users relating
+to the Materials. 
+
+2.  LICENSE GRANT: 
+
+Subject to the terms and conditions of this Agreement, Intel grants You a
+non-exclusive, worldwide, non-assignable, royalty-free limited right and
+license:
+A. under its copyrights, to:
+   1) Copy, modify, and compile the Sample Source Code and distribute it solely
+      in Your products in executable and source code form;
+   2) Copy and distribute the Redistributables solely with Your products;
+   3) Copy, modify, and distribute the End User Documentation solely with Your
+      products. 
+
+B. Under its patents, to:
+   1) make copies of the Materials internally only;
+   2) use the Materials internally only; and 3) offer to distribute, and
+      distribute, but not sell, the Materials only as part of or with Your
+      products, under Intel's copyright license granted in Section 2(A) but only
+      under the terms of that copyright license and not as a sale (but this
+      right does not include the right to sub-license);
+   4) provided, further, that the license under the Licensed Patent Claims does
+      not and will not apply to any modifications to, or derivative works of,
+      the Materials, whether made by You, Your end user (which, for all purposes
+      under this Agreement, will mean either an end user, a customer, reseller,
+      distributor or other channel partner), or any third party even if the
+      modification and creation of derivative works are permitted under 2(A).
+
+3.  LICENSE RESTRICTIONS: 
+
+Except as expressly provided in this Agreement, You may not:
+i.    use, copy, distribute or publicly display the Materials;
+ii.   reverse-assemble, reverse-compile, or otherwise reverse-engineer any
+      software provided solely in binary form,
+iii.  rent or lease the Materials to any third party;
+iv.   assign this Agreement or display the Materials;
+v.    assign this Agreement or transfer the Materials;
+vi.   modify, adapt or translate the Materials in whole or in part;
+vii.  distribute, sublicense or transfer the source code form of the Materials
+      or derivatives thereof to any third party;
+viii. distribute the Materials except as part of Your products;
+ix.   include the Materials in malicious, deceptive, or unlawful programs or
+      products;
+x.    modify, create a derivative work, link or distribute the Materials so that
+      any part of it becomes subject to an Excluded License. 
+
+Upon Intel's release of an update, upgrade, or new version of the Materials, you
+will make reasonable efforts to discontinue distribution of the enclosed
+Materials and you will make reasonable efforts to distribute such updates,
+upgrades, or new versions to your customers who have received the Materials
+herein. 
+
+Distribution of the Materials is also subject to the following limitations.
+You:
+i.    will be solely responsible to your customers for any update or support
+      obligation or other liability which may arise from the distribution;
+ii.   will not make any statement that your product is "certified", or that its
+      performance is guaranteed, by Intel;
+iii.  will not use Intel's name or trademarks to market your product without
+      written permission;
+iv.   will prohibit disassembly and reverse engineering of the Materials
+      provided in executable form;
+v.    will not publish reviews of Materials without written permission by Intel,
+      and
+vi.   will indemnify, hold harmless, and defend Intel and its suppliers from and
+      against any claims or lawsuits, including attorney's fees, that arise or
+      result from your distribution of any product.
+
+4. OWNERSHIP:
+
+Title to the Materials and all copies thereof remain with Intel or its
+suppliers. The Materials are copyrighted and are protected by United States
+copyright laws and international treaty provisions. You will not remove any
+copyright notice from the Materials. You agree to prevent unauthorized copying
+of the Materials. Except as expressly provided herein, Intel does not grant any
+express or implied right to you under Intel patents, copyrights, trademarks, or
+trade secret information. 
+
+5. NO WARRANTY AND NO SUPPORT:
+
+Disclaimer.  Intel disclaims all warranties of any kind and the terms and
+remedies provided in this Agreement are instead of any other warranty or
+condition, express, implied or statutory, including those regarding
+merchantability, fitness for any particular purpose, non-infringement or any
+warranty arising out of any course of dealing, usage of trade, proposal,
+specification or sample.  Intel does not assume (and does not authorize any
+person to assume on its behalf) any other liability.
+
+Intel may make changes to the Materials, or to items referenced therein, at any
+time without notice, but is not obligated to support, update or provide training
+for the Materials. Intel may in its sole discretion offer such support, update
+or training services under separate terms at Intel's then-current rates. You
+may request additional information on Intel's service offerings from an Intel
+sales representative. 
+
+6. USER SUBMISSIONS:
+
+You agree that any material, information, or other communication, including all
+data, images, sounds, text, and other things embodied therein, you transmit or
+post to an Intel website will be considered non-confidential ("Communications").
+Intel will have no confidentiality obligations with respect to the
+Communications. You agree that Intel and its designees will be free to copy,
+modify, create derivative works, publicly display, disclose, distribute, license
+and sublicense through multiple tiers of distribution and licensees,
+incorporate, and otherwise use the Communications, including derivative works
+thereto, for any and all commercial or non-commercial purposes. 
+
+7.LIMITATION OF LIABILITY:
+
+Neither Intel nor its suppliers shall be liable for any damages whatsoever
+(including, without limitation, damages for loss of business profits, business
+interruption, loss of business information, or other loss) arising out of the
+use of or inability to use the Materials, even if Intel has been advised of the
+possibility of such damages.  Because some jurisdictions prohibit the exclusion
+or limitation of liability for consequential or incidental damages, the above
+limitation may not apply to You.
+
+8. TERM AND TERMINATION: 
+
+This Agreement commences upon Your copying, installing or using the Materials
+and continues until terminated.  Either You or Intel may terminate this
+Agreement at any time upon 30 days prior written notice to the other party.
+Intel may terminate this license at any time if you are in breach of any of its
+terms and conditions. Upon termination, You will immediately destroy the
+Materials or return all copies of the Materials to Intel along with any copies
+You have made. After termination, the license grant to any Materials or
+Redistributables distributed by You in accordance with the terms and conditions
+of this Agreement, prior to the effective date of such termination, will survive
+any such termination of this Agreement. 
+
+9. U.S. GOVERNMENT RESTRICTED RIGHTS:
+
+The technical data and computer software covered by this license is a
+"Commercial Item", as such term is defined by the FAR 2.101 (48 C.F.R. 2.101)
+and is "commercial computer software" and "commercial computer software
+documentation" as specified under FAR 12.212 (48 C.F.R. 12.212) or DFARS
+227.7202 (48 C.F.R. 227.7202), as applicable. This commercial computer software
+and related documentation is provided to end users for use by and on behalf of
+the U.S. Government, with only those rights as are granted to all other end
+users pursuant to the terms and conditions herein. Use for or on behalf of the
+U.S. Government is permitted only if the party acquiring or using this software
+is properly authorized by an appropriate U.S. Government official. This use by
+or for the U.S. Government clause is in lieu of, and supersedes, any other FAR,
+DFARS, or other provision that addresses Government rights in the computer
+software or documentation covered by this license.  All copyright licenses
+granted to the U.S. Government are coextensive with the technical data and
+computer software licenses granted herein. The U.S. Government will only have
+the right to reproduce, distribute, perform, display, and prepare derivative
+works as needed to implement those rights. 
+
+10. APPLICABLE LAWS:
+
+All disputes arising out of or related to this Agreement, whether based on
+contract, tort, or any other legal or equitable theory, will in all respects be
+governed by, and construed and interpreted under, the laws of the United States
+of America and the State of Delaware, without reference to conflict of laws
+principles. The parties agree that the United Nations Convention on Contracts
+for the International Sale of Goods (1980) is specifically excluded from and
+will not apply to this Agreement. All disputes arising out of or related to this
+Agreement, whether based on contract, tort, or any other legal or equitable
+theory, will be subject to the exclusive jurisdiction of the courts of the State
+of Delaware or of the Federal courts sitting in that State. Each party submits
+to the personal jurisdiction of those courts and waives all objections to that
+jurisdiction and venue for those disputes.    
+
+10. SEVERABILITY:
+
+The parties intend that if a court holds that any provision or part of this
+Agreement is invalid or unenforceable under applicable law, the court will
+modify the provision to the minimum extent necessary to make it valid and
+enforceable, or if it cannot be made valid and enforceable, the parties intend
+that the court will sever and delete the provision or part from this Agreement.
+Any change to or deletion of a provision or part of this Agreement under this
+Section will not affect the validity or enforceability of the remainder of this
+Agreement, which will continue in full force and effect.
+
+11. EXPORT:
+
+You must comply with all laws and regulations of the United States and other
+countries governing the export, re-export, import, transfer, distribution, use,
+and servicing of Software.  In particular, You must not: (a) sell or transfer
+Software to a country subject to sanctions, or to any entity listed on a denial
+order published by the United States government or any other relevant
+government; or (b) use, sell, or transfer Software for the development, design,
+manufacture, or production of nuclear, missile, chemical or biological weapons,
+or for any other purpose prohibited by the United States government or other
+applicable government; without first obtaining all authorizations required by
+all applicable laws.  For more details on Your export obligations, please visit
+http://www.intel.com/content/www/us/en/legal/export-compliance.html?wapkw=export.
+
+12. ENTIRE AGREEMENT:
+
+This Agreement contains the complete and exclusive agreement and understanding
+between the parties concerning the subject matter of this Agreement, and
+supersedes all prior and contemporaneous proposals, agreements, understanding,
+negotiations, representations, warranties, conditions, and communications, oral
+or written, between the parties relating to the same subject matter. No
+modification or amendment to this Agreement will be effective unless in writing
+and signed by authorized representatives of each party, and must specifically
+identify this Agreement.
+