5 years ago · cbd3f5795b
--- a/.gitignore
+++ b/.gitignore
 libs/
 obj/
 *.spv
 *.png
--- a/Android.mk
+++ b/Android.mk
 LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 PNG_DIR = external/libpng/src
 PNG_SRC_FILES = $(PNG_DIR)/png.c \
 	$(PNG_DIR)/pngerror.c \
 	$(PNG_DIR)/pngget.c \
 	$(PNG_DIR)/pngmem.c \
 	$(PNG_DIR)/pngpread.c \
 	$(PNG_DIR)/pngread.c \
 	$(PNG_DIR)/pngrio.c \
 	$(PNG_DIR)/pngrtran.c \
 	$(PNG_DIR)/pngrutil.c \
 	$(PNG_DIR)/pngset.c \
 	$(PNG_DIR)/pngtrans.c \
 	$(PNG_DIR)/pngwio.c \
 	$(PNG_DIR)/pngwrite.c \
 	$(PNG_DIR)/pngwtran.c \
 	$(PNG_DIR)/pngwutil.c \
 	$(PNG_DIR)/arm/arm_init.c  \
 	$(PNG_DIR)/arm/filter_neon_intrinsics.c
 ZLIB_DIR = external/zlib/src
 ZLIB_SRC_FILES = \
 	$(ZLIB_DIR)/adler32.c \
 	$(ZLIB_DIR)/compress.c \
 	$(ZLIB_DIR)/crc32.c \
 	$(ZLIB_DIR)/deflate.c \
 	$(ZLIB_DIR)/gzclose.c \
 	$(ZLIB_DIR)/gzlib.c \
 	$(ZLIB_DIR)/gzread.c \
 	$(ZLIB_DIR)/gzwrite.c \
 	$(ZLIB_DIR)/infback.c \
 	$(ZLIB_DIR)/inflate.c \
 	$(ZLIB_DIR)/inftrees.c \
 	$(ZLIB_DIR)/inffast.c \
 	$(ZLIB_DIR)/trees.c \
 	$(ZLIB_DIR)/uncompr.c \
 	$(ZLIB_DIR)/zutil.c
 NAME := triangle
 LOCAL_MODULE := $(NAME)
 LOCAL_SRC_FILES := $(PNG_SRC_FILES) $(ZLIB_SRC_FILES) $(NAME).cc
 LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
 LOCAL_CPP_INCLUDES := $(LOCAL_PATH)/include $(LOCAL_PATH)/external
 LOCAL_CFLAGS := -Wall
 LOCAL_CPPFLAGS  = -Wall -stdlib=libc++
 LOCAL_LDLIBS := -lvulkan
 include $(BUILD_EXECUTABLE)
--- a/Application.mk
+++ b/Application.mk
 APP_OPTIM := debug
 #APP_ABI := armeabi-v7a
 APP_ABI := arm64-v8a
 APP_STL := c++_static
 APP_CPPFLAGS := -frtti -fexceptions -std=c++14
 APP_PLATFORM := android-24
 APP_BUILD_SCRIPT := Android.mk
 NDK_TOOLCHAIN_VERSION := clang
