diff --git a/Project/CMakeLists.txt b/Project/CMakeLists.txt new file mode 100644 index 0000000..c4f4142 --- /dev/null +++ b/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 ) \ No newline at end of file diff --git a/Project/Common/ListOfFunctions.inl b/Project/Common/ListOfFunctions.inl new file mode 100644 index 0000000..274dbcc --- /dev/null +++ b/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 \ No newline at end of file diff --git a/Project/Common/OperatingSystem.cpp b/Project/Common/OperatingSystem.cpp new file mode 100644 index 0000000..348d543 --- /dev/null +++ b/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(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 \ No newline at end of file diff --git a/Project/Common/OperatingSystem.h b/Project/Common/OperatingSystem.h new file mode 100644 index 0000000..9b4cab9 --- /dev/null +++ b/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 + +#elif defined(VK_USE_PLATFORM_XCB_KHR) +#include +#include +#include +#include + +#elif defined(VK_USE_PLATFORM_XLIB_KHR) +#include +#include +#include +#include +#include + +#endif + +#include + +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 \ No newline at end of file diff --git a/Project/Common/Tools.cpp b/Project/Common/Tools.cpp new file mode 100644 index 0000000..47d33a4 --- /dev/null +++ b/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 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(); + } + + std::streampos begin, end; + begin = file.tellg(); + file.seekg( 0, std::ios::end ); + end = file.tellg(); + + std::vector result( static_cast(end - begin) ); + file.seekg( 0, std::ios::beg ); + file.read( &result[0], end - begin ); + file.close(); + + return result; + } + +} \ No newline at end of file diff --git a/Project/Common/Tools.h b/Project/Common/Tools.h new file mode 100644 index 0000000..95acd8a --- /dev/null +++ b/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 +#include +#include +#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 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 GetBinaryFileContents( std::string const &filename ); + +} + + +#endif // TOOLS_HEADER \ No newline at end of file diff --git a/Project/Common/VulkanCommon.cpp b/Project/Common/VulkanCommon.cpp new file mode 100644 index 0000000..c603b00 --- /dev/null +++ b/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 +#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 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 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(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 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 queue_create_infos; + std::vector 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(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(queue_priorities.size( )), // uint32_t queueCount + &queue_priorities[0] // const float *pQueuePriorities + } ); + } + + std::vector 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(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 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 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 queue_family_properties( queue_families_count ); + std::vector 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 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 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(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 &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 &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 &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 \ No newline at end of file diff --git a/Project/Common/VulkanCommon.h b/Project/Common/VulkanCommon.h new file mode 100644 index 0000000..c10d6a5 --- /dev/null +++ b/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 +#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 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 &available_extensions ); + uint32_t GetSwapChainNumImages( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkSurfaceFormatKHR GetSwapChainFormat( std::vector &surface_formats ); + VkExtent2D GetSwapChainExtent( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkImageUsageFlags GetSwapChainUsageFlags( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkSurfaceTransformFlagBitsKHR GetSwapChainTransform( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkPresentModeKHR GetSwapChainPresentMode( std::vector &present_modes ); + }; + +} // namespace Tutorial + +#endif // VULKAN_COMMON_HEADER \ No newline at end of file diff --git a/Project/Common/VulkanFunctions.cpp b/Project/Common/VulkanFunctions.cpp new file mode 100644 index 0000000..bd19818 --- /dev/null +++ b/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" diff --git a/Project/Common/VulkanFunctions.h b/Project/Common/VulkanFunctions.h new file mode 100644 index 0000000..b8bc9a8 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/Project/Include/vk_platform.h b/Project/Include/vk_platform.h new file mode 100644 index 0000000..a53e725 --- /dev/null +++ b/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 + +#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 + #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 +#endif + +#ifdef VK_USE_PLATFORM_MIR_KHR +#include +#endif + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#include +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#include +#endif + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#include +#endif + +#ifdef VK_USE_PLATFORM_XCB_KHR +#include +#endif + +#endif // __VK_PLATFORM_H__ diff --git a/Project/Include/vulkan.h b/Project/Include/vulkan.h new file mode 100644 index 0000000..cd6a71a --- /dev/null +++ b/Project/Include/vulkan.h @@ -0,0 +1,3775 @@ +#ifndef __vulkan_h_ +#define __vulkan_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2015-2016 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. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + +// Vulkan API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 3) + +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) + +#define VK_NULL_HANDLE 0 + + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif + + + +typedef uint32_t VkFlags; +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkSampleMask; + +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + +#define VK_LOD_CLAMP_NONE 1000.0f +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_WHOLE_SIZE (~0ULL) +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_TRUE 1 +#define VK_FALSE 0 +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256 +#define VK_UUID_SIZE 16 +#define VK_MAX_MEMORY_TYPES 32 +#define VK_MAX_MEMORY_HEAPS 16 +#define VK_MAX_EXTENSION_NAME_SIZE 256 +#define VK_MAX_DESCRIPTION_SIZE 256 + + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1), + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED, + VK_RESULT_END_RANGE = VK_INCOMPLETE, + VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1), + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, + VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, + VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1), + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, + VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1), + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, + VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1), + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, + VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, + VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1), + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, + VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1), + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, + VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, + VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1), + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, + VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, + VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1), + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, + VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, + VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1), + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, + VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, + VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, + VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1), + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, + VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1), + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, + VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, + VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1), + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, + VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1), + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, + VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, + VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, + VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, + VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1), + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, + VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, + VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1), + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, + VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1), + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, + VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, + VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1), + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, + VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, + VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1), + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, + VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, + VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1), + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, + VK_FILTER_END_RANGE = VK_FILTER_LINEAR, + VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1), + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, + VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, + VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1), + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, + VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1), + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, + VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1), + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, + VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1), + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, + VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1), + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, + VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1), + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, + VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, + VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1), + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, + VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1), + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, + VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, + VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1), + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, + VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, + VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1), + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum VkSampleCountFlagBits { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; +typedef VkFlags VkDeviceCreateFlags; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; +typedef VkFlags VkEventCreateFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, +} VkShaderStageFlagBits; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x3, +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; +typedef VkFlags VkSamplerCreateFlags; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; +typedef VkFlags VkFramebufferCreateFlags; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FRONT_AND_BACK = 0x3, +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR void VKAPI_CALL vkFreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t x, + uint32_t y, + uint32_t z); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const uint32_t* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); +#endif + +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" + + +typedef enum VkColorSpaceKHR { + VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, + VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR, + VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1), + VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR, + VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), + VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPresentModeKHR; + + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, +} VkSurfaceTransformFlagBitsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; + +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 67 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); +#endif + +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + +#define VK_KHR_DISPLAY_SPEC_VERSION 21 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" + + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayModeCreateFlagsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" + +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#define VK_KHR_xlib_surface 1 +#include + +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" + +typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + +typedef struct VkXlibSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; +} VkXlibSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif +#endif /* VK_USE_PLATFORM_XLIB_KHR */ + +#ifdef VK_USE_PLATFORM_XCB_KHR +#define VK_KHR_xcb_surface 1 +#include + +#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" + +typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + +typedef struct VkXcbSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; +} VkXcbSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif +#endif /* VK_USE_PLATFORM_XCB_KHR */ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#define VK_KHR_wayland_surface 1 +#include + +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" + +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + +typedef struct VkWaylandSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; +} VkWaylandSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ + +#ifdef VK_USE_PLATFORM_MIR_KHR +#define VK_KHR_mir_surface 1 +#include + +#define VK_KHR_MIR_SURFACE_SPEC_VERSION 4 +#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface" + +typedef VkFlags VkMirSurfaceCreateFlagsKHR; + +typedef struct VkMirSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkMirSurfaceCreateFlagsKHR flags; + MirConnection* connection; + MirSurface* mirSurface; +} VkMirSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR( + VkInstance instance, + const VkMirSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + MirConnection* connection); +#endif +#endif /* VK_USE_PLATFORM_MIR_KHR */ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#define VK_KHR_android_surface 1 +#include + +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" + +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + +typedef struct VkAndroidSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAndroidSurfaceCreateFlagsKHR flags; + ANativeWindow* window; +} VkAndroidSurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_win32_surface 1 +#include + +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" + +typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + +typedef struct VkWin32SurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_EXT_debug_report 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 1 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" + + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, +} VkDebugReportObjectTypeEXT; + +typedef enum VkDebugReportErrorEXT { + VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, + VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, +} VkDebugReportErrorEXT; + + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Project/Tutorial01/Tutorial01.cpp b/Project/Tutorial01/Tutorial01.cpp new file mode 100644 index 0000000..30de215 --- /dev/null +++ b/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 +#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 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 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(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 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 \ No newline at end of file diff --git a/Project/Tutorial01/Tutorial01.h b/Project/Tutorial01/Tutorial01.h new file mode 100644 index 0000000..380c94e --- /dev/null +++ b/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 \ No newline at end of file diff --git a/Project/Tutorial01/main.cpp b/Project/Tutorial01/main.cpp new file mode 100644 index 0000000..b7119fb --- /dev/null +++ b/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; +} diff --git a/Project/Tutorial02/Tutorial02.cpp b/Project/Tutorial02/Tutorial02.cpp new file mode 100644 index 0000000..7fb1f53 --- /dev/null +++ b/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 +#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 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 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(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 &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 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 queue_create_infos; + std::vector 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(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(queue_priorities.size()), // uint32_t queueCount + &queue_priorities[0] // const float *pQueuePriorities + } ); + } + + std::vector 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(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 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 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 queue_family_properties( queue_families_count ); + std::vector 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 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 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(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 &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 &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(Vulkan.PresentQueueCmdBuffers.size()); + + std::vector 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(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 \ No newline at end of file diff --git a/Project/Tutorial02/Tutorial02.h b/Project/Tutorial02/Tutorial02.h new file mode 100644 index 0000000..39dd7ce --- /dev/null +++ b/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 +#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 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 &available_extensions ); + uint32_t GetSwapChainNumImages( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkSurfaceFormatKHR GetSwapChainFormat( std::vector &surface_formats ); + VkExtent2D GetSwapChainExtent( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkImageUsageFlags GetSwapChainUsageFlags( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkSurfaceTransformFlagBitsKHR GetSwapChainTransform( VkSurfaceCapabilitiesKHR &surface_capabilities ); + VkPresentModeKHR GetSwapChainPresentMode( std::vector &present_modes ); + }; + +} // namespace Tutorial + +#endif // TUTORIAL_02_HEADER \ No newline at end of file diff --git a/Project/Tutorial02/main.cpp b/Project/Tutorial02/main.cpp new file mode 100644 index 0000000..a77914b --- /dev/null +++ b/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; +} diff --git a/Project/Tutorial03/Data03/frag.spv b/Project/Tutorial03/Data03/frag.spv new file mode 100644 index 0000000..5651249 Binary files /dev/null and b/Project/Tutorial03/Data03/frag.spv differ diff --git a/Project/Tutorial03/Data03/frag.spv.txt b/Project/Tutorial03/Data03/frag.spv.txt new file mode 100644 index 0000000..523f110 --- /dev/null +++ b/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 diff --git a/Project/Tutorial03/Data03/shader.frag b/Project/Tutorial03/Data03/shader.frag new file mode 100644 index 0000000..ffe7a05 --- /dev/null +++ b/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 ); +} diff --git a/Project/Tutorial03/Data03/shader.vert b/Project/Tutorial03/Data03/shader.vert new file mode 100644 index 0000000..4b58e1f --- /dev/null +++ b/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 ); +} diff --git a/Project/Tutorial03/Data03/vert.spv b/Project/Tutorial03/Data03/vert.spv new file mode 100644 index 0000000..c16b07e Binary files /dev/null and b/Project/Tutorial03/Data03/vert.spv differ diff --git a/Project/Tutorial03/Data03/vert.spv.txt b/Project/Tutorial03/Data03/vert.spv.txt new file mode 100644 index 0000000..9e23a7f --- /dev/null +++ b/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 diff --git a/Project/Tutorial03/Tutorial03.cpp b/Project/Tutorial03/Tutorial03.cpp new file mode 100644 index 0000000..274ad8b --- /dev/null +++ b/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 &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 Tutorial03::CreateShaderModule( const char* filename ) { + const std::vector code = Tools::GetBinaryFileContents( filename ); + if( code.size() == 0 ) { + return Tools::AutoDeleter(); + } + + 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(&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(); + } + + return Tools::AutoDeleter( shader_module, vkDestroyShaderModule, GetDevice() ); + } + + Tools::AutoDeleter 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(); + } + + return Tools::AutoDeleter( pipeline_layout, vkDestroyPipelineLayout, GetDevice() ); + } + + bool Tutorial03::CreatePipeline() { + Tools::AutoDeleter vertex_shader_module = CreateShaderModule( "Data03/vert.spv" ); + Tools::AutoDeleter fragment_shader_module = CreateShaderModule( "Data03/frag.spv" ); + + if( !vertex_shader_module || !fragment_shader_module ) { + return false; + } + + std::vector 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 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(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(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& 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(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 \ No newline at end of file diff --git a/Project/Tutorial03/Tutorial03.h b/Project/Tutorial03/Tutorial03.h new file mode 100644 index 0000000..eb0e3dc --- /dev/null +++ b/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 FramebufferObjects; + VkCommandPool GraphicsCommandPool; + std::vector 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 CreateShaderModule( const char* filename ); + Tools::AutoDeleter 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 \ No newline at end of file diff --git a/Project/Tutorial03/main.cpp b/Project/Tutorial03/main.cpp new file mode 100644 index 0000000..b235e92 --- /dev/null +++ b/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; +} diff --git a/Project/Tutorial04/Data04/frag.spv b/Project/Tutorial04/Data04/frag.spv new file mode 100644 index 0000000..5601583 Binary files /dev/null and b/Project/Tutorial04/Data04/frag.spv differ diff --git a/Project/Tutorial04/Data04/frag.spv.txt b/Project/Tutorial04/Data04/frag.spv.txt new file mode 100644 index 0000000..209e57a --- /dev/null +++ b/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 diff --git a/Project/Tutorial04/Data04/shader.frag b/Project/Tutorial04/Data04/shader.frag new file mode 100644 index 0000000..3a86de5 --- /dev/null +++ b/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; +} diff --git a/Project/Tutorial04/Data04/shader.vert b/Project/Tutorial04/Data04/shader.vert new file mode 100644 index 0000000..1030cb3 --- /dev/null +++ b/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; +} diff --git a/Project/Tutorial04/Data04/vert.spv b/Project/Tutorial04/Data04/vert.spv new file mode 100644 index 0000000..55be53c Binary files /dev/null and b/Project/Tutorial04/Data04/vert.spv differ diff --git a/Project/Tutorial04/Data04/vert.spv.txt b/Project/Tutorial04/Data04/vert.spv.txt new file mode 100644 index 0000000..67ed30a --- /dev/null +++ b/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 diff --git a/Project/Tutorial04/Tutorial04.cpp b/Project/Tutorial04/Tutorial04.cpp new file mode 100644 index 0000000..e8e7471 --- /dev/null +++ b/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 Tutorial04::CreateShaderModule( const char* filename ) { + const std::vector code = Tools::GetBinaryFileContents( filename ); + if( code.size() == 0 ) { + return Tools::AutoDeleter(); + } + + 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(&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(); + } + + return Tools::AutoDeleter( shader_module, vkDestroyShaderModule, GetDevice() ); + } + + Tools::AutoDeleter 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(); + } + + return Tools::AutoDeleter( pipeline_layout, vkDestroyPipelineLayout, GetDevice() ); + } + + bool Tutorial04::CreatePipeline() { + Tools::AutoDeleter vertex_shader_module = CreateShaderModule( "Data04/vert.spv" ); + Tools::AutoDeleter fragment_shader_module = CreateShaderModule( "Data04/frag.spv" ); + + if( !vertex_shader_module || !fragment_shader_module ) { + return false; + } + + std::vector 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 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(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 \ No newline at end of file diff --git a/Project/Tutorial04/Tutorial04.h b/Project/Tutorial04/Tutorial04.h new file mode 100644 index 0000000..419c80c --- /dev/null +++ b/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 CreateShaderModule( const char* filename ); + Tools::AutoDeleter 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 \ No newline at end of file diff --git a/Project/Tutorial04/main.cpp b/Project/Tutorial04/main.cpp new file mode 100644 index 0000000..afe8fd8 --- /dev/null +++ b/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; +} diff --git a/Project/build.bat b/Project/build.bat new file mode 100644 index 0000000..c21443f --- /dev/null +++ b/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 .. \ No newline at end of file diff --git a/Project/build.sh b/Project/build.sh new file mode 100644 index 0000000..b501533 --- /dev/null +++ b/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 " + echo " - xcb | x11" + echo " - release | debug (optional, default is debug)" +else + build $1 $2 +fi + diff --git a/license.txt b/license.txt new file mode 100644 index 0000000..1bb870c --- /dev/null +++ b/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. +