--- a/Makefile
+++ b/Makefile
 NAME = triangle
 all: shaders build deploy run
 build:
 	@echo Building...
 	@./ndk-build.sh
 deploy:
 	@echo Deploying to device...
 	@adb push ${NAME}.vert.spv /data/vulkan/${NAME}/
 	@adb push ${NAME}.frag.spv /data/vulkan/${NAME}/
 	@adb push libs/arm64-v8a/${NAME} /data/vulkan/${NAME}/
 run:
 	@echo Running on device...
 	@adb shell "cd /data/vulkan/${NAME} && ./${NAME}"
 	@echo Copying artifacts back to local device...
 	@adb pull /data/vulkan/${NAME}/${NAME}.png .
 shaders:
 	@echo Compiling shaders...
 	@glslc -c ${NAME}.vert
 	@glslc -c ${NAME}.frag
 clean:
 	@rm -rf obj
 	@rm -rf libs
 	@rm -f ${NAME}.png
 	@rm -f ${NAME}.vert.spv
 	@rm -f ${NAME}.frag.spv
 	@adb shell rm /data/vulkan/${NAME}/*
--- a/external/libpng/.gitignore
+++ b/external/libpng/.gitignore
 src
 packages
--- a/external/libpng/CMakeLists.txt
+++ b/external/libpng/CMakeLists.txt
 # cmake file for libpng
 if (NOT DE_DEFS)
 	message(FATAL_ERROR "Include Defs.cmake")
 endif ()
 if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/png.h")
 	set(DEFAULT_PNG_SRC_PATH ${CMAKE_CURRENT_SOURCE_DIR}/src)
 else ()
 	# Assume build inside Android source tree
 	set(DEFAULT_PNG_SRC_PATH "../libpng")
 endif ()
 set(PNG_SRC_PATH ${DEFAULT_PNG_SRC_PATH} CACHE STRING "Path to libpng source tree")
 if (IS_ABSOLUTE ${PNG_SRC_PATH})
 	set(PNG_ABS_PATH ${PNG_SRC_PATH})
 else ()
 	set(PNG_ABS_PATH "${CMAKE_SOURCE_DIR}/${PNG_SRC_PATH}")
 endif ()
 set(PNG_SRCS
 	${PNG_ABS_PATH}/png.h
 	${PNG_ABS_PATH}/pngconf.h
 	${PNG_ABS_PATH}/png.c
 	${PNG_ABS_PATH}/pngset.c
 	${PNG_ABS_PATH}/pngget.c
 	${PNG_ABS_PATH}/pngrutil.c
 	${PNG_ABS_PATH}/pngtrans.c
 	${PNG_ABS_PATH}/pngwutil.c
 	${PNG_ABS_PATH}/pngread.c
 	${PNG_ABS_PATH}/pngrio.c
 	${PNG_ABS_PATH}/pngwio.c
 	${PNG_ABS_PATH}/pngwrite.c
 	${PNG_ABS_PATH}/pngrtran.c
 	${PNG_ABS_PATH}/pngwtran.c
 	${PNG_ABS_PATH}/pngmem.c
 	${PNG_ABS_PATH}/pngerror.c
 	${PNG_ABS_PATH}/pngpread.c
 	)
 if (DE_CPU_IS_ARM_64)
 	# armv8-a has always neon
 	set(PNG_SRCS
 		${PNG_SRCS}
 		${PNG_ABS_PATH}/arm/arm_init.c
 		${PNG_ABS_PATH}/arm/filter_neon_intrinsics.c
 		${PNG_ABS_PATH}/arm/filter_neon.S
 		)
 endif ()
 if (DE_DEBUG EQUAL 1)
 	add_definitions(-DPNG_DEBUG)
 endif ()
 if (DE_OS_IS_UNIX)
 	# for snprintf()
 	add_definitions(-D_XOPEN_SOURCE=600)
 endif ()
 set(CMAKE_C_FLAGS ${DE_3RD_PARTY_C_FLAGS})
 add_library(png STATIC ${PNG_SRCS})
 target_link_libraries(png ${ZLIB_LIBRARY})
 set(PNG_INCLUDE_PATH	${PNG_ABS_PATH}	PARENT_SCOPE)
 set(PNG_LIBRARY			png				PARENT_SCOPE)
--- a/external/zlib/.gitignore
+++ b/external/zlib/.gitignore
 src
 packages
--- a/external/zlib/CMakeLists.txt
+++ b/external/zlib/CMakeLists.txt
 # cmake file for zlib
 if (NOT DE_DEFS)
 	message(FATAL_ERROR "Include Defs.cmake")
 endif ()
 if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/zlib.h")
 	set(DEFAULT_ZLIB_SRC_PATH ${CMAKE_CURRENT_SOURCE_DIR}/src)
 else ()
 	# Assume build inside Android source tree
 	set(DEFAULT_ZLIB_SRC_PATH "../zlib/src")
 endif ()
 set(ZLIB_SRC_PATH ${DEFAULT_ZLIB_SRC_PATH} CACHE STRING "Path to zlib source tree")
 if (IS_ABSOLUTE ${ZLIB_SRC_PATH})
 	set(ZLIB_ABS_PATH ${ZLIB_SRC_PATH})
 else ()
 	set(ZLIB_ABS_PATH "${CMAKE_SOURCE_DIR}/${ZLIB_SRC_PATH}")
 endif ()
 set(ZLIB_SRCS
 	${ZLIB_ABS_PATH}/adler32.c
 	${ZLIB_ABS_PATH}/compress.c
 	${ZLIB_ABS_PATH}/crc32.c
 	${ZLIB_ABS_PATH}/crc32.h
 	${ZLIB_ABS_PATH}/deflate.c
 	${ZLIB_ABS_PATH}/deflate.h
 	${ZLIB_ABS_PATH}/gzclose.c
 	${ZLIB_ABS_PATH}/gzguts.h
 	${ZLIB_ABS_PATH}/gzlib.c
 	${ZLIB_ABS_PATH}/gzread.c
 	${ZLIB_ABS_PATH}/gzwrite.c
 	${ZLIB_ABS_PATH}/infback.c
 	${ZLIB_ABS_PATH}/inffast.c
 	${ZLIB_ABS_PATH}/inffast.h
 	${ZLIB_ABS_PATH}/inffixed.h
 	${ZLIB_ABS_PATH}/inflate.c
 	${ZLIB_ABS_PATH}/inflate.h
 	${ZLIB_ABS_PATH}/inftrees.c
 	${ZLIB_ABS_PATH}/inftrees.h
 	${ZLIB_ABS_PATH}/trees.c
 	${ZLIB_ABS_PATH}/trees.h
 	${ZLIB_ABS_PATH}/uncompr.c
 	${ZLIB_ABS_PATH}/zconf.h
 	${ZLIB_ABS_PATH}/zlib.h
 	${ZLIB_ABS_PATH}/zutil.c
 	${ZLIB_ABS_PATH}/zutil.h
 	)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DHAVE_UNISTD_H")
 if (DE_COMPILER_IS_MSC)
 	# 4127: conditional expression is constant
 	# 4131: 'x': uses old style declarator
 	# 4242, 4244: conversion from 'x' to 'y', possible loss of data
 	# 4996: deprecated POSIX name
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Wall /wd4127 /wd4131 /wd4242 /wd4244 /wd4996")
 elseif (DE_COMPILER_IS_GCC OR DE_COMPILER_IS_CLANG)
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-implicit-function-declaration")
 endif ()
 if (DE_OS_IS_UNIX)
 	add_definitions(-D_XOPEN_SOURCE=600)
 endif ()
 set(CMAKE_C_FLAGS ${DE_3RD_PARTY_C_FLAGS})
 add_library(z STATIC ${ZLIB_SRCS})
 set(ZLIB_INCLUDE_PATH	${ZLIB_ABS_PATH}	PARENT_SCOPE)
 set(ZLIB_LIBRARY		z					PARENT_SCOPE)
--- a/include/png.h
+++ b/include/png.h
--- a/include/pngconf.h
+++ b/include/pngconf.h
 /* pngconf.h - machine-configurable file for libpng
 *
 * libpng version 1.6.37
 *
 * Copyright (c) 2018-2019 Cosmin Truta
 * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson
 * Copyright (c) 1996-1997 Andreas Dilger
 * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
 *
 * This code is released under the libpng license.
 * For conditions of distribution and use, see the disclaimer
 * and license in png.h
 *
 * Any machine specific code is near the front of this file, so if you
 * are configuring libpng for a machine, you may want to read the section
 * starting here down to where it starts to typedef png_color, png_text,
 * and png_info.
 */
 #ifndef PNGCONF_H
 #define PNGCONF_H
 #ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */
 /* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C
 * compiler for correct compilation.  The following header files are required by
 * the standard.  If your compiler doesn't provide these header files, or they
 * do not match the standard, you will need to provide/improve them.
 */
 #include <limits.h>
 #include <stddef.h>
 /* Library header files.  These header files are all defined by ISOC90; libpng
 * expects conformant implementations, however, an ISOC90 conformant system need
 * not provide these header files if the functionality cannot be implemented.
 * In this case it will be necessary to disable the relevant parts of libpng in
 * the build of pnglibconf.h.
 *
 * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not
 * include this unnecessary header file.
 */
 #ifdef PNG_STDIO_SUPPORTED
   /* Required for the definition of FILE: */
 #  include <stdio.h>
 #endif
 #ifdef PNG_SETJMP_SUPPORTED
   /* Required for the definition of jmp_buf and the declaration of longjmp: */
 #  include <setjmp.h>
 #endif
 #ifdef PNG_CONVERT_tIME_SUPPORTED
   /* Required for struct tm: */
 #  include <time.h>
 #endif
 #endif /* PNG_BUILDING_SYMBOL_TABLE */
 /* Prior to 1.6.0, it was possible to turn off 'const' in declarations,
 * using PNG_NO_CONST.  This is no longer supported.
 */
 #define PNG_CONST const /* backward compatibility only */
 /* This controls optimization of the reading of 16-bit and 32-bit
 * values from PNG files.  It can be set on a per-app-file basis: it
 * just changes whether a macro is used when the function is called.
 * The library builder sets the default; if read functions are not
 * built into the library the macro implementation is forced on.
 */
 #ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED
 #  define PNG_USE_READ_MACROS
 #endif
 #if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS)
 #  if PNG_DEFAULT_READ_MACROS
 #    define PNG_USE_READ_MACROS
 #  endif
 #endif
 /* COMPILER SPECIFIC OPTIONS.
 *
 * These options are provided so that a variety of difficult compilers
 * can be used.  Some are fixed at build time (e.g. PNG_API_RULE
 * below) but still have compiler specific implementations, others
 * may be changed on a per-file basis when compiling against libpng.
 */
 /* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect
 * against legacy (pre ISOC90) compilers that did not understand function
 * prototypes.  It is not required for modern C compilers.
 */
 #ifndef PNGARG
 #  define PNGARG(arglist) arglist
 #endif
 /* Function calling conventions.
 * =============================
 * Normally it is not necessary to specify to the compiler how to call
 * a function - it just does it - however on x86 systems derived from
 * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems
 * and some others) there are multiple ways to call a function and the
 * default can be changed on the compiler command line.  For this reason
 * libpng specifies the calling convention of every exported function and
 * every function called via a user supplied function pointer.  This is
 * done in this file by defining the following macros:
 *
 * PNGAPI    Calling convention for exported functions.
 * PNGCBAPI  Calling convention for user provided (callback) functions.
 * PNGCAPI   Calling convention used by the ANSI-C library (required
 *           for longjmp callbacks and sometimes used internally to
 *           specify the calling convention for zlib).
 *
 * These macros should never be overridden.  If it is necessary to
 * change calling convention in a private build this can be done
 * by setting PNG_API_RULE (which defaults to 0) to one of the values
 * below to select the correct 'API' variants.
 *
 * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout.
 *                This is correct in every known environment.
 * PNG_API_RULE=1 Use the operating system convention for PNGAPI and
 *                the 'C' calling convention (from PNGCAPI) for
 *                callbacks (PNGCBAPI).  This is no longer required
 *                in any known environment - if it has to be used
 *                please post an explanation of the problem to the
 *                libpng mailing list.
 *
 * These cases only differ if the operating system does not use the C
 * calling convention, at present this just means the above cases
 * (x86 DOS/Windows systems) and, even then, this does not apply to
 * Cygwin running on those systems.
 *
 * Note that the value must be defined in pnglibconf.h so that what
 * the application uses to call the library matches the conventions
 * set when building the library.
 */
 /* Symbol export
 * =============
 * When building a shared library it is almost always necessary to tell
 * the compiler which symbols to export.  The png.h macro 'PNG_EXPORT'
 * is used to mark the symbols.  On some systems these symbols can be
 * extracted at link time and need no special processing by the compiler,
 * on other systems the symbols are flagged by the compiler and just
 * the declaration requires a special tag applied (unfortunately) in a
 * compiler dependent way.  Some systems can do either.
 *
 * A small number of older systems also require a symbol from a DLL to
 * be flagged to the program that calls it.  This is a problem because
 * we do not know in the header file included by application code that
 * the symbol will come from a shared library, as opposed to a statically
 * linked one.  For this reason the application must tell us by setting
 * the magic flag PNG_USE_DLL to turn on the special processing before
 * it includes png.h.
 *
 * Four additional macros are used to make this happen:
 *
 * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from
 *            the build or imported if PNG_USE_DLL is set - compiler
 *            and system specific.
 *
 * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to
 *                       'type', compiler specific.
 *
 * PNG_DLL_EXPORT Set to the magic to use during a libpng build to
 *                make a symbol exported from the DLL.  Not used in the
 *                public header files; see pngpriv.h for how it is used
 *                in the libpng build.
 *
 * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come
 *                from a DLL - used to define PNG_IMPEXP when
 *                PNG_USE_DLL is set.
 */
 /* System specific discovery.
 * ==========================
 * This code is used at build time to find PNG_IMPEXP, the API settings
 * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL
 * import processing is possible.  On Windows systems it also sets
 * compiler-specific macros to the values required to change the calling
 * conventions of the various functions.
 */
 #if defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\
    defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  /* Windows system (DOS doesn't support DLLs).  Includes builds under Cygwin or
   * MinGW on any architecture currently supported by Windows.  Also includes
   * Watcom builds but these need special treatment because they are not
   * compatible with GCC or Visual C because of different calling conventions.
   */
 #  if PNG_API_RULE == 2
   /* If this line results in an error, either because __watcall is not
    * understood or because of a redefine just below you cannot use *this*
    * build of the library with the compiler you are using.  *This* build was
    * build using Watcom and applications must also be built using Watcom!
    */
 #    define PNGCAPI __watcall
 #  endif
 #  if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800))
 #    define PNGCAPI __cdecl
 #    if PNG_API_RULE == 1
   /* If this line results in an error __stdcall is not understood and
    * PNG_API_RULE should not have been set to '1'.
    */
 #      define PNGAPI __stdcall
 #    endif
 #  else
   /* An older compiler, or one not detected (erroneously) above,
    * if necessary override on the command line to get the correct
    * variants for the compiler.
    */
 #    ifndef PNGCAPI
 #      define PNGCAPI _cdecl
 #    endif
 #    if PNG_API_RULE == 1 && !defined(PNGAPI)
 #      define PNGAPI _stdcall
 #    endif
 #  endif /* compiler/api */
  /* NOTE: PNGCBAPI always defaults to PNGCAPI. */
 #  if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD)
 #     error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed"
 #  endif
 #  if (defined(_MSC_VER) && _MSC_VER < 800) ||\
      (defined(__BORLANDC__) && __BORLANDC__ < 0x500)
   /* older Borland and MSC
    * compilers used '__export' and required this to be after
    * the type.
    */
 #    ifndef PNG_EXPORT_TYPE
 #      define PNG_EXPORT_TYPE(type) type PNG_IMPEXP
 #    endif
 #    define PNG_DLL_EXPORT __export
 #  else /* newer compiler */
 #    define PNG_DLL_EXPORT __declspec(dllexport)
 #    ifndef PNG_DLL_IMPORT
 #      define PNG_DLL_IMPORT __declspec(dllimport)
 #    endif
 #  endif /* compiler */
 #else /* !Windows */
 #  if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
 #    define PNGAPI _System
 #  else /* !Windows/x86 && !OS/2 */
   /* Use the defaults, or define PNG*API on the command line (but
    * this will have to be done for every compile!)
    */
 #  endif /* other system, !OS/2 */
 #endif /* !Windows/x86 */
 /* Now do all the defaulting . */
 #ifndef PNGCAPI
 #  define PNGCAPI
 #endif
 #ifndef PNGCBAPI
 #  define PNGCBAPI PNGCAPI
 #endif
 #ifndef PNGAPI
 #  define PNGAPI PNGCAPI
 #endif
 /* PNG_IMPEXP may be set on the compilation system command line or (if not set)
 * then in an internal header file when building the library, otherwise (when
 * using the library) it is set here.
 */
 #ifndef PNG_IMPEXP
 #  if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)
   /* This forces use of a DLL, disallowing static linking */
 #    define PNG_IMPEXP PNG_DLL_IMPORT
 #  endif
 #  ifndef PNG_IMPEXP
 #    define PNG_IMPEXP
 #  endif
 #endif
 /* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat
 * 'attributes' as a storage class - the attributes go at the start of the
 * function definition, and attributes are always appended regardless of the
 * compiler.  This considerably simplifies these macros but may cause problems
 * if any compilers both need function attributes and fail to handle them as
 * a storage class (this is unlikely.)
 */
 #ifndef PNG_FUNCTION
 #  define PNG_FUNCTION(type, name, args, attributes) attributes type name args
 #endif
 #ifndef PNG_EXPORT_TYPE
 #  define PNG_EXPORT_TYPE(type) PNG_IMPEXP type
 #endif
   /* The ordinal value is only relevant when preprocessing png.h for symbol
    * table entries, so we discard it here.  See the .dfn files in the
    * scripts directory.
    */
 #ifndef PNG_EXPORTA
 #  define PNG_EXPORTA(ordinal, type, name, args, attributes) \
      PNG_FUNCTION(PNG_EXPORT_TYPE(type), (PNGAPI name), PNGARG(args), \
      PNG_LINKAGE_API attributes)
 #endif
 /* ANSI-C (C90) does not permit a macro to be invoked with an empty argument,
 * so make something non-empty to satisfy the requirement:
 */
 #define PNG_EMPTY /*empty list*/
 #define PNG_EXPORT(ordinal, type, name, args) \
   PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY)
 /* Use PNG_REMOVED to comment out a removed interface. */
 #ifndef PNG_REMOVED
 #  define PNG_REMOVED(ordinal, type, name, args, attributes)
 #endif
 #ifndef PNG_CALLBACK
 #  define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args)
 #endif
 /* Support for compiler specific function attributes.  These are used
 * so that where compiler support is available incorrect use of API
 * functions in png.h will generate compiler warnings.
 *
 * Added at libpng-1.2.41.
 */
 #ifndef PNG_NO_PEDANTIC_WARNINGS
 #  ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED
 #    define PNG_PEDANTIC_WARNINGS_SUPPORTED
 #  endif
 #endif
 #ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED
  /* Support for compiler specific function attributes.  These are used
   * so that where compiler support is available, incorrect use of API
   * functions in png.h will generate compiler warnings.  Added at libpng
   * version 1.2.41.  Disabling these removes the warnings but may also produce
   * less efficient code.
   */
 #  if defined(__clang__) && defined(__has_attribute)
   /* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */
 #    if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__)
 #      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
 #    endif
 #    if !defined(PNG_NORETURN) && __has_attribute(__noreturn__)
 #      define PNG_NORETURN __attribute__((__noreturn__))
 #    endif
 #    if !defined(PNG_ALLOCATED) && __has_attribute(__malloc__)
 #      define PNG_ALLOCATED __attribute__((__malloc__))
 #    endif
 #    if !defined(PNG_DEPRECATED) && __has_attribute(__deprecated__)
 #      define PNG_DEPRECATED __attribute__((__deprecated__))
 #    endif
 #    if !defined(PNG_PRIVATE)
 #      ifdef __has_extension
 #        if __has_extension(attribute_unavailable_with_message)
 #          define PNG_PRIVATE __attribute__((__unavailable__(\
             "This function is not exported by libpng.")))
 #        endif
 #      endif
 #    endif
 #    ifndef PNG_RESTRICT
 #      define PNG_RESTRICT __restrict
 #    endif
 #  elif defined(__GNUC__)
 #    ifndef PNG_USE_RESULT
 #      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
 #    endif
 #    ifndef PNG_NORETURN
 #      define PNG_NORETURN   __attribute__((__noreturn__))
 #    endif
 #    if __GNUC__ >= 3
 #      ifndef PNG_ALLOCATED
 #        define PNG_ALLOCATED  __attribute__((__malloc__))
 #      endif
 #      ifndef PNG_DEPRECATED
 #        define PNG_DEPRECATED __attribute__((__deprecated__))
 #      endif
 #      ifndef PNG_PRIVATE
 #        if 0 /* Doesn't work so we use deprecated instead*/
 #          define PNG_PRIVATE \
            __attribute__((warning("This function is not exported by libpng.")))
 #        else
 #          define PNG_PRIVATE \
            __attribute__((__deprecated__))
 #        endif
 #      endif
 #      if ((__GNUC__ > 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))
 #        ifndef PNG_RESTRICT
 #          define PNG_RESTRICT __restrict
 #        endif
 #      endif /* __GNUC__.__GNUC_MINOR__ > 3.0 */
 #    endif /* __GNUC__ >= 3 */
 #  elif defined(_MSC_VER)  && (_MSC_VER >= 1300)
 #    ifndef PNG_USE_RESULT
 #      define PNG_USE_RESULT /* not supported */
 #    endif
 #    ifndef PNG_NORETURN
 #      define PNG_NORETURN   __declspec(noreturn)
 #    endif
 #    ifndef PNG_ALLOCATED
 #      if (_MSC_VER >= 1400)
 #        define PNG_ALLOCATED __declspec(restrict)
 #      endif
 #    endif
 #    ifndef PNG_DEPRECATED
 #      define PNG_DEPRECATED __declspec(deprecated)
 #    endif
 #    ifndef PNG_PRIVATE
 #      define PNG_PRIVATE __declspec(deprecated)
 #    endif
 #    ifndef PNG_RESTRICT
 #      if (_MSC_VER >= 1400)
 #        define PNG_RESTRICT __restrict
 #      endif
 #    endif
 #  elif defined(__WATCOMC__)
 #    ifndef PNG_RESTRICT
 #      define PNG_RESTRICT __restrict
 #    endif
 #  endif
 #endif /* PNG_PEDANTIC_WARNINGS */
 #ifndef PNG_DEPRECATED
 #  define PNG_DEPRECATED  /* Use of this function is deprecated */
 #endif
 #ifndef PNG_USE_RESULT
 #  define PNG_USE_RESULT  /* The result of this function must be checked */
 #endif
 #ifndef PNG_NORETURN
 #  define PNG_NORETURN    /* This function does not return */
 #endif
 #ifndef PNG_ALLOCATED
 #  define PNG_ALLOCATED   /* The result of the function is new memory */
 #endif
 #ifndef PNG_PRIVATE
 #  define PNG_PRIVATE     /* This is a private libpng function */
 #endif
 #ifndef PNG_RESTRICT
 #  define PNG_RESTRICT    /* The C99 "restrict" feature */
 #endif
 #ifndef PNG_FP_EXPORT     /* A floating point API. */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
 #     define PNG_FP_EXPORT(ordinal, type, name, args)\
         PNG_EXPORT(ordinal, type, name, args);
 #  else                   /* No floating point APIs */
 #     define PNG_FP_EXPORT(ordinal, type, name, args)
 #  endif
 #endif
 #ifndef PNG_FIXED_EXPORT  /* A fixed point API. */
 #  ifdef PNG_FIXED_POINT_SUPPORTED
 #     define PNG_FIXED_EXPORT(ordinal, type, name, args)\
         PNG_EXPORT(ordinal, type, name, args);
 #  else                   /* No fixed point APIs */
 #     define PNG_FIXED_EXPORT(ordinal, type, name, args)
 #  endif
 #endif
 #ifndef PNG_BUILDING_SYMBOL_TABLE
 /* Some typedefs to get us started.  These should be safe on most of the common
 * platforms.
 *
 * png_uint_32 and png_int_32 may, currently, be larger than required to hold a
 * 32-bit value however this is not normally advisable.
 *
 * png_uint_16 and png_int_16 should always be two bytes in size - this is
 * verified at library build time.
 *
 * png_byte must always be one byte in size.
 *
 * The checks below use constants from limits.h, as defined by the ISOC90
 * standard.
 */
 #if CHAR_BIT == 8 && UCHAR_MAX == 255
   typedef unsigned char png_byte;
 #else
 #  error "libpng requires 8-bit bytes"
 #endif
 #if INT_MIN == -32768 && INT_MAX == 32767
   typedef int png_int_16;
 #elif SHRT_MIN == -32768 && SHRT_MAX == 32767
   typedef short png_int_16;
 #else
 #  error "libpng requires a signed 16-bit type"
 #endif
 #if UINT_MAX == 65535
   typedef unsigned int png_uint_16;
 #elif USHRT_MAX == 65535
   typedef unsigned short png_uint_16;
 #else
 #  error "libpng requires an unsigned 16-bit type"
 #endif
 #if INT_MIN < -2147483646 && INT_MAX > 2147483646
   typedef int png_int_32;
 #elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646
   typedef long int png_int_32;
 #else
 #  error "libpng requires a signed 32-bit (or more) type"
 #endif
 #if UINT_MAX > 4294967294U
   typedef unsigned int png_uint_32;
 #elif ULONG_MAX > 4294967294U
   typedef unsigned long int png_uint_32;
 #else
 #  error "libpng requires an unsigned 32-bit (or more) type"
 #endif
 /* Prior to 1.6.0, it was possible to disable the use of size_t and ptrdiff_t.
 * From 1.6.0 onwards, an ISO C90 compiler, as well as a standard-compliant
 * behavior of sizeof and ptrdiff_t are required.
 * The legacy typedefs are provided here for backwards compatibility.
 */
 typedef size_t png_size_t;
 typedef ptrdiff_t png_ptrdiff_t;
 /* libpng needs to know the maximum value of 'size_t' and this controls the
 * definition of png_alloc_size_t, below.  This maximum value of size_t limits
 * but does not control the maximum allocations the library makes - there is
 * direct application control of this through png_set_user_limits().
 */
 #ifndef PNG_SMALL_SIZE_T
   /* Compiler specific tests for systems where size_t is known to be less than
    * 32 bits (some of these systems may no longer work because of the lack of
    * 'far' support; see above.)
    */
 #  if (defined(__TURBOC__) && !defined(__FLAT__)) ||\
   (defined(_MSC_VER) && defined(MAXSEG_64K))
 #     define PNG_SMALL_SIZE_T
 #  endif
 #endif
 /* png_alloc_size_t is guaranteed to be no smaller than size_t, and no smaller
 * than png_uint_32.  Casts from size_t or png_uint_32 to png_alloc_size_t are
 * not necessary; in fact, it is recommended not to use them at all, so that
 * the compiler can complain when something turns out to be problematic.
 *
 * Casts in the other direction (from png_alloc_size_t to size_t or
 * png_uint_32) should be explicitly applied; however, we do not expect to
 * encounter practical situations that require such conversions.
 *
 * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than
 * 4294967295 - i.e. less than the maximum value of png_uint_32.
 */
 #ifdef PNG_SMALL_SIZE_T
   typedef png_uint_32 png_alloc_size_t;
 #else
   typedef size_t png_alloc_size_t;
 #endif
 /* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
 * implementations of Intel CPU specific support of user-mode segmented address
 * spaces, where 16-bit pointers address more than 65536 bytes of memory using
 * separate 'segment' registers.  The implementation requires two different
 * types of pointer (only one of which includes the segment value.)
 *
 * If required this support is available in version 1.2 of libpng and may be
 * available in versions through 1.5, although the correctness of the code has
 * not been verified recently.
 */
 /* Typedef for floating-point numbers that are converted to fixed-point with a
 * multiple of 100,000, e.g., gamma
 */
 typedef png_int_32 png_fixed_point;
 /* Add typedefs for pointers */
 typedef void                  * png_voidp;
 typedef const void            * png_const_voidp;
 typedef png_byte              * png_bytep;
 typedef const png_byte        * png_const_bytep;
 typedef png_uint_32           * png_uint_32p;
 typedef const png_uint_32     * png_const_uint_32p;
 typedef png_int_32            * png_int_32p;
 typedef const png_int_32      * png_const_int_32p;
 typedef png_uint_16           * png_uint_16p;
 typedef const png_uint_16     * png_const_uint_16p;
 typedef png_int_16            * png_int_16p;
 typedef const png_int_16      * png_const_int_16p;
 typedef char                  * png_charp;
 typedef const char            * png_const_charp;
 typedef png_fixed_point       * png_fixed_point_p;
 typedef const png_fixed_point * png_const_fixed_point_p;
 typedef size_t                * png_size_tp;
 typedef const size_t          * png_const_size_tp;
 #ifdef PNG_STDIO_SUPPORTED
 typedef FILE            * png_FILE_p;
 #endif
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 typedef double       * png_doublep;
 typedef const double * png_const_doublep;
 #endif
 /* Pointers to pointers; i.e. arrays */
 typedef png_byte        * * png_bytepp;
 typedef png_uint_32     * * png_uint_32pp;
 typedef png_int_32      * * png_int_32pp;
 typedef png_uint_16     * * png_uint_16pp;
 typedef png_int_16      * * png_int_16pp;
 typedef const char      * * png_const_charpp;
 typedef char            * * png_charpp;
 typedef png_fixed_point * * png_fixed_point_pp;
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 typedef double          * * png_doublepp;
 #endif
 /* Pointers to pointers to pointers; i.e., pointer to array */
 typedef char            * * * png_charppp;
 #endif /* PNG_BUILDING_SYMBOL_TABLE */
 #endif /* PNGCONF_H */
--- a/include/pnglibconf.h
+++ b/include/pnglibconf.h
 /* pnglibconf.h - library build configuration */
 /* libpng version 1.6.37 */
 /* Copyright (c) 2018-2019 Cosmin Truta */
 /* Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson */
 /* This code is released under the libpng license. */
 /* For conditions of distribution and use, see the disclaimer */
 /* and license in png.h */
 /* pnglibconf.h */
 /* Machine generated file: DO NOT EDIT */
 /* Derived from: scripts/pnglibconf.dfa */
 #ifndef PNGLCONF_H
 #define PNGLCONF_H
 /* options */
 #define PNG_16BIT_SUPPORTED
 #define PNG_ALIGNED_MEMORY_SUPPORTED
 /*#undef PNG_ARM_NEON_API_SUPPORTED*/
 /*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/
 #define PNG_BENIGN_ERRORS_SUPPORTED
 #define PNG_BENIGN_READ_ERRORS_SUPPORTED
 /*#undef PNG_BENIGN_WRITE_ERRORS_SUPPORTED*/
 #define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
 #define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
 #define PNG_COLORSPACE_SUPPORTED
 #define PNG_CONSOLE_IO_SUPPORTED
 #define PNG_CONVERT_tIME_SUPPORTED
 #define PNG_EASY_ACCESS_SUPPORTED
 /*#undef PNG_ERROR_NUMBERS_SUPPORTED*/
 #define PNG_ERROR_TEXT_SUPPORTED
 #define PNG_FIXED_POINT_SUPPORTED
 #define PNG_FLOATING_ARITHMETIC_SUPPORTED
 #define PNG_FLOATING_POINT_SUPPORTED
 #define PNG_FORMAT_AFIRST_SUPPORTED
 #define PNG_FORMAT_BGR_SUPPORTED
 #define PNG_GAMMA_SUPPORTED
 #define PNG_GET_PALETTE_MAX_SUPPORTED
 #define PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 #define PNG_INCH_CONVERSIONS_SUPPORTED
 #define PNG_INFO_IMAGE_SUPPORTED
 #define PNG_IO_STATE_SUPPORTED
 #define PNG_MNG_FEATURES_SUPPORTED
 #define PNG_POINTER_INDEXING_SUPPORTED
 /*#undef PNG_POWERPC_VSX_API_SUPPORTED*/
 /*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/
 #define PNG_PROGRESSIVE_READ_SUPPORTED
 #define PNG_READ_16BIT_SUPPORTED
 #define PNG_READ_ALPHA_MODE_SUPPORTED
 #define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED
 #define PNG_READ_BACKGROUND_SUPPORTED
 #define PNG_READ_BGR_SUPPORTED
 #define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
 #define PNG_READ_COMPOSITE_NODIV_SUPPORTED
 #define PNG_READ_COMPRESSED_TEXT_SUPPORTED
 #define PNG_READ_EXPAND_16_SUPPORTED
 #define PNG_READ_EXPAND_SUPPORTED
 #define PNG_READ_FILLER_SUPPORTED
 #define PNG_READ_GAMMA_SUPPORTED
 #define PNG_READ_GET_PALETTE_MAX_SUPPORTED
 #define PNG_READ_GRAY_TO_RGB_SUPPORTED
 #define PNG_READ_INTERLACING_SUPPORTED
 #define PNG_READ_INT_FUNCTIONS_SUPPORTED
 #define PNG_READ_INVERT_ALPHA_SUPPORTED
 #define PNG_READ_INVERT_SUPPORTED
 #define PNG_READ_OPT_PLTE_SUPPORTED
 #define PNG_READ_PACKSWAP_SUPPORTED
 #define PNG_READ_PACK_SUPPORTED
 #define PNG_READ_QUANTIZE_SUPPORTED
 #define PNG_READ_RGB_TO_GRAY_SUPPORTED
 #define PNG_READ_SCALE_16_TO_8_SUPPORTED
 #define PNG_READ_SHIFT_SUPPORTED
 #define PNG_READ_STRIP_16_TO_8_SUPPORTED
 #define PNG_READ_STRIP_ALPHA_SUPPORTED
 #define PNG_READ_SUPPORTED
 #define PNG_READ_SWAP_ALPHA_SUPPORTED
 #define PNG_READ_SWAP_SUPPORTED
 #define PNG_READ_TEXT_SUPPORTED
 #define PNG_READ_TRANSFORMS_SUPPORTED
 #define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_READ_USER_CHUNKS_SUPPORTED
 #define PNG_READ_USER_TRANSFORM_SUPPORTED
 #define PNG_READ_bKGD_SUPPORTED
 #define PNG_READ_cHRM_SUPPORTED
 #define PNG_READ_eXIf_SUPPORTED
 #define PNG_READ_gAMA_SUPPORTED
 #define PNG_READ_hIST_SUPPORTED
 #define PNG_READ_iCCP_SUPPORTED
 #define PNG_READ_iTXt_SUPPORTED
 #define PNG_READ_oFFs_SUPPORTED
 #define PNG_READ_pCAL_SUPPORTED
 #define PNG_READ_pHYs_SUPPORTED
 #define PNG_READ_sBIT_SUPPORTED
 #define PNG_READ_sCAL_SUPPORTED
 #define PNG_READ_sPLT_SUPPORTED
 #define PNG_READ_sRGB_SUPPORTED
 #define PNG_READ_tEXt_SUPPORTED
 #define PNG_READ_tIME_SUPPORTED
 #define PNG_READ_tRNS_SUPPORTED
 #define PNG_READ_zTXt_SUPPORTED
 #define PNG_SAVE_INT_32_SUPPORTED
 #define PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_SEQUENTIAL_READ_SUPPORTED
 #define PNG_SETJMP_SUPPORTED
 #define PNG_SET_OPTION_SUPPORTED
 #define PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_SET_USER_LIMITS_SUPPORTED
 #define PNG_SIMPLIFIED_READ_AFIRST_SUPPORTED
 #define PNG_SIMPLIFIED_READ_BGR_SUPPORTED
 #define PNG_SIMPLIFIED_READ_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
 #define PNG_SIMPLIFIED_WRITE_SUPPORTED
 #define PNG_STDIO_SUPPORTED
 #define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_TEXT_SUPPORTED
 #define PNG_TIME_RFC1123_SUPPORTED
 #define PNG_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_USER_CHUNKS_SUPPORTED
 #define PNG_USER_LIMITS_SUPPORTED
 #define PNG_USER_MEM_SUPPORTED
 #define PNG_USER_TRANSFORM_INFO_SUPPORTED
 #define PNG_USER_TRANSFORM_PTR_SUPPORTED
 #define PNG_WARNINGS_SUPPORTED
 #define PNG_WRITE_16BIT_SUPPORTED
 #define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED
 #define PNG_WRITE_BGR_SUPPORTED
 #define PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
 #define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
 #define PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
 #define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
 #define PNG_WRITE_FILLER_SUPPORTED
 #define PNG_WRITE_FILTER_SUPPORTED
 #define PNG_WRITE_FLUSH_SUPPORTED
 #define PNG_WRITE_GET_PALETTE_MAX_SUPPORTED
 #define PNG_WRITE_INTERLACING_SUPPORTED
 #define PNG_WRITE_INT_FUNCTIONS_SUPPORTED
 #define PNG_WRITE_INVERT_ALPHA_SUPPORTED
 #define PNG_WRITE_INVERT_SUPPORTED
 #define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
 #define PNG_WRITE_PACKSWAP_SUPPORTED
 #define PNG_WRITE_PACK_SUPPORTED
 #define PNG_WRITE_SHIFT_SUPPORTED
 #define PNG_WRITE_SUPPORTED
 #define PNG_WRITE_SWAP_ALPHA_SUPPORTED
 #define PNG_WRITE_SWAP_SUPPORTED
 #define PNG_WRITE_TEXT_SUPPORTED
 #define PNG_WRITE_TRANSFORMS_SUPPORTED
 #define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
 #define PNG_WRITE_USER_TRANSFORM_SUPPORTED
 #define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
 #define PNG_WRITE_bKGD_SUPPORTED
 #define PNG_WRITE_cHRM_SUPPORTED
 #define PNG_WRITE_eXIf_SUPPORTED
 #define PNG_WRITE_gAMA_SUPPORTED
 #define PNG_WRITE_hIST_SUPPORTED
 #define PNG_WRITE_iCCP_SUPPORTED
 #define PNG_WRITE_iTXt_SUPPORTED
 #define PNG_WRITE_oFFs_SUPPORTED
 #define PNG_WRITE_pCAL_SUPPORTED
 #define PNG_WRITE_pHYs_SUPPORTED
 #define PNG_WRITE_sBIT_SUPPORTED
 #define PNG_WRITE_sCAL_SUPPORTED
 #define PNG_WRITE_sPLT_SUPPORTED
 #define PNG_WRITE_sRGB_SUPPORTED
 #define PNG_WRITE_tEXt_SUPPORTED
 #define PNG_WRITE_tIME_SUPPORTED
 #define PNG_WRITE_tRNS_SUPPORTED
 #define PNG_WRITE_zTXt_SUPPORTED
 #define PNG_bKGD_SUPPORTED
 #define PNG_cHRM_SUPPORTED
 #define PNG_eXIf_SUPPORTED
 #define PNG_gAMA_SUPPORTED
 #define PNG_hIST_SUPPORTED
 #define PNG_iCCP_SUPPORTED
 #define PNG_iTXt_SUPPORTED
 #define PNG_oFFs_SUPPORTED
 #define PNG_pCAL_SUPPORTED
 #define PNG_pHYs_SUPPORTED
 #define PNG_sBIT_SUPPORTED
 #define PNG_sCAL_SUPPORTED
 #define PNG_sPLT_SUPPORTED
 #define PNG_sRGB_SUPPORTED
 #define PNG_tEXt_SUPPORTED
 #define PNG_tIME_SUPPORTED
 #define PNG_tRNS_SUPPORTED
 #define PNG_zTXt_SUPPORTED
 /* end of options */
 /* settings */
 #define PNG_API_RULE 0
 #define PNG_DEFAULT_READ_MACROS 1
 #define PNG_GAMMA_THRESHOLD_FIXED 5000
 #define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE
 #define PNG_INFLATE_BUF_SIZE 1024
 #define PNG_LINKAGE_API extern
 #define PNG_LINKAGE_CALLBACK extern
 #define PNG_LINKAGE_DATA extern
 #define PNG_LINKAGE_FUNCTION extern
 #define PNG_MAX_GAMMA_8 11
 #define PNG_QUANTIZE_BLUE_BITS 5
 #define PNG_QUANTIZE_GREEN_BITS 5
 #define PNG_QUANTIZE_RED_BITS 5
 #define PNG_TEXT_Z_DEFAULT_COMPRESSION (-1)
 #define PNG_TEXT_Z_DEFAULT_STRATEGY 0
 #define PNG_USER_CHUNK_CACHE_MAX 1000
 #define PNG_USER_CHUNK_MALLOC_MAX 8000000
 #define PNG_USER_HEIGHT_MAX 1000000
 #define PNG_USER_WIDTH_MAX 1000000
 #define PNG_ZBUF_SIZE 8192
 #define PNG_ZLIB_VERNUM 0x12b0
 #define PNG_Z_DEFAULT_COMPRESSION (-1)
 #define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0
 #define PNG_Z_DEFAULT_STRATEGY 1
 #define PNG_sCAL_PRECISION 5
 #define PNG_sRGB_PROFILE_CHECKS 2
 /* end of settings */
 #endif /* PNGLCONF_H */
--- a/include/vulkan/vk_icd.h
+++ b/include/vulkan/vk_icd.h
 //
 // File: vk_icd.h
 //
 /*
 * Copyright (c) 2015-2016 The Khronos Group Inc.
 * Copyright (c) 2015-2016 Valve Corporation
 * Copyright (c) 2015-2016 LunarG, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 #ifndef VKICD_H
 #define VKICD_H
 #include "vulkan.h"
 #include <stdbool.h>
 // Loader-ICD version negotiation API.  Versions add the following features:
 //   Version 0 - Initial.  Doesn't support vk_icdGetInstanceProcAddr
 //               or vk_icdNegotiateLoaderICDInterfaceVersion.
 //   Version 1 - Add support for vk_icdGetInstanceProcAddr.
 //   Version 2 - Add Loader/ICD Interface version negotiation
 //               via vk_icdNegotiateLoaderICDInterfaceVersion.
 //   Version 3 - Add ICD creation/destruction of KHR_surface objects.
 //   Version 4 - Add unknown physical device extension qyering via
 //               vk_icdGetPhysicalDeviceProcAddr.
 //   Version 5 - Tells ICDs that the loader is now paying attention to the
 //               application version of Vulkan passed into the ApplicationInfo
 //               structure during vkCreateInstance.  This will tell the ICD
 //               that if the loader is older, it should automatically fail a
 //               call for any API version > 1.0.  Otherwise, the loader will
 //               manually determine if it can support the expected version.
 #define CURRENT_LOADER_ICD_INTERFACE_VERSION 5
 #define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
 #define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
 typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
 // This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
 // file directly, it won't be found.
 #ifndef PFN_GetPhysicalDeviceProcAddr
 typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName);
 #endif
 /*
 * The ICD must reserve space for a pointer for the loader's dispatch
 * table, at the start of <each object>.
 * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
 */
 #define ICD_LOADER_MAGIC 0x01CDC0DE
 typedef union {
    uintptr_t loaderMagic;
    void *loaderData;
 } VK_LOADER_DATA;
 static inline void set_loader_magic_value(void *pNewObject) {
    VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
    loader_info->loaderMagic = ICD_LOADER_MAGIC;
 }
 static inline bool valid_loader_magic_value(void *pNewObject) {
    const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
    return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
 }
 /*
 * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
 * contains the platform-specific connection and surface information.
 */
 typedef enum {
    VK_ICD_WSI_PLATFORM_MIR,
    VK_ICD_WSI_PLATFORM_WAYLAND,
    VK_ICD_WSI_PLATFORM_WIN32,
    VK_ICD_WSI_PLATFORM_XCB,
    VK_ICD_WSI_PLATFORM_XLIB,
    VK_ICD_WSI_PLATFORM_ANDROID,
    VK_ICD_WSI_PLATFORM_MACOS,
    VK_ICD_WSI_PLATFORM_IOS,
    VK_ICD_WSI_PLATFORM_DISPLAY,
    VK_ICD_WSI_PLATFORM_HEADLESS
 } VkIcdWsiPlatform;
 typedef struct {
    VkIcdWsiPlatform platform;
 } VkIcdSurfaceBase;
 #ifdef VK_USE_PLATFORM_MIR_KHR
 typedef struct {
    VkIcdSurfaceBase base;
    MirConnection *connection;
    MirSurface *mirSurface;
 } VkIcdSurfaceMir;
 #endif  // VK_USE_PLATFORM_MIR_KHR
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
 typedef struct {
    VkIcdSurfaceBase base;
    struct wl_display *display;
    struct wl_surface *surface;
 } VkIcdSurfaceWayland;
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 typedef struct {
    VkIcdSurfaceBase base;
    HINSTANCE hinstance;
    HWND hwnd;
 } VkIcdSurfaceWin32;
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 #ifdef VK_USE_PLATFORM_XCB_KHR
 typedef struct {
    VkIcdSurfaceBase base;
    xcb_connection_t *connection;
    xcb_window_t window;
 } VkIcdSurfaceXcb;
 #endif  // VK_USE_PLATFORM_XCB_KHR
 #ifdef VK_USE_PLATFORM_XLIB_KHR
 typedef struct {
    VkIcdSurfaceBase base;
    Display *dpy;
    Window window;
 } VkIcdSurfaceXlib;
 #endif  // VK_USE_PLATFORM_XLIB_KHR
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 typedef struct {
    VkIcdSurfaceBase base;
    struct ANativeWindow *window;
 } VkIcdSurfaceAndroid;
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 #ifdef VK_USE_PLATFORM_MACOS_MVK
 typedef struct {
    VkIcdSurfaceBase base;
    const void *pView;
 } VkIcdSurfaceMacOS;
 #endif  // VK_USE_PLATFORM_MACOS_MVK
 #ifdef VK_USE_PLATFORM_IOS_MVK
 typedef struct {
    VkIcdSurfaceBase base;
    const void *pView;
 } VkIcdSurfaceIOS;
 #endif  // VK_USE_PLATFORM_IOS_MVK
 typedef struct {
    VkIcdSurfaceBase base;
    VkDisplayModeKHR displayMode;
    uint32_t planeIndex;
    uint32_t planeStackIndex;
    VkSurfaceTransformFlagBitsKHR transform;
    float globalAlpha;
    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
    VkExtent2D imageExtent;
 } VkIcdSurfaceDisplay;
 typedef struct {
    VkIcdSurfaceBase base;
 } VkIcdSurfaceHeadless;
 #endif  // VKICD_H
--- a/include/vulkan/vk_layer.h
+++ b/include/vulkan/vk_layer.h
 //
 // File: vk_layer.h
 //
 /*
 * Copyright (c) 2015-2017 The Khronos Group Inc.
 * Copyright (c) 2015-2017 Valve Corporation
 * Copyright (c) 2015-2017 LunarG, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 /* Need to define dispatch table
 * Core struct can then have ptr to dispatch table at the top
 * Along with object ptrs for current and next OBJ
 */
 #pragma once
 #include "vulkan.h"
 #if defined(__GNUC__) && __GNUC__ >= 4
 #define VK_LAYER_EXPORT __attribute__((visibility("default")))
 #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
 #define VK_LAYER_EXPORT __attribute__((visibility("default")))
 #else
 #define VK_LAYER_EXPORT
 #endif
 #define MAX_NUM_UNKNOWN_EXTS 250
 // Loader-Layer version negotiation API.  Versions add the following features:
 //   Versions 0/1 - Initial.  Doesn't support vk_layerGetPhysicalDeviceProcAddr
 //                  or vk_icdNegotiateLoaderLayerInterfaceVersion.
 //   Version 2    - Add support for vk_layerGetPhysicalDeviceProcAddr and
 //                  vk_icdNegotiateLoaderLayerInterfaceVersion.
 #define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
 #define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
 #define VK_CURRENT_CHAIN_VERSION 1
 // Typedef for use in the interfaces below
 typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
 // Version negotiation values
 typedef enum VkNegotiateLayerStructType {
    LAYER_NEGOTIATE_UNINTIALIZED = 0,
    LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
 } VkNegotiateLayerStructType;
 // Version negotiation structures
 typedef struct VkNegotiateLayerInterface {
    VkNegotiateLayerStructType sType;
    void *pNext;
    uint32_t loaderLayerInterfaceVersion;
    PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
    PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
    PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
 } VkNegotiateLayerInterface;
 // Version negotiation functions
 typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
 // Function prototype for unknown physical device extension command
 typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
 // ------------------------------------------------------------------------------------------------
 // CreateInstance and CreateDevice support structures
 /* Sub type of structure for instance and device loader ext of CreateInfo.
 * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
 * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
 * then VkLayerFunction indicates struct type pointed to by pNext
 */
 typedef enum VkLayerFunction_ {
    VK_LAYER_LINK_INFO = 0,
    VK_LOADER_DATA_CALLBACK = 1,
    VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2
 } VkLayerFunction;
 typedef struct VkLayerInstanceLink_ {
    struct VkLayerInstanceLink_ *pNext;
    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
    PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
 } VkLayerInstanceLink;
 /*
 * When creating the device chain the loader needs to pass
 * down information about it's device structure needed at
 * the end of the chain. Passing the data via the
 * VkLayerDeviceInfo avoids issues with finding the
 * exact instance being used.
 */
 typedef struct VkLayerDeviceInfo_ {
    void *device_info;
    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
 } VkLayerDeviceInfo;
 typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
        void *object);
 typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
        void *object);
 typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
 						      const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA);
 typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction);
 typedef struct {
    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
    const void *pNext;
    VkLayerFunction function;
    union {
        VkLayerInstanceLink *pLayerInfo;
        PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
        struct {
 	  PFN_vkLayerCreateDevice pfnLayerCreateDevice;
 	  PFN_vkLayerDestroyDevice pfnLayerDestroyDevice;
 	} layerDevice;
    } u;
 } VkLayerInstanceCreateInfo;
 typedef struct VkLayerDeviceLink_ {
    struct VkLayerDeviceLink_ *pNext;
    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
    PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
 } VkLayerDeviceLink;
 typedef struct {
    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
    const void *pNext;
    VkLayerFunction function;
    union {
        VkLayerDeviceLink *pLayerInfo;
        PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
    } u;
 } VkLayerDeviceCreateInfo;
 #ifdef __cplusplus
 extern "C" {
 #endif
 VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
 typedef enum VkChainType {
    VK_CHAIN_TYPE_UNKNOWN = 0,
    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3,
 } VkChainType;
 typedef struct VkChainHeader {
    VkChainType type;
    uint32_t version;
    uint32_t size;
 } VkChainHeader;
 typedef struct VkEnumerateInstanceExtensionPropertiesChain {
    VkChainHeader header;
    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
                                      VkExtensionProperties *);
    const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
 #if defined(__cplusplus)
    inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
        return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
    }
 #endif
 } VkEnumerateInstanceExtensionPropertiesChain;
 typedef struct VkEnumerateInstanceLayerPropertiesChain {
    VkChainHeader header;
    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
    const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
 #if defined(__cplusplus)
    inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
        return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
    }
 #endif
 } VkEnumerateInstanceLayerPropertiesChain;
 typedef struct VkEnumerateInstanceVersionChain {
    VkChainHeader header;
    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *);
    const struct VkEnumerateInstanceVersionChain *pNextLink;
 #if defined(__cplusplus)
    inline VkResult CallDown(uint32_t *pApiVersion) const {
        return pfnNextLayer(pNextLink, pApiVersion);
    }
 #endif
 } VkEnumerateInstanceVersionChain;
 #ifdef __cplusplus
 }
 #endif
--- a/include/vulkan/vk_platform.h
+++ b/include/vulkan/vk_platform.h
 //
 // File: vk_platform.h
 //
 /*
 ** Copyright (c) 2014-2017 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 #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_ARCH) && __ARM_ARCH < 7
    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
    // calling convention, i.e. float parameters are passed in registers. This
    // is true even if the rest of the application passes floats on the stack,
    // as it does by default when compiling for the armeabi-v7a NDK ABI.
    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
    #define VKAPI_CALL
    #define VKAPI_PTR  VKAPI_ATTR
 #else
    // On other platforms, use the default calling convention
    #define VKAPI_ATTR
    #define VKAPI_CALL
    #define VKAPI_PTR
 #endif
 #include <stddef.h>
 #if !defined(VK_NO_STDINT_H)
    #if defined(_MSC_VER) && (_MSC_VER < 1600)
        typedef signed   __int8  int8_t;
        typedef unsigned __int8  uint8_t;
        typedef signed   __int16 int16_t;
        typedef unsigned __int16 uint16_t;
        typedef signed   __int32 int32_t;
        typedef unsigned __int32 uint32_t;
        typedef signed   __int64 int64_t;
        typedef unsigned __int64 uint64_t;
    #else
        #include <stdint.h>
    #endif
 #endif // !defined(VK_NO_STDINT_H)
 #ifdef __cplusplus
 } // extern "C"
 #endif // __cplusplus
 #endif
--- a/include/vulkan/vk_sdk_platform.h
+++ b/include/vulkan/vk_sdk_platform.h
 //
 // File: vk_sdk_platform.h
 //
 /*
 * Copyright (c) 2015-2016 The Khronos Group Inc.
 * Copyright (c) 2015-2016 Valve Corporation
 * Copyright (c) 2015-2016 LunarG, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 #ifndef VK_SDK_PLATFORM_H
 #define VK_SDK_PLATFORM_H
 #if defined(_WIN32)
 #define NOMINMAX
 #ifndef __cplusplus
 #undef inline
 #define inline __inline
 #endif // __cplusplus
 #if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
 // C99:
 // Microsoft didn't implement C99 in Visual Studio; but started adding it with
 // VS2013.  However, VS2013 still didn't have snprintf().  The following is a
 // work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
 // "CMakeLists.txt" file).
 // NOTE: This is fixed in Visual Studio 2015.
 #define snprintf _snprintf
 #endif
 #define strdup _strdup
 #endif // _WIN32
 // Check for noexcept support using clang, with fallback to Windows or GCC version numbers
 #ifndef NOEXCEPT
 #if defined(__clang__)
 #if __has_feature(cxx_noexcept)
 #define HAS_NOEXCEPT
 #endif
 #else
 #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
 #define HAS_NOEXCEPT
 #else
 #if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
 #define HAS_NOEXCEPT
 #endif
 #endif
 #endif
 #ifdef HAS_NOEXCEPT
 #define NOEXCEPT noexcept
 #else
 #define NOEXCEPT
 #endif
 #endif
 #endif  // VK_SDK_PLATFORM_H
--- a/include/vulkan/vulkan.h
+++ b/include/vulkan/vulkan.h
 #ifndef VULKAN_H_
 #define VULKAN_H_ 1
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 #include "vk_platform.h"
 #include "vulkan_core.h"
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 #include "vulkan_android.h"
 #endif
 #ifdef VK_USE_PLATFORM_FUCHSIA
 #include <zircon/types.h>
 #include "vulkan_fuchsia.h"
 #endif
 #ifdef VK_USE_PLATFORM_IOS_MVK
 #include "vulkan_ios.h"
 #endif
 #ifdef VK_USE_PLATFORM_MACOS_MVK
 #include "vulkan_macos.h"
 #endif
 #ifdef VK_USE_PLATFORM_METAL_EXT
 #include "vulkan_metal.h"
 #endif
 #ifdef VK_USE_PLATFORM_VI_NN
 #include "vulkan_vi.h"
 #endif
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
 #include <wayland-client.h>
 #include "vulkan_wayland.h"
 #endif
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 #include <windows.h>
 #include "vulkan_win32.h"
 #endif
 #ifdef VK_USE_PLATFORM_XCB_KHR
 #include <xcb/xcb.h>
 #include "vulkan_xcb.h"
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_KHR
 #include <X11/Xlib.h>
 #include "vulkan_xlib.h"
 #endif
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrandr.h>
 #include "vulkan_xlib_xrandr.h"
 #endif
 #ifdef VK_USE_PLATFORM_GGP
 #include <ggp_c/vulkan_types.h>
 #include "vulkan_ggp.h"
 #endif
 #endif // VULKAN_H_
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
--- a/include/vulkan/vulkan_android.h
+++ b/include/vulkan/vulkan_android.h
 #ifndef VULKAN_ANDROID_H_
 #define VULKAN_ANDROID_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_KHR_android_surface 1
 struct ANativeWindow;
 #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;
    struct 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
 #define VK_ANDROID_external_memory_android_hardware_buffer 1
 struct AHardwareBuffer;
 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
 #define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
 typedef struct VkAndroidHardwareBufferUsageANDROID {
    VkStructureType    sType;
    void*              pNext;
    uint64_t           androidHardwareBufferUsage;
 } VkAndroidHardwareBufferUsageANDROID;
 typedef struct VkAndroidHardwareBufferPropertiesANDROID {
    VkStructureType    sType;
    void*              pNext;
    VkDeviceSize       allocationSize;
    uint32_t           memoryTypeBits;
 } VkAndroidHardwareBufferPropertiesANDROID;
 typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
    VkStructureType                  sType;
    void*                            pNext;
    VkFormat                         format;
    uint64_t                         externalFormat;
    VkFormatFeatureFlags             formatFeatures;
    VkComponentMapping               samplerYcbcrConversionComponents;
    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
    VkSamplerYcbcrRange              suggestedYcbcrRange;
    VkChromaLocation                 suggestedXChromaOffset;
    VkChromaLocation                 suggestedYChromaOffset;
 } VkAndroidHardwareBufferFormatPropertiesANDROID;
 typedef struct VkImportAndroidHardwareBufferInfoANDROID {
    VkStructureType            sType;
    const void*                pNext;
    struct AHardwareBuffer*    buffer;
 } VkImportAndroidHardwareBufferInfoANDROID;
 typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
    VkStructureType    sType;
    const void*        pNext;
    VkDeviceMemory     memory;
 } VkMemoryGetAndroidHardwareBufferInfoANDROID;
 typedef struct VkExternalFormatANDROID {
    VkStructureType    sType;
    void*              pNext;
    uint64_t           externalFormat;
 } VkExternalFormatANDROID;
 typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
    VkDevice                                    device,
    const struct AHardwareBuffer*               buffer,
    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
    VkDevice                                    device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    struct AHardwareBuffer**                    pBuffer);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_core.h
+++ b/include/vulkan/vulkan_core.h
--- a/include/vulkan/vulkan_fuchsia.h
+++ b/include/vulkan/vulkan_fuchsia.h
 #ifndef VULKAN_FUCHSIA_H_
 #define VULKAN_FUCHSIA_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_FUCHSIA_imagepipe_surface 1
 #define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1
 #define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface"
 typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA;
 typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA {
    VkStructureType                         sType;
    const void*                             pNext;
    VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
    zx_handle_t                             imagePipeHandle;
 } VkImagePipeSurfaceCreateInfoFUCHSIA;
 typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(
    VkInstance                                  instance,
    const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_ggp.h
+++ b/include/vulkan/vulkan_ggp.h
 #ifndef VULKAN_GGP_H_
 #define VULKAN_GGP_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_GGP_stream_descriptor_surface 1
 #define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1
 #define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface"
 typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP;
 typedef struct VkStreamDescriptorSurfaceCreateInfoGGP {
    VkStructureType                            sType;
    const void*                                pNext;
    VkStreamDescriptorSurfaceCreateFlagsGGP    flags;
    GgpStreamDescriptor                        streamDescriptor;
 } VkStreamDescriptorSurfaceCreateInfoGGP;
 typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(
    VkInstance                                  instance,
    const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);
 #endif
 #define VK_GGP_frame_token 1
 #define VK_GGP_FRAME_TOKEN_SPEC_VERSION   1
 #define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token"
 typedef struct VkPresentFrameTokenGGP {
    VkStructureType    sType;
    const void*        pNext;
    GgpFrameToken      frameToken;
 } VkPresentFrameTokenGGP;
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_ios.h
+++ b/include/vulkan/vulkan_ios.h
 #ifndef VULKAN_IOS_H_
 #define VULKAN_IOS_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_MVK_ios_surface 1
 #define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
 #define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
 typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
 typedef struct VkIOSSurfaceCreateInfoMVK {
    VkStructureType               sType;
    const void*                   pNext;
    VkIOSSurfaceCreateFlagsMVK    flags;
    const void*                   pView;
 } VkIOSSurfaceCreateInfoMVK;
 typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
    VkInstance                                  instance,
    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_macos.h
+++ b/include/vulkan/vulkan_macos.h
 #ifndef VULKAN_MACOS_H_
 #define VULKAN_MACOS_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_MVK_macos_surface 1
 #define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
 #define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
 typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
 typedef struct VkMacOSSurfaceCreateInfoMVK {
    VkStructureType                 sType;
    const void*                     pNext;
    VkMacOSSurfaceCreateFlagsMVK    flags;
    const void*                     pView;
 } VkMacOSSurfaceCreateInfoMVK;
 typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
    VkInstance                                  instance,
    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_metal.h
+++ b/include/vulkan/vulkan_metal.h
 #ifndef VULKAN_METAL_H_
 #define VULKAN_METAL_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_EXT_metal_surface 1
 #ifdef __OBJC__
@class CAMetalLayer;
 #else
 typedef void CAMetalLayer;
 #endif
 #define VK_EXT_METAL_SURFACE_SPEC_VERSION 1
 #define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
 typedef VkFlags VkMetalSurfaceCreateFlagsEXT;
 typedef struct VkMetalSurfaceCreateInfoEXT {
    VkStructureType                 sType;
    const void*                     pNext;
    VkMetalSurfaceCreateFlagsEXT    flags;
    const CAMetalLayer*             pLayer;
 } VkMetalSurfaceCreateInfoEXT;
 typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(
    VkInstance                                  instance,
    const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_vi.h
+++ b/include/vulkan/vulkan_vi.h
 #ifndef VULKAN_VI_H_
 #define VULKAN_VI_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_NN_vi_surface 1
 #define VK_NN_VI_SURFACE_SPEC_VERSION     1
 #define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
 typedef VkFlags VkViSurfaceCreateFlagsNN;
 typedef struct VkViSurfaceCreateInfoNN {
    VkStructureType             sType;
    const void*                 pNext;
    VkViSurfaceCreateFlagsNN    flags;
    void*                       window;
 } VkViSurfaceCreateInfoNN;
 typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
    VkInstance                                  instance,
    const VkViSurfaceCreateInfoNN*              pCreateInfo,
    const VkAllocationCallbacks*                pAllocator,
    VkSurfaceKHR*                               pSurface);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_wayland.h
+++ b/include/vulkan/vulkan_wayland.h
 #ifndef VULKAN_WAYLAND_H_
 #define VULKAN_WAYLAND_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_KHR_wayland_surface 1
 #define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
 #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
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_win32.h
+++ b/include/vulkan/vulkan_win32.h
 #ifndef VULKAN_WIN32_H_
 #define VULKAN_WIN32_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_KHR_win32_surface 1
 #define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
 #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
 #define VK_KHR_external_memory_win32 1
 #define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
 #define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
 typedef struct VkImportMemoryWin32HandleInfoKHR {
    VkStructureType                       sType;
    const void*                           pNext;
    VkExternalMemoryHandleTypeFlagBits    handleType;
    HANDLE                                handle;
    LPCWSTR                               name;
 } VkImportMemoryWin32HandleInfoKHR;
 typedef struct VkExportMemoryWin32HandleInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
    LPCWSTR                       name;
 } VkExportMemoryWin32HandleInfoKHR;
 typedef struct VkMemoryWin32HandlePropertiesKHR {
    VkStructureType    sType;
    void*              pNext;
    uint32_t           memoryTypeBits;
 } VkMemoryWin32HandlePropertiesKHR;
 typedef struct VkMemoryGetWin32HandleInfoKHR {
    VkStructureType                       sType;
    const void*                           pNext;
    VkDeviceMemory                        memory;
    VkExternalMemoryHandleTypeFlagBits    handleType;
 } VkMemoryGetWin32HandleInfoKHR;
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
    VkDevice                                    device,
    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
    HANDLE*                                     pHandle);
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
    VkDevice                                    device,
    VkExternalMemoryHandleTypeFlagBits          handleType,
    HANDLE                                      handle,
    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
 #endif
 #define VK_KHR_win32_keyed_mutex 1
 #define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
 #define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
 typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
    VkStructureType          sType;
    const void*              pNext;
    uint32_t                 acquireCount;
    const VkDeviceMemory*    pAcquireSyncs;
    const uint64_t*          pAcquireKeys;
    const uint32_t*          pAcquireTimeouts;
    uint32_t                 releaseCount;
    const VkDeviceMemory*    pReleaseSyncs;
    const uint64_t*          pReleaseKeys;
 } VkWin32KeyedMutexAcquireReleaseInfoKHR;
 #define VK_KHR_external_semaphore_win32 1
 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
 #define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
 typedef struct VkImportSemaphoreWin32HandleInfoKHR {
    VkStructureType                          sType;
    const void*                              pNext;
    VkSemaphore                              semaphore;
    VkSemaphoreImportFlags                   flags;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
    HANDLE                                   handle;
    LPCWSTR                                  name;
 } VkImportSemaphoreWin32HandleInfoKHR;
 typedef struct VkExportSemaphoreWin32HandleInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
    LPCWSTR                       name;
 } VkExportSemaphoreWin32HandleInfoKHR;
 typedef struct VkD3D12FenceSubmitInfoKHR {
    VkStructureType    sType;
    const void*        pNext;
    uint32_t           waitSemaphoreValuesCount;
    const uint64_t*    pWaitSemaphoreValues;
    uint32_t           signalSemaphoreValuesCount;
    const uint64_t*    pSignalSemaphoreValues;
 } VkD3D12FenceSubmitInfoKHR;
 typedef struct VkSemaphoreGetWin32HandleInfoKHR {
    VkStructureType                          sType;
    const void*                              pNext;
    VkSemaphore                              semaphore;
    VkExternalSemaphoreHandleTypeFlagBits    handleType;
 } VkSemaphoreGetWin32HandleInfoKHR;
 typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
 typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
    VkDevice                                    device,
    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
    VkDevice                                    device,
    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
    HANDLE*                                     pHandle);
 #endif
 #define VK_KHR_external_fence_win32 1
 #define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
 #define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
 typedef struct VkImportFenceWin32HandleInfoKHR {
    VkStructureType                      sType;
    const void*                          pNext;
    VkFence                              fence;
    VkFenceImportFlags                   flags;
    VkExternalFenceHandleTypeFlagBits    handleType;
    HANDLE                               handle;
    LPCWSTR                              name;
 } VkImportFenceWin32HandleInfoKHR;
 typedef struct VkExportFenceWin32HandleInfoKHR {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
    LPCWSTR                       name;
 } VkExportFenceWin32HandleInfoKHR;
 typedef struct VkFenceGetWin32HandleInfoKHR {
    VkStructureType                      sType;
    const void*                          pNext;
    VkFence                              fence;
    VkExternalFenceHandleTypeFlagBits    handleType;
 } VkFenceGetWin32HandleInfoKHR;
 typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
 typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
    VkDevice                                    device,
    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
 VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
    VkDevice                                    device,
    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
    HANDLE*                                     pHandle);
 #endif
 #define VK_NV_external_memory_win32 1
 #define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
 #define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
 typedef struct VkImportMemoryWin32HandleInfoNV {
    VkStructureType                      sType;
    const void*                          pNext;
    VkExternalMemoryHandleTypeFlagsNV    handleType;
    HANDLE                               handle;
 } VkImportMemoryWin32HandleInfoNV;
 typedef struct VkExportMemoryWin32HandleInfoNV {
    VkStructureType               sType;
    const void*                   pNext;
    const SECURITY_ATTRIBUTES*    pAttributes;
    DWORD                         dwAccess;
 } VkExportMemoryWin32HandleInfoNV;
 typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
    VkDevice                                    device,
    VkDeviceMemory                              memory,
    VkExternalMemoryHandleTypeFlagsNV           handleType,
    HANDLE*                                     pHandle);
 #endif
 #define VK_NV_win32_keyed_mutex 1
 #define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
 #define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
 typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
    VkStructureType          sType;
    const void*              pNext;
    uint32_t                 acquireCount;
    const VkDeviceMemory*    pAcquireSyncs;
    const uint64_t*          pAcquireKeys;
    const uint32_t*          pAcquireTimeoutMilliseconds;
    uint32_t                 releaseCount;
    const VkDeviceMemory*    pReleaseSyncs;
    const uint64_t*          pReleaseKeys;
 } VkWin32KeyedMutexAcquireReleaseInfoNV;
 #define VK_EXT_full_screen_exclusive 1
 #define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 3
 #define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
 typedef enum VkFullScreenExclusiveEXT {
    VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
    VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
    VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
    VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
    VK_FULL_SCREEN_EXCLUSIVE_BEGIN_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT,
    VK_FULL_SCREEN_EXCLUSIVE_END_RANGE_EXT = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT,
    VK_FULL_SCREEN_EXCLUSIVE_RANGE_SIZE_EXT = (VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT + 1),
    VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
 } VkFullScreenExclusiveEXT;
 typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
    VkStructureType             sType;
    void*                       pNext;
    VkFullScreenExclusiveEXT    fullScreenExclusive;
 } VkSurfaceFullScreenExclusiveInfoEXT;
 typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
    VkStructureType    sType;
    void*              pNext;
    VkBool32           fullScreenExclusiveSupported;
 } VkSurfaceCapabilitiesFullScreenExclusiveEXT;
 typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
    VkStructureType    sType;
    const void*        pNext;
    HMONITOR           hmonitor;
 } VkSurfaceFullScreenExclusiveWin32InfoEXT;
 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
 typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
 typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
 typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
    VkPhysicalDevice                            physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    uint32_t*                                   pPresentModeCount,
    VkPresentModeKHR*                           pPresentModes);
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain);
 VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
    VkDevice                                    device,
    VkSwapchainKHR                              swapchain);
 VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
    VkDevice                                    device,
    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
    VkDeviceGroupPresentModeFlagsKHR*           pModes);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_xcb.h
+++ b/include/vulkan/vulkan_xcb.h
 #ifndef VULKAN_XCB_H_
 #define VULKAN_XCB_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_KHR_xcb_surface 1
 #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
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_xlib.h
+++ b/include/vulkan/vulkan_xlib.h
 #ifndef VULKAN_XLIB_H_
 #define VULKAN_XLIB_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_KHR_xlib_surface 1
 #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
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/include/vulkan/vulkan_xlib_xrandr.h
+++ b/include/vulkan/vulkan_xlib_xrandr.h
 #ifndef VULKAN_XLIB_XRANDR_H_
 #define VULKAN_XLIB_XRANDR_H_ 1
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Copyright (c) 2015-2019 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
 ** You may obtain a copy of the License at
 **
 **     http://www.apache.org/licenses/LICENSE-2.0
 **
 ** Unless required by applicable law or agreed to in writing, software
 ** distributed under the License is distributed on an "AS IS" BASIS,
 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 ** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 /*
 ** This header is generated from the Khronos Vulkan XML API Registry.
 **
 */
 #define VK_EXT_acquire_xlib_display 1
 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
 #define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
 typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
 typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    Display*                                    dpy,
    VkDisplayKHR                                display);
 VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
    VkPhysicalDevice                            physicalDevice,
    Display*                                    dpy,
    RROutput                                    rrOutput,
    VkDisplayKHR*                               pDisplay);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif
--- a/ndk-build.sh
+++ b/ndk-build.sh
 export NDK_PROJECT_PATH=`pwd`
 export NDK_ROOT=/home/hob/android/ndk/
 /home/hob/android/ndk/ndk-build NDK_APPLICATION_MK=./Application.mk
--- a/triangle.cc
+++ b/triangle.cc
 #include <png.h>
 #include <vulkan/vulkan.h>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 #include <string>
 #include <vector>
 const uint32_t kWidth = 256;
 const uint32_t kHeight = 256;
 const VkFormat kVulkanFormat = VK_FORMAT_A8B8G8R8_UNORM_PACK32;
 const std::string kVertexShaderPath = "triangle.vert.spv";
 const std::string kFragmentShaderPath = "triangle.frag.spv";
 #define ERROR(message) \
    std::cerr << message << std::endl; \
    std::exit(EXIT_FAILURE)
 VkInstance CreateVkInstance() {
  VkApplicationInfo app_info = {};
  app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
  app_info.apiVersion = VK_API_VERSION_1_1;
  VkInstanceCreateInfo create_info = {};
  create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
  create_info.pApplicationInfo = &app_info;
  create_info.enabledExtensionCount = 0;
  create_info.ppEnabledExtensionNames = nullptr;
  create_info.enabledLayerCount = 0;
  create_info.ppEnabledLayerNames = nullptr;
  VkInstance instance;
  VkResult result = vkCreateInstance(&create_info, nullptr, &instance);
  if (result != VK_SUCCESS) {
    ERROR("Error creating VkInstance: " << result);
  }
  return instance;
 }
 VkPhysicalDevice ChooseVkPhysicalDevice(VkInstance instance) {
  uint32_t device_count = 0;
  VkResult result = vkEnumeratePhysicalDevices(instance, &device_count, nullptr);
  if (result != VK_SUCCESS) {
    ERROR("Error enumerating VkPhysicalDevices: " << result);
  }
  if (device_count == 0) {
    ERROR("No available VkPhysicalDevices");
  }
  std::vector<VkPhysicalDevice> devices(device_count);
  result = vkEnumeratePhysicalDevices(instance, &device_count, devices.data());
  if (result != VK_SUCCESS) {
    ERROR("Error fetching VkPhysicalDevices: " << result);
  }
  std::cout << "Found " << device_count << " device(s):" << std::endl;
  VkPhysicalDevice chosen_device = VK_NULL_HANDLE;
  for (VkPhysicalDevice device : devices) {
    VkPhysicalDeviceProperties device_props;
    vkGetPhysicalDeviceProperties(device, &device_props);
    std::cout << "\t- " << device_props.deviceName << " [V: " <<
        VK_VERSION_MAJOR(device_props.apiVersion) << "." <<
        VK_VERSION_MINOR(device_props.apiVersion) << "." <<
        VK_VERSION_PATCH(device_props.apiVersion) << "]" << std::endl;
    // Currently, any device with Vulkan API version 1.1 is fine.
    if (chosen_device == VK_NULL_HANDLE && device_props.apiVersion >= VK_API_VERSION_1_1) {
      chosen_device = device;
    }
  }
  if (chosen_device == VK_NULL_HANDLE) {
    ERROR("Unable to find suitable VkPhysicalDevice");
  }
  return chosen_device;
 }
 uint32_t ChooseDeviceQueueFamilyIndex(VkPhysicalDevice physical_device) {
  uint32_t props_count;
  vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &props_count, nullptr);
  std::vector<VkQueueFamilyProperties> props(props_count);
  vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &props_count, props.data());
  // Simply choose the first graphics queue.
  for (size_t i = 0; i < props_count; i++) {
    const VkQueueFamilyProperties& prop = props[i];
    if ((prop.queueFlags & VK_QUEUE_GRAPHICS_BIT) && prop.queueCount > 0) {
      return i;
    }
  }
  ERROR("Unable to find suitable queue family");
 }
 VkDevice CreateVkDevice(VkPhysicalDevice physical_device, uint32_t device_queue_family_index) {
  VkDeviceQueueCreateInfo queue_create_info = {};
  queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
  queue_create_info.queueFamilyIndex = device_queue_family_index;
  queue_create_info.queueCount = 1;
  float queue_priority = 1.0f;
  queue_create_info.pQueuePriorities = &queue_priority;
  VkDeviceCreateInfo device_create_info = {};
  device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
  device_create_info.queueCreateInfoCount = 1;
  device_create_info.pQueueCreateInfos = &queue_create_info;
  // Let's not use any device extensions for now.
  device_create_info.enabledExtensionCount = 0;
  device_create_info.ppEnabledExtensionNames = nullptr;
  VkDevice device;
  VkResult result = vkCreateDevice(physical_device, &device_create_info, nullptr, &device);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create logical device: " << result);
  }
  return device;
 }
 VkQueue GetVkQueue(VkDevice device, uint32_t device_queue_family_index) {
  VkQueue queue;
  vkGetDeviceQueue(device, device_queue_family_index, /*queueIndex*/ 0, &queue);
  return queue;
 }
 VkCommandPool CreateVkCommandPool(VkDevice device, uint32_t device_queue_family_index) {
  VkCommandPool command_pool;
  VkCommandPoolCreateInfo create_info = {};
  create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
  create_info.flags = 0;
  create_info.queueFamilyIndex = device_queue_family_index;
  VkResult result = vkCreateCommandPool(device, &create_info, nullptr, &command_pool);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create command pool: " << result);
  }
  return command_pool;
 }
 VkCommandBuffer CreateVkCommandBuffer(VkDevice device, VkCommandPool command_pool) {
  VkCommandBufferAllocateInfo allocate_info = {};
  allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
  allocate_info.commandPool = command_pool;
  allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
  allocate_info.commandBufferCount = 1;
  VkCommandBuffer command_buffer;
  VkResult result = vkAllocateCommandBuffers( device, &allocate_info, &command_buffer);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create VkCommandBuffer: " << result);
  }
  return command_buffer;
 }
 VkRenderPass CreateVkRenderPass(VkDevice device) {
  VkAttachmentDescription attachment_description = {};
  attachment_description.format = kVulkanFormat;
  attachment_description.samples = VK_SAMPLE_COUNT_1_BIT;
  attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
  attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
  attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
  attachment_description.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  attachment_description.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
  VkAttachmentReference attachment_reference = {};
  attachment_reference.attachment = 0;
  attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  VkSubpassDescription subpass_description = {};
  subpass_description.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
  subpass_description.colorAttachmentCount = 1;
  subpass_description.pColorAttachments = &attachment_reference;
  VkSubpassDependency subpass_dependency = {};
  subpass_dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
  subpass_dependency.dstSubpass = 0;
  subpass_dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
  subpass_dependency.srcAccessMask = 0;
  subpass_dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
  subpass_dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
      VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
  VkRenderPassCreateInfo render_pass_info = {};
  render_pass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
  render_pass_info.attachmentCount = 1;
  render_pass_info.pAttachments = &attachment_description;
  render_pass_info.subpassCount = 1;
  render_pass_info.pSubpasses = &subpass_description;
  render_pass_info.dependencyCount = 1;
  render_pass_info.pDependencies = &subpass_dependency;
  VkRenderPass render_pass;
  VkResult result = vkCreateRenderPass(device, &render_pass_info, nullptr, &render_pass);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create render pass: " << result);
  }
  return render_pass;
 }
 VkShaderModule CreateVkShaderModule(VkDevice device, std::string path) {
  std::ifstream fstream(path);
  if (!fstream) {
    ERROR("Unable to open: " << path);
  }
  std::stringstream buffer;
  buffer << fstream.rdbuf();
  std::string spirv_source = buffer.str();
  VkShaderModuleCreateInfo create_info = {};
  create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
  create_info.codeSize = spirv_source.length();
  create_info.pCode = (const uint32_t*)spirv_source.c_str();
  VkShaderModule shader_module;
  VkResult result = vkCreateShaderModule(device, &create_info, nullptr, &shader_module);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create shader module for " << path << ": ");
  }
  return shader_module;
 }
 VkPipeline CreateVkPipeline(VkDevice device, VkRenderPass render_pass) {
  VkShaderModule vertex_shader_module = CreateVkShaderModule(device, kVertexShaderPath);
  VkShaderModule fragment_shader_module = CreateVkShaderModule(device, kFragmentShaderPath);
  VkPipelineShaderStageCreateInfo vertex_shader_stage_info = {};
  vertex_shader_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
  vertex_shader_stage_info.stage = VK_SHADER_STAGE_VERTEX_BIT;
  vertex_shader_stage_info.module = vertex_shader_module;
  vertex_shader_stage_info.pName = "main";
  VkPipelineShaderStageCreateInfo fragment_shader_stage_info = {};
  fragment_shader_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
  fragment_shader_stage_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
  fragment_shader_stage_info.module = fragment_shader_module;
  fragment_shader_stage_info.pName = "main";
  std::vector<VkPipelineShaderStageCreateInfo> shader_stages =
      {vertex_shader_stage_info, fragment_shader_stage_info};
  VkPipelineVertexInputStateCreateInfo vertex_input_info = {};
  vertex_input_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
  vertex_input_info.vertexBindingDescriptionCount = 0;
  vertex_input_info.pVertexBindingDescriptions = nullptr;
  vertex_input_info.vertexAttributeDescriptionCount = 0;
  vertex_input_info.pVertexAttributeDescriptions = nullptr;
  VkPipelineInputAssemblyStateCreateInfo input_assembly_info = {};
  input_assembly_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
  input_assembly_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
  input_assembly_info.primitiveRestartEnable = VK_FALSE;
  VkViewport viewport = {};
  viewport.x = 0.0f;
  viewport.y = 0.0f;
  viewport.width = (float)kWidth;
  viewport.height = (float)kHeight;
  viewport.minDepth = 0.0f;
  viewport.maxDepth = 1.0f;
  VkExtent2D extent = {};
  extent.width = kWidth;
  extent.height = kHeight;
  VkRect2D scissor = {};
  scissor.offset = {0, 0};
  scissor.extent = extent;
  VkPipelineViewportStateCreateInfo viewport_state_info = {};
  viewport_state_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
  viewport_state_info.viewportCount = 1;
  viewport_state_info.pViewports = &viewport;
  viewport_state_info.scissorCount = 1;
  viewport_state_info.pScissors = &scissor;
  VkPipelineRasterizationStateCreateInfo rasterization_state_info = {};
  rasterization_state_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
  rasterization_state_info.depthClampEnable = VK_FALSE;
  rasterization_state_info.rasterizerDiscardEnable = VK_FALSE;
  rasterization_state_info.polygonMode = VK_POLYGON_MODE_FILL;
  rasterization_state_info.lineWidth = 1.0f;
  rasterization_state_info.cullMode = VK_CULL_MODE_BACK_BIT;
  rasterization_state_info.frontFace = VK_FRONT_FACE_CLOCKWISE;
  rasterization_state_info.depthBiasEnable = VK_FALSE;
  VkPipelineMultisampleStateCreateInfo multisampling_state_info = {};
  multisampling_state_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
  multisampling_state_info.sampleShadingEnable = VK_FALSE;
  multisampling_state_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
  VkPipelineColorBlendAttachmentState color_blend_attachment_state = {};
  color_blend_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT |
      VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
  color_blend_attachment_state.blendEnable = VK_FALSE;
  VkPipelineColorBlendStateCreateInfo color_blend_state = {};
  color_blend_state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
  color_blend_state.logicOpEnable = VK_FALSE;
  color_blend_state.attachmentCount = 1;
  color_blend_state.pAttachments = &color_blend_attachment_state;
  VkPipelineLayoutCreateInfo pipeline_layout_create_info = {};
  pipeline_layout_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
  VkPipelineLayout pipeline_layout;
  VkResult result = vkCreatePipelineLayout(device, &pipeline_layout_create_info, nullptr,
      &pipeline_layout);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create VkPipelineLayout: " << result);
  }
  VkGraphicsPipelineCreateInfo pipeline_create_info = {};
  pipeline_create_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
  pipeline_create_info.stageCount = 2;
  pipeline_create_info.pStages = shader_stages.data();
  pipeline_create_info.pVertexInputState = &vertex_input_info;
  pipeline_create_info.pInputAssemblyState = &input_assembly_info;
  pipeline_create_info.pViewportState = &viewport_state_info;
  pipeline_create_info.pRasterizationState = &rasterization_state_info;
  pipeline_create_info.pMultisampleState = &multisampling_state_info;
  pipeline_create_info.pDepthStencilState = nullptr;
  pipeline_create_info.pColorBlendState = &color_blend_state;
  pipeline_create_info.pDynamicState = nullptr;
  pipeline_create_info.layout = pipeline_layout;
  pipeline_create_info.renderPass = render_pass;
  pipeline_create_info.subpass = 0;
  pipeline_create_info.basePipelineHandle = VK_NULL_HANDLE;
  pipeline_create_info.basePipelineIndex = -1;
  VkPipeline pipeline;
  result = vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipeline_create_info, nullptr,
      &pipeline);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create VkPipeline: " << result);
  }
  return pipeline;
 }
 VkImage CreateVkImage(VkDevice device, VkImageTiling image_tiling, VkImageUsageFlags usage) {
  VkImageCreateInfo create_info = {};
  create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
  create_info.pNext = nullptr;
  create_info.imageType = VK_IMAGE_TYPE_2D;
  create_info.format = kVulkanFormat;
  VkExtent3D extent  = {};
  extent.width = kWidth;
  extent.height = kHeight;
  extent.depth = 1;
  create_info.extent = extent;
  create_info.mipLevels = 1;
  create_info.arrayLayers = 1;
  create_info.samples = VK_SAMPLE_COUNT_1_BIT;
  create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  create_info.tiling = image_tiling;
  create_info.usage = usage;
  create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  VkImage image;
  VkResult result = vkCreateImage(device, &create_info, nullptr, &image);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create VkImage: " << result);
  }
  return image;
 }
 inline VkImage CreateRenderVkImage(VkDevice device) {
  return CreateVkImage(device, VK_IMAGE_TILING_OPTIMAL,
      VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
 }
 inline VkImage CreateScanoutVkImage(VkDevice device) {
  return CreateVkImage(device, VK_IMAGE_TILING_LINEAR,
      VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
 }
 uint32_t FindMemoryType(uint32_t valid_image_memory_types,
    VkPhysicalDeviceMemoryProperties device_memory_properties,
    VkMemoryPropertyFlags memory_property_flags) {
  for (uint32_t i = 0; i < device_memory_properties.memoryTypeCount; i++) {
    // We don't care about performance, so just choose the first mappable memory type.
    if ((valid_image_memory_types & (1 << i)) &&
        ((device_memory_properties.memoryTypes[i].propertyFlags & memory_property_flags) ==
        memory_property_flags)) {
      return i;
    }
  }
  ERROR("Unable to find suitable memory type index");
 }
 VkDeviceMemory AllocateAndBindMemory(VkPhysicalDevice physical_device, VkDevice device,
    VkImage image, VkMemoryPropertyFlags memory_property_flags) {
  VkMemoryRequirements image_memory_requirements;
  vkGetImageMemoryRequirements(device, image, &image_memory_requirements);
  VkPhysicalDeviceMemoryProperties device_memory_properties;
  vkGetPhysicalDeviceMemoryProperties(physical_device, &device_memory_properties);
  VkMemoryAllocateInfo memory_allocate_info = {};
  memory_allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  memory_allocate_info.allocationSize = image_memory_requirements.size;
  memory_allocate_info.memoryTypeIndex = FindMemoryType(
      image_memory_requirements.memoryTypeBits, device_memory_properties,
      memory_property_flags);
  VkDeviceMemory image_memory;
  VkResult result = vkAllocateMemory(device, &memory_allocate_info, nullptr, &image_memory);
  if (result != VK_SUCCESS) {
    ERROR("Unable to allocate image memory: " << result);
  }
  result = vkBindImageMemory(device, image, image_memory, 0);
  if (result != VK_SUCCESS) {
    ERROR("Unable to bind image memory: " << result);
  }
  return image_memory;
 }
 inline VkDeviceMemory AllocateAndBindRenderMemory(VkPhysicalDevice physical_device,
    VkDevice device, VkImage image) {
  return AllocateAndBindMemory(physical_device, device, image, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 }
 inline VkDeviceMemory AllocateAndBindScanoutMemory(VkPhysicalDevice physical_device,
    VkDevice device, VkImage image) {
  return AllocateAndBindMemory(physical_device, device, image, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
 }
 VkImageView CreateVkImageView(VkDevice device, VkImage image) {
  VkImageViewCreateInfo create_info = {};
  create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
  create_info.image = image;
  create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
  create_info.format = kVulkanFormat;
  VkComponentMapping component_mapping = {};
  component_mapping.r = VK_COMPONENT_SWIZZLE_IDENTITY;
  component_mapping.b = VK_COMPONENT_SWIZZLE_IDENTITY;
  component_mapping.g = VK_COMPONENT_SWIZZLE_IDENTITY;
  component_mapping.a = VK_COMPONENT_SWIZZLE_IDENTITY;
  create_info.components = component_mapping;
  VkImageSubresourceRange subresource_range = {};
  subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  subresource_range.baseMipLevel = 0;
  subresource_range.levelCount = 1;
  subresource_range.baseArrayLayer = 0;
  subresource_range.layerCount = 1;
  create_info.subresourceRange = subresource_range;
  VkImageView image_view;
  VkResult result = vkCreateImageView(device, &create_info, nullptr, &image_view);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create VkImageView: " << result);
  }
  return image_view;
 }
 VkFramebuffer CreateVkFramebuffer(VkDevice device, VkRenderPass render_pass,
    VkImageView image_view) {
  VkFramebufferCreateInfo create_info = {};
  create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
  create_info.renderPass = render_pass;
  create_info.attachmentCount = 1;
  create_info.pAttachments = &image_view;
  create_info.width = kWidth;
  create_info.height = kHeight;
  create_info.layers = 1;
  VkFramebuffer framebuffer;
  VkResult result = vkCreateFramebuffer(device, &create_info, nullptr, &framebuffer);
  if (result != VK_SUCCESS) {
    ERROR("Unable to create VkFramebuffer: " << result);
  }
  return framebuffer;
 }
 void BeginCommandBuffer(VkCommandBuffer command_buffer) {
  VkCommandBufferBeginInfo command_buffer_begin_info = {};
  command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
  command_buffer_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
  VkResult result = vkBeginCommandBuffer(command_buffer, &command_buffer_begin_info);
  if (result != VK_SUCCESS) {
    ERROR("Unable to begin command buffer recording: " << result);
  }
 }
 void EndCommandBufferAndSubmit(VkCommandBuffer command_buffer, VkQueue queue) {
  VkResult result = vkEndCommandBuffer(command_buffer);
  if (result != VK_SUCCESS) {
    ERROR("Unable to end command buffer recording: " << result);
  }
  VkSubmitInfo submit_info = {};
  submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
  submit_info.commandBufferCount = 1;
  submit_info.pCommandBuffers = &command_buffer;
  result = vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
  if (result != VK_SUCCESS) {
    ERROR("Error in submitting command buffer to queue: " << result);
  }
 }
 void WaitForIdle(VkQueue queue) {
  // In a real application, we should use real synchronization primitives to figure out when the
  // command buffers have been executed. Waiting on an idle queue is simple, but it can cause
  // deadlock if we continue to submit to the queue while we wait for idle.
  VkResult result = vkQueueWaitIdle(queue);
  if (result != VK_SUCCESS) {
    ERROR("Error in waiting for graphics queue to reach idle state: " << result);
  }
 }
 void Draw(VkDevice device, VkQueue queue, VkRenderPass render_pass, VkPipeline pipeline,
    VkFramebuffer framebuffer, VkCommandBuffer command_buffer) {
  BeginCommandBuffer(command_buffer);
  VkRenderPassBeginInfo render_pass_begin_info = {};
  render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
  render_pass_begin_info.renderPass = render_pass;
  render_pass_begin_info.framebuffer = framebuffer;
  VkRect2D render_area = {};
  render_area.offset = { 0, 0 };
  render_area.extent = { kWidth, kHeight };
  render_pass_begin_info.renderArea = render_area;
  render_pass_begin_info.clearValueCount = 1;
  VkClearValue clear_value = {};
  clear_value.color.float32[0] = 1.0f;
  clear_value.color.float32[1] = 1.0f;
  clear_value.color.float32[2] = 0.0f;
  clear_value.color.float32[3] = 1.0f;
  render_pass_begin_info.pClearValues = &clear_value;
  vkCmdBeginRenderPass(command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
  vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
  vkCmdDraw(command_buffer, 3, 1, 0, 0);
  vkCmdEndRenderPass(command_buffer);
 }
 void BlitToScanoutImage(VkQueue queue, VkCommandBuffer command_buffer, VkImage source_image,
    VkImage dest_image) {
  // We need to make sure the writes of the render pass have executed before actually scanning out
  // the rendered image. Also, we need to transition the layout of the scanout image to
  // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL.
  VkImageMemoryBarrier image_memory_barrier = {};
  image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
  image_memory_barrier.pNext = nullptr;
  image_memory_barrier.srcAccessMask = 0;
  image_memory_barrier.dstAccessMask = 0;
  image_memory_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  image_memory_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
  image_memory_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  image_memory_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  image_memory_barrier.image = dest_image;
  VkImageSubresourceRange subresource_range = {};
  subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  subresource_range.baseMipLevel = 0;
  subresource_range.levelCount = 1;
  subresource_range.baseArrayLayer = 0;
  subresource_range.layerCount = 1;
  image_memory_barrier.subresourceRange = subresource_range;
  vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
      VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
  VkOffset3D blit_start = {};
  blit_start.x = 0;
  blit_start.y = 0;
  blit_start.z = 0;
  VkOffset3D blit_end = {};
  blit_end.x = kWidth;
  blit_end.y = kHeight;
  blit_end.z = 1;
  VkImageSubresourceLayers subresource_layers = {};
  subresource_layers.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  subresource_layers.mipLevel = 0;
  subresource_layers.baseArrayLayer = 0;
  subresource_layers.layerCount = 1;
  VkImageBlit image_blit = {};
  image_blit.srcSubresource = subresource_layers;
  image_blit.srcOffsets[0] = blit_start;
  image_blit.srcOffsets[1] = blit_end;
  image_blit.dstSubresource = subresource_layers;
  image_blit.dstOffsets[0] = blit_start;
  image_blit.dstOffsets[1] = blit_end;
  // TODO(brkho): Support multi-planar formats.
  vkCmdBlitImage(command_buffer, source_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dest_image,
      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &image_blit, VK_FILTER_NEAREST);
  EndCommandBufferAndSubmit(command_buffer, queue);
 }
 uint8_t* MapVkDeviceMemory(VkDevice device, VkDeviceMemory image_memory) {
  void* mapped_memory = nullptr;
  VkResult result = vkMapMemory(device, image_memory, 0, kWidth * kHeight * 4, 0, &mapped_memory);
  if (result != VK_SUCCESS) {
    ERROR("Unable to map device memory: " << result);
  }
  return static_cast<uint8_t*>(mapped_memory);
 }
 void WriteImage(uint8_t* pixels) {
  FILE *f = fopen("triangle.png", "wb");
  png_image image_info = {};
  image_info.version = PNG_IMAGE_VERSION;
  image_info.width = kWidth;
  image_info.height = kHeight;
  image_info.format = PNG_FORMAT_RGBA;
  if (png_image_write_to_stdio(&image_info, f, 0, pixels, kWidth * 4, nullptr) == 0) {
    ERROR("Error writing PNG: " << image_info.message);
  }
  fclose(f);
 }
 int main() {
  VkInstance instance = CreateVkInstance();
  VkPhysicalDevice physical_device = ChooseVkPhysicalDevice(instance);
  uint32_t device_queue_family_index = ChooseDeviceQueueFamilyIndex(physical_device);
  VkDevice device = CreateVkDevice(physical_device, device_queue_family_index);
  VkQueue queue = GetVkQueue(device, device_queue_family_index);
  VkCommandPool command_pool = CreateVkCommandPool(device, device_queue_family_index);
  VkCommandBuffer command_buffer = CreateVkCommandBuffer(device, command_pool);
  VkRenderPass render_pass = CreateVkRenderPass(device);
  VkPipeline pipeline = CreateVkPipeline(device, render_pass);
  VkImage render_image = CreateRenderVkImage(device);
  AllocateAndBindRenderMemory(physical_device, device, render_image);
  VkImageView render_image_view = CreateVkImageView(device, render_image);
  VkFramebuffer framebuffer = CreateVkFramebuffer(device, render_pass, render_image_view);
  VkImage scanout_image = CreateScanoutVkImage(device);
  VkDeviceMemory scanout_image_memory =
      AllocateAndBindScanoutMemory(physical_device, device, scanout_image);
  Draw(device, queue, render_pass, pipeline, framebuffer, command_buffer);
  // Since the render target is created with VK_IMAGE_TILING_OPTIMAL, we need to copy it to a linear
  // format before scanning out.
  BlitToScanoutImage(queue, command_buffer, render_image, scanout_image);
  WaitForIdle(queue);
  uint8_t* pixels = MapVkDeviceMemory(device, scanout_image_memory);
  WriteImage(pixels);
  return EXIT_SUCCESS;
 }
--- a/triangle.frag
+++ b/triangle.frag
 #version 450
 #extension GL_ARB_separate_shader_objects : enable
 layout(location = 0) in vec3 fragColor;
 layout(location = 0) out vec4 outColor;
 void main() {
    outColor = vec4(fragColor, 1.0);
 }
--- a/triangle.vert
+++ b/triangle.vert
 #version 450
 #extension GL_ARB_separate_shader_objects : enable
 layout(location = 0) out vec3 fragColor;
 vec2 positions[3] = vec2[](
    vec2(0.0, -0.5),
    vec2(0.5, 0.5),
    vec2(-0.5, 0.5)
 );
 vec3 colors[3] = vec3[](
    vec3(1.0, 0.0, 0.0),
    vec3(0.0, 1.0, 0.0),
    vec3(0.0, 0.0, 1.0)
 );
 void main() {
    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
    fragColor = colors[gl_VertexIndex];
 }