text: /*
   * Copyright 2011-2018 Branimir Karadzic. All rights reserved.
   * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
   */
  
  #include "bgfx_p.h"
  
  #if BGFX_CONFIG_RENDERER_VULKAN
  #	include "renderer_vk.h"
  
  namespace bgfx { namespace vk
  {
  	static char s_viewName[BGFX_CONFIG_MAX_VIEWS][256];
  
  	struct PrimInfo
  	{
  		VkPrimitiveTopology m_topology;
  		uint32_t m_min;
  		uint32_t m_div;
  		uint32_t m_sub;
  	};
  
  	static const PrimInfo s_primInfo[] =
  	{
  		{ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,  3, 3, 0 },
  		{ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, 3, 1, 2 },
  		{ VK_PRIMITIVE_TOPOLOGY_LINE_LIST,      2, 2, 0 },
  		{ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,     2, 1, 1 },
  		{ VK_PRIMITIVE_TOPOLOGY_POINT_LIST,     1, 1, 0 },
  		{ VK_PRIMITIVE_TOPOLOGY_MAX_ENUM,       0, 0, 0 },
  	};
  	BX_STATIC_ASSERT(Topology::Count == BX_COUNTOF(s_primInfo)-1);
  
  	static const uint32_t s_checkMsaa[] =
  	{
  		0,
  		2,
  		4,
  		8,
  		16,
  	};
  
  //	static DXGI_SAMPLE_DESC s_msaa[] =
  //	{
  //		{  1, 0 },
  //		{  2, 0 },
  //		{  4, 0 },
  //		{  8, 0 },
  //		{ 16, 0 },
  //	};
  
  	static const VkBlendFactor s_blendFactor[][2] =
  	{
  		{ VkBlendFactor(0),                         VkBlendFactor(0)                         }, // ignored
  		{ VK_BLEND_FACTOR_ZERO,                     VK_BLEND_FACTOR_ZERO                     }, // ZERO
  		{ VK_BLEND_FACTOR_ONE,                      VK_BLEND_FACTOR_ONE                      }, // ONE
  		{ VK_BLEND_FACTOR_SRC_COLOR,                VK_BLEND_FACTOR_SRC_ALPHA                }, // SRC_COLOR
  		{ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,      VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA      }, // INV_SRC_COLOR
  		{ VK_BLEND_FACTOR_SRC_ALPHA,                VK_BLEND_FACTOR_SRC_ALPHA                }, // SRC_ALPHA
  		{ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,      VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA      }, // INV_SRC_ALPHA
  		{ VK_BLEND_FACTOR_DST_ALPHA,                VK_BLEND_FACTOR_DST_ALPHA                }, // DST_ALPHA
  		{ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,      VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA      }, // INV_DST_ALPHA
  		{ VK_BLEND_FACTOR_DST_COLOR,                VK_BLEND_FACTOR_DST_ALPHA                }, // DST_COLOR
  		{ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,      VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA      }, // INV_DST_COLOR
  		{ VK_BLEND_FACTOR_SRC_ALPHA,                VK_BLEND_FACTOR_ONE                      }, // SRC_ALPHA_SAT
  		{ VK_BLEND_FACTOR_CONSTANT_COLOR,           VK_BLEND_FACTOR_CONSTANT_COLOR           }, // FACTOR
  		{ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR }, // INV_FACTOR
  	};
  
  	static const VkBlendOp s_blendEquation[] =
  	{
  		VK_BLEND_OP_ADD,
  		VK_BLEND_OP_SUBTRACT,
  		VK_BLEND_OP_REVERSE_SUBTRACT,
  		VK_BLEND_OP_MIN,
  		VK_BLEND_OP_MAX,
  	};
  
  	static const VkCompareOp s_cmpFunc[] =
  	{
  		VkCompareOp(0), // ignored
  		VK_COMPARE_OP_LESS,
  		VK_COMPARE_OP_LESS_OR_EQUAL,
  		VK_COMPARE_OP_EQUAL,
  		VK_COMPARE_OP_GREATER_OR_EQUAL,
  		VK_COMPARE_OP_GREATER,
  		VK_COMPARE_OP_NOT_EQUAL,
  		VK_COMPARE_OP_NEVER,
  		VK_COMPARE_OP_ALWAYS,
  	};
  
  	static const VkStencilOp s_stencilOp[] =
  	{
  		VK_STENCIL_OP_ZERO,
  		VK_STENCIL_OP_KEEP,
  		VK_STENCIL_OP_REPLACE,
  		VK_STENCIL_OP_INCREMENT_AND_WRAP,
  		VK_STENCIL_OP_INCREMENT_AND_CLAMP,
  		VK_STENCIL_OP_DECREMENT_AND_WRAP,
  		VK_STENCIL_OP_DECREMENT_AND_CLAMP,
  		VK_STENCIL_OP_INVERT,
  	};
  
  	static const VkCullModeFlagBits s_cullMode[] =
  	{
  		VK_CULL_MODE_NONE,
  		VK_CULL_MODE_FRONT_BIT,
  		VK_CULL_MODE_BACK_BIT,
  	};
  
  	static const VkSamplerAddressMode s_textureAddress[] =
  	{
  		VK_SAMPLER_ADDRESS_MODE_REPEAT,
  		VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
  		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
  		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
  	};
  
  #define VK_IMPORT_FUNC(_optional, _func) PFN_##_func _func
  #define VK_IMPORT_INSTANCE_FUNC VK_IMPORT_FUNC
  #define VK_IMPORT_DEVICE_FUNC   VK_IMPORT_FUNC
  VK_IMPORT
  VK_IMPORT_INSTANCE
  VK_IMPORT_DEVICE
  #undef VK_IMPORT_DEVICE_FUNC
  #undef VK_IMPORT_INSTANCE_FUNC
  #undef VK_IMPORT_FUNC
  
  	struct TextureFormatInfo
  	{
  		VkFormat m_fmt;
  		VkFormat m_fmtSrv;
  		VkFormat m_fmtDsv;
  		VkFormat m_fmtSrgb;
  	};
  
  	static const TextureFormatInfo s_textureFormat[] =
  	{
  		{ VK_FORMAT_BC1_RGB_UNORM_BLOCK,       VK_FORMAT_BC1_RGB_UNORM_BLOCK,      VK_FORMAT_UNDEFINED,           VK_FORMAT_BC1_RGB_SRGB_BLOCK       }, // BC1
  		{ VK_FORMAT_BC2_UNORM_BLOCK,           VK_FORMAT_BC2_UNORM_BLOCK,          VK_FORMAT_UNDEFINED,           VK_FORMAT_BC2_SRGB_BLOCK           }, // BC2
  		{ VK_FORMAT_BC3_UNORM_BLOCK,           VK_FORMAT_BC3_UNORM_BLOCK,          VK_FORMAT_UNDEFINED,           VK_FORMAT_BC3_SRGB_BLOCK           }, // BC3
  		{ VK_FORMAT_BC4_UNORM_BLOCK,           VK_FORMAT_BC4_UNORM_BLOCK,          VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // BC4
  		{ VK_FORMAT_BC5_UNORM_BLOCK,           VK_FORMAT_BC5_UNORM_BLOCK,          VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // BC5
  		{ VK_FORMAT_BC6H_SFLOAT_BLOCK,         VK_FORMAT_BC6H_SFLOAT_BLOCK,        VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // BC6H
  		{ VK_FORMAT_BC7_UNORM_BLOCK,           VK_FORMAT_BC7_UNORM_BLOCK,          VK_FORMAT_UNDEFINED,           VK_FORMAT_BC7_SRGB_BLOCK           }, // BC7
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ETC1
  		{ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,   VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK   }, // ETC2
  		{ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK }, // ETC2A
  		{ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK }, // ETC2A1
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // PTC12
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // PTC14
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // PTC12A
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // PTC14A
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // PTC22
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // PTC24
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ATC
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ATCE
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ATCI
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ASTC4x4
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ASTC5x5
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ASTC6x6
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ASTC8x5
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ASTC8x6
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // ASTC10x5
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // Unknown
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R1
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // A8
  		{ VK_FORMAT_R8_UNORM,                  VK_FORMAT_R8_UNORM,                 VK_FORMAT_UNDEFINED,           VK_FORMAT_R8_SRGB                  }, // R8
  		{ VK_FORMAT_R8_SINT,                   VK_FORMAT_R8_SINT,                  VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R8I
  		{ VK_FORMAT_R8_UINT,                   VK_FORMAT_R8_UINT,                  VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R8U
  		{ VK_FORMAT_R8_SNORM,                  VK_FORMAT_R8_SNORM,                 VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R8S
  		{ VK_FORMAT_R16_UNORM,                 VK_FORMAT_R16_UNORM,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R16
  		{ VK_FORMAT_R16_SINT,                  VK_FORMAT_R16_SINT,                 VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R16I
  		{ VK_FORMAT_R16_UNORM,                 VK_FORMAT_R16_UNORM,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R16U
  		{ VK_FORMAT_R16_SFLOAT,                VK_FORMAT_R16_SFLOAT,               VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R16F
  		{ VK_FORMAT_R16_SNORM,                 VK_FORMAT_R16_SNORM,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R16S
  		{ VK_FORMAT_R32_SINT,                  VK_FORMAT_R32_SINT,                 VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R32I
  		{ VK_FORMAT_R32_UINT,                  VK_FORMAT_R32_UINT,                 VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R32U
  		{ VK_FORMAT_R32_SFLOAT,                VK_FORMAT_R32_SFLOAT,               VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R32F
  		{ VK_FORMAT_R8G8_UNORM,                VK_FORMAT_R8G8_UNORM,               VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8_SRGB                }, // RG8
  		{ VK_FORMAT_R8G8_SINT,                 VK_FORMAT_R8G8_SINT,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG8I
  		{ VK_FORMAT_R8G8_UINT,                 VK_FORMAT_R8G8_UINT,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG8U
  		{ VK_FORMAT_R8G8_SNORM,                VK_FORMAT_R8G8_SNORM,               VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG8S
  		{ VK_FORMAT_R16G16_UNORM,              VK_FORMAT_R16G16_UNORM,             VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG16
  		{ VK_FORMAT_R16G16_SINT,               VK_FORMAT_R16G16_SINT,              VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG16I
  		{ VK_FORMAT_R16G16_UINT,               VK_FORMAT_R16G16_UINT,              VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG16U
  		{ VK_FORMAT_R16G16_SFLOAT,             VK_FORMAT_R16G16_SFLOAT,            VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG16F
  		{ VK_FORMAT_R16G16_SNORM,              VK_FORMAT_R16G16_SNORM,             VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG16S
  		{ VK_FORMAT_R32G32_SINT,               VK_FORMAT_R32G32_SINT,              VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG32I
  		{ VK_FORMAT_R32G32_UINT,               VK_FORMAT_R32G32_UINT,              VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG32U
  		{ VK_FORMAT_R32G32_SFLOAT,             VK_FORMAT_R32G32_SFLOAT,            VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG32F
  		{ VK_FORMAT_R8G8B8_UNORM,              VK_FORMAT_R8G8B8_UNORM,             VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8B8_SRGB              }, // RGB8
  		{ VK_FORMAT_R8G8B8_SINT,               VK_FORMAT_R8G8B8_SINT,              VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8B8_SRGB              }, // RGB8I
  		{ VK_FORMAT_R8G8B8_UINT,               VK_FORMAT_R8G8B8_UINT,              VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8B8_SRGB              }, // RGB8U
  		{ VK_FORMAT_R8G8B8_SNORM,              VK_FORMAT_R8G8B8_SNORM,             VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGB8S
  		{ VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,   VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGB9E5F
  		{ VK_FORMAT_B8G8R8A8_UNORM,            VK_FORMAT_B8G8R8A8_UNORM,           VK_FORMAT_UNDEFINED,           VK_FORMAT_B8G8R8A8_SRGB            }, // BGRA8
  		{ VK_FORMAT_R8G8B8A8_UNORM,            VK_FORMAT_R8G8B8A8_UNORM,           VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8B8A8_SRGB            }, // RGBA8
  		{ VK_FORMAT_R8G8B8A8_SINT,             VK_FORMAT_R8G8B8A8_SINT,            VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8B8A8_SRGB            }, // RGBA8I
  		{ VK_FORMAT_R8G8B8A8_UINT,             VK_FORMAT_R8G8B8A8_UINT,            VK_FORMAT_UNDEFINED,           VK_FORMAT_R8G8B8A8_SRGB            }, // RGBA8U
  		{ VK_FORMAT_R8G8B8A8_SNORM,            VK_FORMAT_R8G8B8A8_SNORM,           VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA8S
  		{ VK_FORMAT_R16G16B16A16_UNORM,        VK_FORMAT_R16G16B16A16_UNORM,       VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA16
  		{ VK_FORMAT_R16G16B16A16_SINT,         VK_FORMAT_R16G16B16A16_SINT,        VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA16I
  		{ VK_FORMAT_R16G16B16A16_UINT,         VK_FORMAT_R16G16B16A16_UINT,        VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA16U
  		{ VK_FORMAT_R16G16B16A16_SFLOAT,       VK_FORMAT_R16G16B16A16_SFLOAT,      VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA16F
  		{ VK_FORMAT_R16G16B16A16_SNORM,        VK_FORMAT_R16G16B16A16_SNORM,       VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA16S
  		{ VK_FORMAT_R32G32B32A32_SINT,         VK_FORMAT_R32G32B32A32_SINT,        VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA32I
  		{ VK_FORMAT_R32G32B32A32_UINT,         VK_FORMAT_R32G32B32A32_UINT,        VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA32U
  		{ VK_FORMAT_R32G32B32A32_SFLOAT,       VK_FORMAT_R32G32B32A32_SFLOAT,      VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA32F
  		{ VK_FORMAT_B5G6R5_UNORM_PACK16,       VK_FORMAT_B5G6R5_UNORM_PACK16,      VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // R5G6B5
  		{ VK_FORMAT_B4G4R4A4_UNORM_PACK16,     VK_FORMAT_B4G4R4A4_UNORM_PACK16,    VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGBA4
  		{ VK_FORMAT_B5G5R5A1_UNORM_PACK16,     VK_FORMAT_B5G5R5A1_UNORM_PACK16,    VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGB5A1
  		{ VK_FORMAT_A2R10G10B10_UNORM_PACK32,  VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RGB10A2
  		{ VK_FORMAT_B10G11R11_UFLOAT_PACK32,   VK_FORMAT_B10G11R11_UFLOAT_PACK32,  VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // RG11B10F
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_UNDEFINED,                VK_FORMAT_UNDEFINED,           VK_FORMAT_UNDEFINED                }, // UnknownDepth
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_R16_UNORM,                VK_FORMAT_D16_UNORM,           VK_FORMAT_UNDEFINED                }, // D16
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_X8_D24_UNORM_PACK32,      VK_FORMAT_D24_UNORM_S8_UINT,   VK_FORMAT_UNDEFINED                }, // D24
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_X8_D24_UNORM_PACK32,      VK_FORMAT_D24_UNORM_S8_UINT,   VK_FORMAT_UNDEFINED                }, // D24S8
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_X8_D24_UNORM_PACK32,      VK_FORMAT_D24_UNORM_S8_UINT,   VK_FORMAT_UNDEFINED                }, // D32
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_R32_SFLOAT,               VK_FORMAT_D32_SFLOAT,          VK_FORMAT_UNDEFINED                }, // D16F
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_R32_SFLOAT,               VK_FORMAT_D32_SFLOAT,          VK_FORMAT_UNDEFINED                }, // D24F
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_R32_SFLOAT,               VK_FORMAT_D32_SFLOAT,          VK_FORMAT_UNDEFINED                }, // D32F
  		{ VK_FORMAT_UNDEFINED,                 VK_FORMAT_X8_D24_UNORM_PACK32,      VK_FORMAT_D24_UNORM_S8_UINT,   VK_FORMAT_UNDEFINED                }, // D0S8
  	};
  	BX_STATIC_ASSERT(TextureFormat::Count == BX_COUNTOF(s_textureFormat) );
  
  	static const VkFormat s_attribType[][4][2] =
  	{
  		{ // Uint8
  			{ VK_FORMAT_R8_UINT,                 VK_FORMAT_R8_UNORM                 },
  			{ VK_FORMAT_R8G8_UINT,               VK_FORMAT_R8G8_UNORM               },
  			{ VK_FORMAT_R8G8B8A8_UINT,           VK_FORMAT_R8G8B8A8_UNORM           },
  			{ VK_FORMAT_R8G8B8A8_UINT,           VK_FORMAT_R8G8B8A8_UNORM           },
  		},
  		{ // Uint10
  			{ VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
  			{ VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
  			{ VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
  			{ VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
  		},
  		{ // Int16
  			{ VK_FORMAT_R16_SINT,                VK_FORMAT_R16_SNORM                },
  			{ VK_FORMAT_R16G16_SINT,             VK_FORMAT_R16G16_SNORM             },
  			{ VK_FORMAT_R16G16B16_SINT,          VK_FORMAT_R16G16B16_SNORM          },
  			{ VK_FORMAT_R16G16B16A16_SINT,       VK_FORMAT_R16G16B16A16_SNORM       },
  		},
  		{ // Half
  			{ VK_FORMAT_R16_SFLOAT,              VK_FORMAT_R16_SFLOAT               },
  			{ VK_FORMAT_R16G16_SFLOAT,           VK_FORMAT_R16G16_SFLOAT            },
  			{ VK_FORMAT_R16G16B16_SFLOAT,        VK_FORMAT_R16G16B16_SFLOAT         },
  			{ VK_FORMAT_R16G16B16A16_SFLOAT,     VK_FORMAT_R16G16B16A16_SFLOAT      },
  		},
  		{ // Float
  			{ VK_FORMAT_R32_SFLOAT,              VK_FORMAT_R32_SFLOAT               },
  			{ VK_FORMAT_R32G32_SFLOAT,           VK_FORMAT_R32G32_SFLOAT            },
  			{ VK_FORMAT_R32G32B32_SFLOAT,        VK_FORMAT_R32G32B32_SFLOAT         },
  			{ VK_FORMAT_R32G32B32A32_SFLOAT,     VK_FORMAT_R32G32B32A32_SFLOAT      },
  		},
  	};
  	BX_STATIC_ASSERT(AttribType::Count == BX_COUNTOF(s_attribType) );
  
  	uint32_t fillVertexDecl(const ShaderVK* _vsh, VkPipelineVertexInputStateCreateInfo& _vertexInputState, const VertexDecl& _decl)
  	{
  		VkVertexInputBindingDescription*   inputBinding = const_cast<VkVertexInputBindingDescription*>(_vertexInputState.pVertexBindingDescriptions);
  		VkVertexInputAttributeDescription* inputAttrib  = const_cast<VkVertexInputAttributeDescription*>(_vertexInputState.pVertexAttributeDescriptions);
  
  		inputBinding->binding   = 0;
  		inputBinding->stride    = _decl.m_stride;
  		inputBinding->inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
  		_vertexInputState.vertexBindingDescriptionCount = 1;
  
  		uint32_t numAttribs = 0;
  		for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
  		{
  			if (UINT16_MAX != _decl.m_attributes[attr])
  			{
  				inputAttrib->location = _vsh->m_attrRemap[attr];
  				inputAttrib->binding  = 0;
  
  				if (0 == _decl.m_attributes[attr])
  				{
  					inputAttrib->format = VK_FORMAT_R32G32B32_SFLOAT;
  					inputAttrib->offset = 0;
  				}
  				else
  				{
  					uint8_t num;
  					AttribType::Enum type;
  					bool normalized;
  					bool asInt;
  					_decl.decode(Attrib::Enum(attr), num, type, normalized, asInt);
  					inputAttrib->format = s_attribType[type][num-1][normalized];
  					inputAttrib->offset = _decl.m_offset[attr];
  				}
  
  				++inputAttrib;
  				++numAttribs;
  			}
  		}
  
  		_vertexInputState.vertexAttributeDescriptionCount = numAttribs;
  
  		return numAttribs;
  	}
  
  	static const char* s_allocScopeName[] =
  	{
  		"vkCommand",
  		"vkObject",
  		"vkCache",
  		"vkDevice",
  		"vkInstance",
  	};
  	BX_STATIC_ASSERT(VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE == BX_COUNTOF(s_allocScopeName) );
  
  	static void* VKAPI_PTR allocationFunction(void* _userData, size_t _size, size_t _alignment, VkSystemAllocationScope _allocationScope)
  	{
  		BX_UNUSED(_userData, _allocationScope);
  		return bx::alignedAlloc(g_allocator, _size, _alignment, s_allocScopeName[_allocationScope]);
  	}
  
  	static void* VKAPI_PTR reallocationFunction(void* _userData, void* _original, size_t _size, size_t _alignment, VkSystemAllocationScope _allocationScope)
  	{
  		BX_UNUSED(_userData, _allocationScope);
  		return bx::alignedRealloc(g_allocator, _original, _size, _alignment, s_allocScopeName[_allocationScope]);
  	}
  
  	static void VKAPI_PTR freeFunction(void* _userData, void* _memory)
  	{
  		BX_UNUSED(_userData);
  
  		if (NULL == _memory)
  		{
  			return;
  		}
  
  		bx::alignedFree(g_allocator, _memory, 8);
  	}
  
  	static void VKAPI_PTR internalAllocationNotification(void* _userData, size_t _size, VkInternalAllocationType _allocationType, VkSystemAllocationScope _allocationScope)
  	{
  		BX_UNUSED(_userData, _size, _allocationType, _allocationScope);
  	}
  
  	static void VKAPI_PTR internalFreeNotification(void* _userData, size_t _size, VkInternalAllocationType _allocationType, VkSystemAllocationScope _allocationScope)
  	{
  		BX_UNUSED(_userData, _size, _allocationType, _allocationScope);
  	}
  
  	static VkAllocationCallbacks s_allocationCb =
  	{
  		NULL,
  		allocationFunction,
  		reallocationFunction,
  		freeFunction,
  		internalAllocationNotification,
  		internalFreeNotification,
  	};
  
  	static const char* s_debugReportObjectType[] =
  	{
  		"Unknown",
  		"Instance",
  		"PhysicalDevice",
  		"Device",
  		"Queue",
  		"Semaphore",
  		"CommandBuffer",
  		"Fence",
  		"DeviceMemory",
  		"Buffer",
  		"Image",
  		"Event",
  		"QueryPool",
  		"BufferView",
  		"ImageView",
  		"ShaderModule",
  		"PipelineCache",
  		"PipelineLayout",
  		"RenderPass",
  		"Pipeline",
  		"DescriptorSetLayout",
  		"Sampler",
  		"DescriptorPool",
  		"DescriptorSet",
  		"Framebuffer",
  		"CommandPool",
  		"SurfaceKHR",
  		"SwapchainKHR",
  		"DebugReport",
  	};
  
  	VkBool32 VKAPI_PTR debugReportCb(
  		VkDebugReportFlagsEXT _flags,
  		VkDebugReportObjectTypeEXT _objectType,
  		uint64_t _object,
  		size_t _location,
  		int32_t _messageCode,
  		const char* _layerPrefix,
  		const char* _message,
  		void* _userData
  	)
  	{
  		BX_UNUSED(_flags
  			, _objectType
  			, _object
  			, _location
  			, _messageCode
  			, _layerPrefix
  			, _message
  			, _userData
  			, s_debugReportObjectType
  		);
  		BX_TRACE("%c%c%c%c%c %19s, %s, %d: %s"
  			, 0 != (_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT        ) ? 'I' : '-'
  			, 0 != (_flags & VK_DEBUG_REPORT_WARNING_BIT_EXT            ) ? 'W' : '-'
  			, 0 != (_flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) ? 'P' : '-'
  			, 0 != (_flags & VK_DEBUG_REPORT_ERROR_BIT_EXT              ) ? 'E' : '-'
  			, 0 != (_flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT              ) ? 'D' : '-'
  			, s_debugReportObjectType[_objectType]
  			, _layerPrefix
  			, _messageCode
  			, _message
  			);
  		return VK_TRUE;
  	}
  
  	VkResult enumerateLayerProperties(VkPhysicalDevice _physicalDevice, uint32_t* _propertyCount, VkLayerProperties* _properties)
  	{
  		return (VK_NULL_HANDLE == _physicalDevice)
  			? vkEnumerateInstanceLayerProperties(_propertyCount, _properties)
  			: vkEnumerateDeviceLayerProperties(_physicalDevice, _propertyCount, _properties)
  			;
  	}
  
  	VkResult enumerateExtensionProperties(VkPhysicalDevice _physicalDevice, const char* _layerName, uint32_t* _propertyCount, VkExtensionProperties* _properties)
  	{
  		return (VK_NULL_HANDLE == _physicalDevice)
  			? vkEnumerateInstanceExtensionProperties(_layerName, _propertyCount, _properties)
  			: vkEnumerateDeviceExtensionProperties(_physicalDevice, _layerName, _propertyCount, _properties)
  			;
  	}
  
  	void dumpExtensions(VkPhysicalDevice _physicalDevice = VK_NULL_HANDLE)
  	{
  		{ // Global extensions.
  			uint32_t numExtensionProperties;
  			VkResult result = enumerateExtensionProperties(_physicalDevice
  				, NULL
  				, &numExtensionProperties
  				, NULL
  				);
  
  			if (VK_SUCCESS == result
  			&&  0 < numExtensionProperties)
  			{
  				VkExtensionProperties extensionProperties[64];
  				numExtensionProperties = bx::uint32_min(numExtensionProperties, BX_COUNTOF(extensionProperties) );
  				result = enumerateExtensionProperties(_physicalDevice
  					, NULL
  					, &numExtensionProperties
  					, extensionProperties
  					);
  
  				BX_TRACE("\tGlobal extensions (%d):"
  					, numExtensionProperties
  					);
  
  				for (uint32_t extension = 0; extension < numExtensionProperties; ++extension)
  				{
  					BX_TRACE("\t\t%s (s: 0x%08x)"
  						, extensionProperties[extension].extensionName
  						, extensionProperties[extension].specVersion
  						);
  				}
  			}
  		}
  
  		// Layer extensions.
  		uint32_t numLayerProperties;
  		VkResult result = enumerateLayerProperties(_physicalDevice, &numLayerProperties, NULL);
  
  		if (VK_SUCCESS == result
  		&&  0 < numLayerProperties)
  		{
  			VkLayerProperties layerProperties[64];
  			numLayerProperties = bx::uint32_min(numLayerProperties, BX_COUNTOF(layerProperties) );
  			result = enumerateLayerProperties(_physicalDevice, &numLayerProperties, layerProperties);
  
  			char indent = VK_NULL_HANDLE == _physicalDevice ? ' ' : '\t';
  			BX_UNUSED(indent);
  
  			BX_TRACE("%cLayer extensions (%d):"
  				, indent
  				, numLayerProperties
  				);
  			for (uint32_t layer = 0; layer < numLayerProperties; ++layer)
  			{
  				BX_TRACE("%c\t%s (s: 0x%08x, i: 0x%08x), %s"
  					, indent
  					, layerProperties[layer].layerName
  					, layerProperties[layer].specVersion
  					, layerProperties[layer].implementationVersion
  					, layerProperties[layer].description
  					);
  				uint32_t numExtensionProperties;
  				result = enumerateExtensionProperties(_physicalDevice
  					, layerProperties[layer].layerName
  					, &numExtensionProperties
  					, NULL
  					);
  
  				if (VK_SUCCESS == result
  				&&  0 < numExtensionProperties)
  				{
  					VkExtensionProperties extensionProperties[64];
  					numExtensionProperties = bx::uint32_min(numExtensionProperties, BX_COUNTOF(extensionProperties) );
  					result = enumerateExtensionProperties(_physicalDevice
  						, layerProperties[layer].layerName
  						, &numExtensionProperties
  						, extensionProperties
  						);
  
  					for (uint32_t extension = 0; extension < numExtensionProperties; ++extension)
  					{
  						BX_TRACE("%c\t\t%s (s: 0x%08x)"
  							, indent
  							, extensionProperties[extension].extensionName
  							, extensionProperties[extension].specVersion
  							);
  					}
  				}
  			}
  		}
  	}
  
  	const char* getName(VkResult _result)
  	{
  		switch (_result)
  		{
  #define VKENUM(_ty) case _ty: return #_ty
  			VKENUM(VK_SUCCESS);
  			VKENUM(VK_NOT_READY);
  			VKENUM(VK_TIMEOUT);
  			VKENUM(VK_EVENT_SET);
  			VKENUM(VK_EVENT_RESET);
  			VKENUM(VK_INCOMPLETE);
  			VKENUM(VK_ERROR_OUT_OF_HOST_MEMORY);
  			VKENUM(VK_ERROR_OUT_OF_DEVICE_MEMORY);
  			VKENUM(VK_ERROR_INITIALIZATION_FAILED);
  			VKENUM(VK_ERROR_DEVICE_LOST);
  			VKENUM(VK_ERROR_MEMORY_MAP_FAILED);
  			VKENUM(VK_ERROR_LAYER_NOT_PRESENT);
  			VKENUM(VK_ERROR_EXTENSION_NOT_PRESENT);
  			VKENUM(VK_ERROR_FEATURE_NOT_PRESENT);
  			VKENUM(VK_ERROR_INCOMPATIBLE_DRIVER);
  			VKENUM(VK_ERROR_TOO_MANY_OBJECTS);
  			VKENUM(VK_ERROR_FORMAT_NOT_SUPPORTED);
  			VKENUM(VK_ERROR_SURFACE_LOST_KHR);
  			VKENUM(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
  			VKENUM(VK_SUBOPTIMAL_KHR);
  			VKENUM(VK_ERROR_OUT_OF_DATE_KHR);
  			VKENUM(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
  			VKENUM(VK_ERROR_VALIDATION_FAILED_EXT);
  #undef VKENUM
  			default: break;
  		}
  
  		BX_WARN(false, "Unknown VkResult? %x", _result);
  		return "<VkResult?>";
  	}
  
  	void setImageMemoryBarrier(VkCommandBuffer _commandBuffer, VkImage _image, VkImageLayout _oldLayout, VkImageLayout _newLayout)
  	{
  		BX_CHECK(true
  			&& _newLayout != VK_IMAGE_LAYOUT_UNDEFINED
  			&& _newLayout != VK_IMAGE_LAYOUT_PREINITIALIZED
  			, "_newLayout cannot use VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED."
  			);
  
  		VkAccessFlags srcAccessMask = 0;
  		VkAccessFlags dstAccessMask = 0;
  		VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  
  		switch (_oldLayout)
  		{
  		case VK_IMAGE_LAYOUT_UNDEFINED:
  //			srcAccessMask |= VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_GENERAL:
  			break;
  
  		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
  			srcAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
  			srcAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
  			break;
  
  		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
  			srcAccessMask |= VK_ACCESS_SHADER_READ_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
  			srcAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
  			break;
  
  		case VK_IMAGE_LAYOUT_PREINITIALIZED:
  			srcAccessMask |= VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
  			srcAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
  			break;
  
  		default:
  			break;
  		}
  
  		switch (_newLayout)
  		{
  		case VK_IMAGE_LAYOUT_UNDEFINED:
  			break;
  
  		case VK_IMAGE_LAYOUT_GENERAL:
  			break;
  
  		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
  			dstAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
  			dstAccessMask |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
  			aspectMask     = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
  			break;
  
  		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
  			dstAccessMask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
  			dstAccessMask |= VK_ACCESS_SHADER_READ_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
  			dstAccessMask |= VK_ACCESS_TRANSFER_READ_BIT;
  			break;
  
  		case VK_IMAGE_LAYOUT_PREINITIALIZED:
  			break;
  
  		case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
  			dstAccessMask |= VK_ACCESS_MEMORY_READ_BIT;
  			break;
  
  		default:
  			break;
  		}
  
  		VkImageMemoryBarrier imb;
  		imb.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
  		imb.pNext = NULL;
  		imb.srcAccessMask = srcAccessMask;
  		imb.dstAccessMask = dstAccessMask;
  		imb.oldLayout = _oldLayout;
  		imb.newLayout = _newLayout;
  		imb.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  		imb.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
  		imb.image = _image;
  		imb.subresourceRange.aspectMask     = aspectMask;
  		imb.subresourceRange.baseMipLevel   = 0;
  		imb.subresourceRange.levelCount     = 1;
  		imb.subresourceRange.baseArrayLayer = 0;
  		imb.subresourceRange.layerCount     = 1;
  		vkCmdPipelineBarrier(_commandBuffer
  			, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
  			, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
  			, 0
  			, 0
  			, NULL
  			, 0
  			, NULL
  			, 1
  			, &imb
  			);
  	}
  
  	struct RendererContextVK : public RendererContextI
  	{
  		RendererContextVK()
  			: m_allocatorCb(NULL)
  			, m_renderDocDll(NULL)
  			, m_vulkan1Dll(NULL)
  			, m_maxAnisotropy(1)
  			, m_depthClamp(false)
  			, m_wireframe(false)
  		{
  		}
  
  		~RendererContextVK()
  		{
  		}
  
  		bool init(const Init& _init)
  		{
  			BX_UNUSED(s_checkMsaa, s_textureAddress);
  
  			struct ErrorState
  			{
  				enum Enum
  				{
  					Default,
  					LoadedVulkan1,
  					InstanceCreated,
  					DeviceCreated,
  					RenderPassCreated,
  					SurfaceCreated,
  					SwapchainCreated,
  					CommandBuffersCreated,
  					DescriptorCreated,
  				};
  			};
  
  			ErrorState::Enum errorState = ErrorState::Default;
  
  			m_fbh.idx = kInvalidHandle;
  			bx::memSet(m_uniforms, 0, sizeof(m_uniforms) );
  			bx::memSet(&m_resolution, 0, sizeof(m_resolution) );
  
  			bool imported = true;
  			VkResult result;
  			m_qfiGraphics = UINT32_MAX;
  			m_qfiCompute  = UINT32_MAX;
  
  			if (_init.debug
  			||  _init.profile)
  			{
  				m_renderDocDll = loadRenderDoc();
  			}
  
  			m_vulkan1Dll = bx::dlopen(
  #if BX_PLATFORM_WINDOWS
  					"vulkan-1.dll"
  #elif BX_PLATFORM_ANDROID
  					"libvulkan.so"
  #else
  					"libvulkan.so.1"
  #endif // BX_PLATFORM_*
  					);
  
  			if (NULL == m_vulkan1Dll)
  			{
  				BX_TRACE("Init error: Failed to load vulkan dynamic library.");
  				goto error;
  			}
  
  			errorState = ErrorState::LoadedVulkan1;
  
  			BX_TRACE("Shared library functions:");
  #define VK_IMPORT_FUNC(_optional, _func)                  \
  	_func = (PFN_##_func)bx::dlsym(m_vulkan1Dll, #_func); \
  	BX_TRACE("\t%p " #_func, _func);                      \
  	imported &= _optional || NULL != _func
  VK_IMPORT
  #undef VK_IMPORT_FUNC
  
  			if (!imported)
  			{
  				BX_TRACE("Init error: Failed to load shared library functions.");
  				goto error;
  			}
  
  			{
  				dumpExtensions();
  
  				VkApplicationInfo appInfo;
  				appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
  				appInfo.pNext = NULL;
  				appInfo.pApplicationName   = "bgfx";
  				appInfo.applicationVersion = BGFX_API_VERSION;
  				appInfo.pEngineName   = "bgfx";
  				appInfo.engineVersion = BGFX_API_VERSION;
  				appInfo.apiVersion    = VK_MAKE_VERSION(1, 0, 0); //VK_HEADER_VERSION);
  
  				const char* enabledLayerNames[] =
  				{
  #if BGFX_CONFIG_DEBUG
  //					"VK_LAYER_GOOGLE_threading",
  //					"VK_LAYER_GOOGLE_unique_objects",
  //					"VK_LAYER_LUNARG_device_limits",
  //					"VK_LAYER_LUNARG_standard_validation",
  //					"VK_LAYER_LUNARG_image",
  //					"VK_LAYER_LUNARG_mem_tracker",
  //					"VK_LAYER_LUNARG_object_tracker",
  //					"VK_LAYER_LUNARG_parameter_validation",
  //					"VK_LAYER_LUNARG_swapchain",
  //					"VK_LAYER_LUNARG_vktrace",
  //					"VK_LAYER_RENDERDOC_Capture",
  #endif // BGFX_CONFIG_DEBUG
  					/*not used*/ ""
  				};
  
  				const char* enabledExtension[] =
  				{
  					VK_KHR_SURFACE_EXTENSION_NAME,
  					KHR_SURFACE_EXTENSION_NAME,
  #if BGFX_CONFIG_DEBUG
  					VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
  #endif // BGFX_CONFIG_DEBUG
  					/*not used*/ ""
  				};
  
  				VkInstanceCreateInfo ici;
  				ici.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
  				ici.pNext = NULL;
  				ici.flags = 0;
  				ici.pApplicationInfo = &appInfo;
  				ici.enabledLayerCount   = BX_COUNTOF(enabledLayerNames) - 1;
  				ici.ppEnabledLayerNames = enabledLayerNames;
  				ici.enabledExtensionCount   = BX_COUNTOF(enabledExtension) - 1;
  				ici.ppEnabledExtensionNames = enabledExtension;
  
  				if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
  				{
  					m_allocatorCb = &s_allocationCb;
  					BX_UNUSED(s_allocationCb);
  				}
  
  				result = vkCreateInstance(&ici
  						, m_allocatorCb
  						, &m_instance
  						);
  			}
  
  			if (VK_SUCCESS != result)
  			{
  				BX_TRACE("Init error: vkCreateInstance failed %d: %s.", result, getName(result) );
  				goto error;
  			}
  
  			errorState = ErrorState::InstanceCreated;
  
  			BX_TRACE("Instance functions:");
  
  #define VK_IMPORT_INSTANCE_FUNC(_optional, _func)                           \
  			_func = (PFN_##_func)vkGetInstanceProcAddr(m_instance, #_func); \
  			BX_TRACE("\t%p " #_func, _func);                                \
  			imported &= _optional || NULL != _func
  VK_IMPORT_INSTANCE
  #undef VK_IMPORT_INSTANCE_FUNC
  
  			if (!imported)
  			{
  				BX_TRACE("Init error: Failed to load instance functions.");
  				goto error;
  			}
  
  			m_debugReportCallback = VK_NULL_HANDLE;
  
  			if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
  			{
  				VkDebugReportCallbackCreateInfoEXT drcb;
  				drcb.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
  				drcb.pNext = NULL;
  				drcb.pfnCallback = debugReportCb;
  				drcb.pUserData   = NULL;
  				drcb.flags       = 0
  					| VK_DEBUG_REPORT_ERROR_BIT_EXT
  					| VK_DEBUG_REPORT_WARNING_BIT_EXT
  					;
  				result = vkCreateDebugReportCallbackEXT(m_instance
  					, &drcb
  					, m_allocatorCb
  					, &m_debugReportCallback
  					);
  				BX_WARN(VK_SUCCESS == result, "vkCreateDebugReportCallbackEXT failed %d: %s.", result, getName(result) );
  			}
  
  			{
  				BX_TRACE("---");
  
  				uint32_t numPhysicalDevices;
  				result = vkEnumeratePhysicalDevices(m_instance
  					, &numPhysicalDevices
  					, NULL
  					);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkEnumeratePhysicalDevices failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkPhysicalDevice physicalDevices[4];
  				numPhysicalDevices = bx::uint32_min(numPhysicalDevices, BX_COUNTOF(physicalDevices) );
  				result = vkEnumeratePhysicalDevices(m_instance
  					, &numPhysicalDevices
  					, physicalDevices
  					);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkEnumeratePhysicalDevices failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				m_physicalDevice = VK_NULL_HANDLE;
  
  				for (uint32_t ii = 0; ii < numPhysicalDevices; ++ii)
  				{
  					VkPhysicalDeviceProperties pdp;
  					vkGetPhysicalDeviceProperties(physicalDevices[ii], &pdp);
  					BX_TRACE("Physical device %d:", ii);
  					BX_TRACE("\t          Name: %s", pdp.deviceName);
  					BX_TRACE("\t   API version: %x", pdp.apiVersion);
  					BX_TRACE("\tDriver version: %x", pdp.driverVersion);
  					BX_TRACE("\t      VendorId: %x", pdp.vendorID);
  					BX_TRACE("\t      DeviceId: %x", pdp.deviceID);
  					BX_TRACE("\t          Type: %d", pdp.deviceType);
  
  					g_caps.gpu[ii].vendorId = uint16_t(pdp.vendorID);
  					g_caps.gpu[ii].deviceId = uint16_t(pdp.deviceID);
  					++g_caps.numGPUs;
  
  					if ( (BGFX_PCI_ID_NONE != g_caps.vendorId ||            0 != g_caps.deviceId)
  					&&   (BGFX_PCI_ID_NONE == g_caps.vendorId || pdp.vendorID == g_caps.vendorId)
  					&&   (0 == g_caps.deviceId                || pdp.deviceID == g_caps.deviceId) )
  					{
  						m_physicalDevice = physicalDevices[ii];
  					}
  
  					VkPhysicalDeviceMemoryProperties pdmp;
  					vkGetPhysicalDeviceMemoryProperties(physicalDevices[ii], &pdmp);
  
  					BX_TRACE("\tMemory type count: %d", pdmp.memoryTypeCount);
  					for (uint32_t jj = 0; jj < pdmp.memoryTypeCount; ++jj)
  					{
  						BX_TRACE("\t%3d: flags 0x%08x, index %d"
  								, jj
  								, pdmp.memoryTypes[jj].propertyFlags
  								, pdmp.memoryTypes[jj].heapIndex
  								);
  					}
  
  					BX_TRACE("\tMemory heap count: %d", pdmp.memoryHeapCount);
  					for (uint32_t jj = 0; jj < pdmp.memoryHeapCount; ++jj)
  					{
  						char size[16];
  						bx::prettify(size, BX_COUNTOF(size), pdmp.memoryHeaps[jj].size);
  						BX_TRACE("\t%3d: flags 0x%08x, size %10s"
  								, jj
  								, pdmp.memoryHeaps[jj].flags
  								, size
  								);
  					}
  
  					dumpExtensions(physicalDevices[ii]);
  				}
  
  				if (VK_NULL_HANDLE == m_physicalDevice)
  				{
  					m_physicalDevice = physicalDevices[0];
  				}
  
  				vkGetPhysicalDeviceProperties(m_physicalDevice, &m_deviceProperties);
  				g_caps.vendorId = uint16_t(m_deviceProperties.vendorID);
  				g_caps.deviceId = uint16_t(m_deviceProperties.deviceID);
  
  				g_caps.limits.maxTextureSize     = m_deviceProperties.limits.maxImageDimension2D;
  				g_caps.limits.maxFBAttachments   = uint8_t(bx::uint32_min(m_deviceProperties.limits.maxFragmentOutputAttachments, BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) );
  				g_caps.limits.maxComputeBindings = BGFX_MAX_COMPUTE_BINDINGS;
  
  				{
  //					VkFormatProperties fp;
  //					vkGetPhysicalDeviceFormatProperties(m_physicalDevice, fmt, &fp);
  
  					struct ImageTest
  					{
  						VkImageType type;
  						VkImageUsageFlags usage;
  						VkImageCreateFlags flags;
  						uint32_t formatCaps[2];
  					};
  
  					const ImageTest imageTest[] =
  					{
  						{ VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT,          0,                                   { BGFX_CAPS_FORMAT_TEXTURE_2D,          BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB     } },
  						{ VK_IMAGE_TYPE_3D, VK_IMAGE_USAGE_SAMPLED_BIT,          0,                                   { BGFX_CAPS_FORMAT_TEXTURE_3D,          BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB     } },
  						{ VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT,          VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, { BGFX_CAPS_FORMAT_TEXTURE_CUBE,        BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB   } },
  						{ VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0,                                   { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER } },
  					};
  
  					for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii)
  					{
  						uint8_t support = BGFX_CAPS_FORMAT_TEXTURE_NONE;
  
  						const bool depth = bimg::isDepth(bimg::TextureFormat::Enum(ii) );
  						VkFormat fmt = depth
  							? s_textureFormat[ii].m_fmtDsv
  							: s_textureFormat[ii].m_fmt
  							;
  
  						for (uint32_t jj = 0, num = depth ? 1 : 2; jj < num; ++jj)
  						{
  							if (VK_FORMAT_UNDEFINED != fmt)
  							{
  								for (uint32_t test = 0; test < BX_COUNTOF(imageTest); ++test)
  								{
  									const ImageTest& it = imageTest[test];
  
  									VkImageFormatProperties ifp;
  									result = vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice
  										, fmt
  										, it.type
  										, VK_IMAGE_TILING_OPTIMAL
  										, it.usage
  										, it.flags
  										, &ifp
  										);
  
  									if (VK_SUCCESS == result)
  									{
  										support |= it.formatCaps[jj];
  										if (VK_SAMPLE_COUNT_1_BIT < ifp.sampleCounts)
  										{
  											support |= BGFX_CAPS_FORMAT_TEXTURE_MSAA;
  										}
  									}
  								}
  							}
  
  							fmt = s_textureFormat[ii].m_fmtSrgb;
  						}
  
  						g_caps.formats[ii] = support;
  					}
  				}
  
  				vkGetPhysicalDeviceMemoryProperties(m_physicalDevice, &m_memoryProperties);
  			}
  
  			{
  				BX_TRACE("---");
  
  				uint32_t queueFamilyPropertyCount = 0;
  				vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice
  					, &queueFamilyPropertyCount
  					, NULL
  					);
  
  				VkQueueFamilyProperties queueFamilyPropertices[10] = {};
  				queueFamilyPropertyCount = bx::uint32_min(queueFamilyPropertyCount, BX_COUNTOF(queueFamilyPropertices) );
  				vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice
  					, &queueFamilyPropertyCount
  					, queueFamilyPropertices
  					);
  
  				for (uint32_t ii = 0; ii < queueFamilyPropertyCount; ++ii)
  				{
  					const VkQueueFamilyProperties& qfp = queueFamilyPropertices[ii];
  					BX_UNUSED(qfp);
  					BX_TRACE("Queue family property %d:", ii);
  					BX_TRACE("\t  Queue flags: 0x%08x", qfp.queueFlags);
  					BX_TRACE("\t  Queue count: %d", qfp.queueCount);
  					BX_TRACE("\tTS valid bits: 0x%08x", qfp.timestampValidBits);
  					BX_TRACE("\t    Min image: %d x %d x %d"
  							, qfp.minImageTransferGranularity.width
  							, qfp.minImageTransferGranularity.height
  							, qfp.minImageTransferGranularity.depth
  							);
  				}
  
  				for (uint32_t ii = 0; ii < queueFamilyPropertyCount; ++ii)
  				{
  					const VkQueueFamilyProperties& qfp = queueFamilyPropertices[ii];
  					if (UINT32_MAX == m_qfiGraphics
  					&&  VK_QUEUE_GRAPHICS_BIT & qfp.queueFlags)
  					{
  						m_qfiGraphics = ii;
  					}
  
  					if (UINT32_MAX == m_qfiCompute
  					&&  VK_QUEUE_COMPUTE_BIT & qfp.queueFlags)
  					{
  						m_qfiCompute = ii;
  					}
  
  					if (UINT32_MAX != m_qfiGraphics
  					&&  UINT32_MAX != m_qfiCompute)
  					{
  						break;
  					}
  				}
  
  				if (UINT32_MAX == m_qfiGraphics)
  				{
  					BX_TRACE("Init error: Unable to find graphics queue.");
  					goto error;
  				}
  			}
  
  			{
  				const char* enabledLayerNames[] =
  				{
  #if BGFX_CONFIG_DEBUG
  					"VK_LAYER_GOOGLE_threading",
  //					"VK_LAYER_GOOGLE_unique_objects",
  					"VK_LAYER_LUNARG_device_limits",
  //					"VK_LAYER_LUNARG_standard_validation",
  					"VK_LAYER_LUNARG_image",
  					"VK_LAYER_LUNARG_object_tracker",
  					"VK_LAYER_LUNARG_parameter_validation",
  					"VK_LAYER_LUNARG_swapchain",
  //					"VK_LAYER_LUNARG_vktrace",
  //					"VK_LAYER_RENDERDOC_Capture",
  #endif // BGFX_CONFIG_DEBUG
  					/*not used*/ ""
  				};
  
  				const char* enabledExtension[] =
  				{
  					VK_KHR_SWAPCHAIN_EXTENSION_NAME,
  //					"VK_LUNARG_DEBUG_MARKER",
  					/*not used*/ ""
  				};
  
  				float queuePriorities[1] = { 0.0f };
  				VkDeviceQueueCreateInfo dcqi;
  				dcqi.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
  				dcqi.pNext = NULL;
  				dcqi.flags = 0;
  				dcqi.queueFamilyIndex = m_qfiGraphics;
  				dcqi.queueCount       = 1;
  				dcqi.pQueuePriorities = queuePriorities;
  
  				VkDeviceCreateInfo dci;
  				dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
  				dci.pNext = NULL;
  				dci.flags = 0;
  				dci.queueCreateInfoCount = 1;
  				dci.pQueueCreateInfos    = &dcqi;
  				dci.enabledLayerCount    = BX_COUNTOF(enabledLayerNames) - 1;
  				dci.ppEnabledLayerNames  = enabledLayerNames;
  				dci.enabledExtensionCount   = BX_COUNTOF(enabledExtension) - 1;
  				dci.ppEnabledExtensionNames = enabledExtension;
  				dci.pEnabledFeatures = NULL;
  
  				result = vkCreateDevice(m_physicalDevice
  							, &dci
  							, m_allocatorCb
  							, &m_device
  							);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateDevice failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  			}
  
  			errorState = ErrorState::DeviceCreated;
  
  			BX_TRACE("Device functions:");
  #define VK_IMPORT_DEVICE_FUNC(_optional, _func) \
  			_func = (PFN_##_func)vkGetDeviceProcAddr(m_device, #_func); \
  			BX_TRACE("\t%p " #_func, _func); \
  			imported &= _optional || NULL != _func
  VK_IMPORT_DEVICE
  #undef VK_IMPORT_DEVICE_FUNC
  
  			if (!imported)
  			{
  				BX_TRACE("Init error: Failed to load device functions.");
  				goto error;
  			}
  
  			vkGetDeviceQueue(m_device, m_qfiGraphics, 0, &m_queueGraphics);
  			vkGetDeviceQueue(m_device, m_qfiCompute,  0, &m_queueCompute);
  
  			m_backBufferDepthStencilFormat =
  				VK_FORMAT_D32_SFLOAT_S8_UINT
  //				VK_FORMAT_D24_UNORM_S8_UINT
  				;
  
  			{
  				m_sci.imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
  
  				VkAttachmentDescription ad[2];
  				ad[0].flags   = 0;
  				ad[0].format  = m_sci.imageFormat;
  				ad[0].samples = VK_SAMPLE_COUNT_1_BIT;
  				ad[0].loadOp  = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  				ad[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
  				ad[0].stencilLoadOp  = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  				ad[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
  				ad[0].initialLayout  = VK_IMAGE_LAYOUT_UNDEFINED;
  				ad[0].finalLayout    = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  				ad[1].flags   = 0;
  				ad[1].format  = m_backBufferDepthStencilFormat;
  				ad[1].samples = VK_SAMPLE_COUNT_1_BIT;
  				ad[1].loadOp  = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  				ad[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
  				ad[1].stencilLoadOp  = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
  				ad[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
  				ad[1].initialLayout  = VK_IMAGE_LAYOUT_UNDEFINED;
  				ad[1].finalLayout    = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
  
  				VkAttachmentReference colorAr[1];
  				colorAr[0].attachment = 0;
  				colorAr[0].layout     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  
  				VkAttachmentReference resolveAr[1];
  				resolveAr[0].attachment = VK_ATTACHMENT_UNUSED;
  				resolveAr[0].layout     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
  
  				VkAttachmentReference depthAr[1];
  				depthAr[0].attachment = 1;
  				depthAr[0].layout     = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
  
  				VkSubpassDescription sd[1];
  				sd[0].flags = 0;
  				sd[0].pipelineBindPoint    = VK_PIPELINE_BIND_POINT_GRAPHICS;
  				sd[0].inputAttachmentCount = 0;
  				sd[0].pInputAttachments    = NULL;
  				sd[0].colorAttachmentCount = BX_COUNTOF(colorAr);
  				sd[0].pColorAttachments    = colorAr;
  				sd[0].pResolveAttachments  = resolveAr;
  				sd[0].pDepthStencilAttachment = depthAr;
  				sd[0].preserveAttachmentCount = 0;
  				sd[0].pPreserveAttachments    = NULL;
  
  				VkRenderPassCreateInfo rpi;
  				rpi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
  				rpi.pNext = NULL;
  				rpi.flags = 0;
  				rpi.attachmentCount = BX_COUNTOF(ad);
  				rpi.pAttachments    = ad;
  				rpi.subpassCount    = BX_COUNTOF(sd);
  				rpi.pSubpasses      = sd;
  				rpi.dependencyCount = 0;
  				rpi.pDependencies   = NULL;
  
  				result = vkCreateRenderPass(m_device, &rpi, m_allocatorCb, &m_renderPass);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateRenderPass failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  			}
  
  			errorState = ErrorState::RenderPassCreated;
  
  #if BX_PLATFORM_WINDOWS
  			{
  				VkWin32SurfaceCreateInfoKHR sci;
  				sci.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
  				sci.pNext = NULL;
  				sci.flags     = 0;
  				sci.hinstance = (HINSTANCE)GetModuleHandle(NULL);
  				sci.hwnd      = (HWND)g_platformData.nwh;
  				result = vkCreateWin32SurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
  			}
  #elif BX_PLATFORM_ANDROID
  			{
  				VkAndroidSurfaceCreateInfoKHR sci;
  				sci.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
  				sci.pNext = NULL;
  				sci.flags = 0;
  				result = vkCreateAndroidSurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
  			}
  #elif BX_PLATFORM_LINUX
  			{
  				if (NULL != vkCreateXlibSurfaceKHR)
  				{
  					VkXlibSurfaceCreateInfoKHR sci;
  					sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
  					sci.pNext = NULL;
  					sci.flags  = 0;
  					sci.dpy    = (Display*)g_platformData.ndt;
  					sci.window = (Window)g_platformData.nwh;
  					result = vkCreateXlibSurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
  				}
  				else
  				{
  					result = VK_RESULT_MAX_ENUM;
  				}
  
  				if (VK_SUCCESS != result)
  				{
  					void* xcbdll = bx::dlopen("libX11-xcb.so.1");
  					if (NULL != xcbdll)
  					{
  						typedef xcb_connection_t* (*PFN_XGETXCBCONNECTION)(Display*);
  						PFN_XGETXCBCONNECTION XGetXCBConnection = (PFN_XGETXCBCONNECTION)bx::dlsym(xcbdll, "XGetXCBConnection");
  
  						VkXcbSurfaceCreateInfoKHR sci;
  						sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
  						sci.pNext = NULL;
  						sci.flags      = 0;
  						sci.connection = XGetXCBConnection( (Display*)g_platformData.ndt);
  						union { void* ptr; xcb_window_t window; } cast = { g_platformData.nwh };
  						sci.window = cast.window;
  						result = vkCreateXcbSurfaceKHR(m_instance, &sci, m_allocatorCb, &m_surface);
  
  						bx::dlclose(xcbdll);
  					}
  				}
  			}
  #else
  #	error "Figure out KHR surface..."
  #endif // BX_PLATFORM_
  
  			if (VK_SUCCESS != result)
  			{
  				BX_TRACE("Init error: vkCreateSurfaceKHR failed %d: %s.", result, getName(result) );
  				goto error;
  			}
  
  			errorState = ErrorState::SurfaceCreated;
  
  			{
  				VkBool32 surfaceSupported;
  				result = vkGetPhysicalDeviceSurfaceSupportKHR(m_physicalDevice, m_qfiGraphics, m_surface, &surfaceSupported);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkGetPhysicalDeviceSurfaceSupportKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkSurfaceCapabilitiesKHR surfaceCapabilities;
  				result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physicalDevice, m_surface, &surfaceCapabilities);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkGetPhysicalDeviceSurfaceCapabilitiesKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				uint32_t numSurfaceFormats;
  				result = vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &numSurfaceFormats, NULL);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkGetPhysicalDeviceSurfaceFormatsKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkSurfaceFormatKHR surfaceFormats[10];
  				numSurfaceFormats = bx::uint32_min(numSurfaceFormats, BX_COUNTOF(surfaceFormats) );
  				vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &numSurfaceFormats, surfaceFormats);
  
  				// find the best match...
  				uint32_t surfaceFormatIdx = 0;
  
  				uint32_t numPresentModes;
  				result = vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &numPresentModes, NULL);
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkPresentModeKHR presentModes[10];
  				numPresentModes = bx::uint32_min(numPresentModes, BX_COUNTOF(presentModes) );
  				vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &numPresentModes, presentModes);
  
  				// find the best match...
  				uint32_t presentModeIdx = 0;
  
  				m_sci.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
  				m_sci.pNext = NULL;
  				m_sci.flags = 0;
  				m_sci.surface = m_surface;
  				m_sci.minImageCount   = BX_COUNTOF(m_backBufferColorImage);
  				m_sci.imageFormat     = surfaceFormats[surfaceFormatIdx].format;
  				m_sci.imageColorSpace = surfaceFormats[surfaceFormatIdx].colorSpace;
  				m_sci.imageExtent.width  = _init.resolution.width;
  				m_sci.imageExtent.height = _init.resolution.height;
  				m_sci.imageArrayLayers = 1;
  				m_sci.imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
  				m_sci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
  				m_sci.queueFamilyIndexCount = 0;
  				m_sci.pQueueFamilyIndices   = NULL;
  				m_sci.preTransform   = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
  				m_sci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
  				m_sci.presentMode    = presentModes[presentModeIdx];
  				m_sci.clipped        = VK_TRUE;
  				m_sci.oldSwapchain   = VK_NULL_HANDLE;
  				result = vkCreateSwapchainKHR(m_device, &m_sci, m_allocatorCb, &m_swapchain);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateSwapchainKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				uint32_t numSwapchainImages;
  				result = vkGetSwapchainImagesKHR(m_device, m_swapchain, &numSwapchainImages, NULL);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkGetSwapchainImagesKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				if (numSwapchainImages < m_sci.minImageCount)
  				{
  					BX_TRACE("Init error: vkGetSwapchainImagesKHR: numSwapchainImages %d, minImageCount %d."
  						, numSwapchainImages
  						, m_sci.minImageCount
  						);
  					goto error;
  				}
  
  				numSwapchainImages = m_sci.minImageCount;
  				result = vkGetSwapchainImagesKHR(m_device, m_swapchain, &numSwapchainImages, &m_backBufferColorImage[0]);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkGetSwapchainImagesKHR failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
  				{
  					m_backBufferColorImageView[ii] = VK_NULL_HANDLE;
  					m_backBufferColor[ii]          = VK_NULL_HANDLE;
  				}
  
  				VkImageCreateInfo ici;
  				ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
  				ici.pNext = NULL;
  				ici.flags = 0;
  				ici.imageType = VK_IMAGE_TYPE_2D;
  				ici.format    = m_backBufferDepthStencilFormat;
  				ici.extent.width  = m_sci.imageExtent.width;
  				ici.extent.height = m_sci.imageExtent.height;
  				ici.extent.depth  = 1;
  				ici.mipLevels   = 1;
  				ici.arrayLayers = 1;
  				ici.samples = VK_SAMPLE_COUNT_1_BIT;
  				ici.tiling  = VK_IMAGE_TILING_OPTIMAL;
  				ici.usage   = 0
  					| VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
  					| VK_IMAGE_USAGE_TRANSFER_SRC_BIT
  					;
  				ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  				ici.queueFamilyIndexCount = 0; //m_sci.queueFamilyIndexCount;
  				ici.pQueueFamilyIndices   = NULL; //m_sci.pQueueFamilyIndices;
  				ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  				result = vkCreateImage(m_device, &ici, m_allocatorCb, &m_backBufferDepthStencilImage);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateImage failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkMemoryRequirements mr;
  				vkGetImageMemoryRequirements(m_device, m_backBufferDepthStencilImage, &mr);
  
  				VkMemoryAllocateInfo ma;
  				ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  				ma.pNext = NULL;
  				ma.allocationSize  = mr.size;
  				ma.memoryTypeIndex = selectMemoryType(mr.memoryTypeBits
  					, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
  					);
  				result = vkAllocateMemory(m_device
  					, &ma
  					, m_allocatorCb
  					, &m_backBufferDepthStencilMemory
  					);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkAllocateMemory failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				result = vkBindImageMemory(m_device, m_backBufferDepthStencilImage, m_backBufferDepthStencilMemory, 0);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkBindImageMemory failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkImageViewCreateInfo ivci;
  				ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
  				ivci.pNext = NULL;
  				ivci.flags = 0;
  				ivci.image    = m_backBufferDepthStencilImage;
  				ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
  				ivci.format   = m_backBufferDepthStencilFormat;
  				ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
  				ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
  				ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
  				ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
  				ivci.subresourceRange.aspectMask = 0
  					| VK_IMAGE_ASPECT_DEPTH_BIT
  					| VK_IMAGE_ASPECT_STENCIL_BIT
  					;
  				ivci.subresourceRange.baseMipLevel   = 0;
  				ivci.subresourceRange.levelCount     = 1;
  				ivci.subresourceRange.baseArrayLayer = 0;
  				ivci.subresourceRange.layerCount     = 1;
  				result = vkCreateImageView(m_device, &ivci, m_allocatorCb, &m_backBufferDepthStencilImageView);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateImageView failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				::VkImageView attachments[] =
  				{
  					VK_NULL_HANDLE,
  					m_backBufferDepthStencilImageView,
  				};
  
  				VkFramebufferCreateInfo fci;
  				fci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
  				fci.pNext = NULL;
  				fci.flags = 0;
  				fci.renderPass = m_renderPass;
  				fci.attachmentCount = BX_COUNTOF(attachments);
  				fci.pAttachments    = attachments;
  				fci.width  = m_sci.imageExtent.width;
  				fci.height = m_sci.imageExtent.height;
  				fci.layers = 1;
  
  				VkSemaphoreCreateInfo sci;
  				sci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
  				sci.pNext = NULL;
  				sci.flags = 0;
  
  				for (uint32_t ii = 0; ii < numSwapchainImages; ++ii)
  				{
  					ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
  					ivci.pNext = NULL;
  					ivci.flags = 0;
  					ivci.image    = m_backBufferColorImage[ii];
  					ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
  					ivci.format   = m_sci.imageFormat;
  					ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
  					ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
  					ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
  					ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
  					ivci.subresourceRange.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
  					ivci.subresourceRange.baseMipLevel   = 0;
  					ivci.subresourceRange.levelCount     = 1;
  					ivci.subresourceRange.baseArrayLayer = 0;
  					ivci.subresourceRange.layerCount     = 1;
  
  					result = vkCreateImageView(m_device, &ivci, m_allocatorCb, &m_backBufferColorImageView[ii]);
  
  					if (VK_SUCCESS != result)
  					{
  						BX_TRACE("Init error: vkCreateImageView failed %d: %s.", result, getName(result) );
  						goto error;
  					}
  
  					attachments[0] = m_backBufferColorImageView[ii];
  					result = vkCreateFramebuffer(m_device, &fci, m_allocatorCb, &m_backBufferColor[ii]);
  
  					if (VK_SUCCESS != result)
  					{
  						BX_TRACE("Init error: vkCreateFramebuffer failed %d: %s.", result, getName(result) );
  						goto error;
  					}
  
  					result = vkCreateSemaphore(m_device, &sci, m_allocatorCb, &m_presentDone[ii]);
  
  					if (VK_SUCCESS != result)
  					{
  						BX_TRACE("Init error: vkCreateSemaphore failed %d: %s.", result, getName(result) );
  						goto error;
  					}
  
  					sci.flags = 0;
  				}
  			}
  
  			errorState = ErrorState::SwapchainCreated;
  
  			{
  				VkFenceCreateInfo fci;
  				fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
  				fci.pNext = NULL;
  				fci.flags = 0;
  				result = vkCreateFence(m_device, &fci, m_allocatorCb, &m_fence);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateFence failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkCommandPoolCreateInfo cpci;
  				cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
  				cpci.pNext = NULL;
  				cpci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
  				cpci.queueFamilyIndex = m_qfiGraphics;
  				result = vkCreateCommandPool(m_device, &cpci, m_allocatorCb, &m_commandPool);
  
  				if (VK_SUCCESS != result)
  				{
  					vkDestroy(m_fence);
  					BX_TRACE("Init error: vkCreateCommandPool failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkCommandBufferAllocateInfo cbai;
  				cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
  				cbai.pNext = NULL;
  				cbai.commandPool = m_commandPool;
  				cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
  				cbai.commandBufferCount = BX_COUNTOF(m_commandBuffers);
  
  				result = vkAllocateCommandBuffers(m_device, &cbai, m_commandBuffers);
  
  				if (VK_SUCCESS != result)
  				{
  					vkDestroy(m_commandPool);
  					vkDestroy(m_fence);
  					BX_TRACE("Init error: vkAllocateCommandBuffers failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkCommandBufferBeginInfo cbbi;
  				cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
  				cbbi.pNext = NULL;
  				cbbi.flags = 0;
  				cbbi.pInheritanceInfo = NULL;
  
  				VkCommandBuffer commandBuffer = m_commandBuffers[0];
  				VK_CHECK(vkBeginCommandBuffer(commandBuffer, &cbbi) );
  
  				VkRenderPassBeginInfo rpbi;
  				rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
  				rpbi.pNext = NULL;
  				rpbi.renderPass  = m_renderPass;
  				rpbi.renderArea.offset.x = 0;
  				rpbi.renderArea.offset.y = 0;
  				rpbi.renderArea.extent = m_sci.imageExtent;
  				rpbi.clearValueCount = 0;
  				rpbi.pClearValues = NULL;
  
  				setImageMemoryBarrier(commandBuffer
  					, m_backBufferDepthStencilImage
  					, VK_IMAGE_LAYOUT_UNDEFINED
  					, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
  					);
  
  				for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImage); ++ii)
  				{
  					setImageMemoryBarrier(commandBuffer
  						, m_backBufferColorImage[ii]
  						, VK_IMAGE_LAYOUT_UNDEFINED
  						, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
  						);
  
  					rpbi.framebuffer = m_backBufferColor[ii];
  					vkCmdBeginRenderPass(commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
  					vkCmdEndRenderPass(commandBuffer);
  
  					setImageMemoryBarrier(commandBuffer
  						, m_backBufferColorImage[ii]
  						, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
  						, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
  						);
  				}
  
  				VK_CHECK(vkEndCommandBuffer(commandBuffer) );
  				m_backBufferColorIdx = 0;
  
  				kick();
  				finishAll();
  
  				VK_CHECK(vkResetCommandPool(m_device, m_commandPool, 0) );
  			}
  
  			errorState = ErrorState::CommandBuffersCreated;
  
  			{
  				VkDescriptorPoolSize dps[] =
  				{
  //					{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
  					{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,         10<<10                           },
  //					{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,         BGFX_CONFIG_MAX_TEXTURE_SAMPLERS },
  				};
  
  				VkDescriptorSetLayoutBinding dslb[] =
  				{
  //					{ DslBinding::CombinedImageSampler, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, VK_SHADER_STAGE_ALL, NULL },
  					{ DslBinding::UniformBuffer,        VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,         1,                                VK_SHADER_STAGE_ALL, NULL },
  //					{ DslBinding::StorageBuffer,        VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,         BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, VK_SHADER_STAGE_ALL, NULL },
  				};
  
  				VkDescriptorPoolCreateInfo dpci;
  				dpci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
  				dpci.pNext = NULL;
  				dpci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
  				dpci.maxSets       = 10<<10;
  				dpci.poolSizeCount = BX_COUNTOF(dps);
  				dpci.pPoolSizes    = dps;
  
  				result = vkCreateDescriptorPool(m_device, &dpci, m_allocatorCb, &m_descriptorPool);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateDescriptorPool failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkDescriptorSetLayoutCreateInfo dsl;
  				dsl.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
  				dsl.pNext = NULL;
  				dsl.flags = 0;
  				dsl.bindingCount = BX_COUNTOF(dslb);
  				dsl.pBindings    = dslb;
  				result = vkCreateDescriptorSetLayout(m_device, &dsl, m_allocatorCb, &m_descriptorSetLayout);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreateDescriptorSetLayout failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkPipelineLayoutCreateInfo pl;
  				pl.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
  				pl.pNext = NULL;
  				pl.flags = 0;
  				pl.setLayoutCount = 1;
  				pl.pSetLayouts    = &m_descriptorSetLayout;
  				pl.pushConstantRangeCount = 0;
  				pl.pPushConstantRanges    = NULL;
  				result = vkCreatePipelineLayout(m_device, &pl, m_allocatorCb, &m_pipelineLayout);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreatePipelineLayout failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  
  				VkPipelineCacheCreateInfo pcci;
  				pcci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
  				pcci.pNext = NULL;
  				pcci.flags = 0;
  				pcci.initialDataSize = 0;
  				pcci.pInitialData    = NULL;
  				result = vkCreatePipelineCache(m_device, &pcci, m_allocatorCb, &m_pipelineCache);
  
  				if (VK_SUCCESS != result)
  				{
  					BX_TRACE("Init error: vkCreatePipelineCache failed %d: %s.", result, getName(result) );
  					goto error;
  				}
  			}
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_scratchBuffer); ++ii)
  			{
  				m_scratchBuffer[ii].create(BGFX_CONFIG_MAX_DRAW_CALLS*1024
  					, 1024 //BGFX_CONFIG_MAX_TEXTURES + BGFX_CONFIG_MAX_SHADERS + BGFX_CONFIG_MAX_DRAW_CALLS
  					);
  			}
  
  			errorState = ErrorState::DescriptorCreated;
  
  			return true;
  
  		error:
  			BX_TRACE("errorState %d", errorState);
  			switch (errorState)
  			{
  			case ErrorState::DescriptorCreated:
  				vkDestroy(m_pipelineCache);
  				vkDestroy(m_pipelineLayout);
  				vkDestroy(m_descriptorSetLayout);
  				vkDestroy(m_descriptorPool);
  				BX_FALLTHROUGH;
  
  			case ErrorState::CommandBuffersCreated:
  				vkFreeCommandBuffers(m_device, m_commandPool, BX_COUNTOF(m_commandBuffers), m_commandBuffers);
  				vkDestroy(m_commandPool);
  				vkDestroy(m_fence);
  				BX_FALLTHROUGH;
  
  			case ErrorState::SwapchainCreated:
  				for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
  				{
  					if (VK_NULL_HANDLE != m_backBufferColorImageView[ii])
  					{
  						vkDestroy(m_backBufferColorImageView[ii]);
  					}
  
  					if (VK_NULL_HANDLE != m_backBufferColor[ii])
  					{
  						vkDestroy(m_backBufferColor[ii]);
  					}
  
  					if (VK_NULL_HANDLE != m_presentDone[ii])
  					{
  						vkDestroy(m_presentDone[ii]);
  					}
  				}
  				vkDestroy(m_swapchain);
  				BX_FALLTHROUGH;
  
  			case ErrorState::SurfaceCreated:
  				vkDestroySurfaceKHR(m_instance, m_surface, m_allocatorCb);
  				BX_FALLTHROUGH;
  
  			case ErrorState::RenderPassCreated:
  				vkDestroy(m_renderPass);
  				BX_FALLTHROUGH;
  
  			case ErrorState::DeviceCreated:
  				vkDestroyDevice(m_device, m_allocatorCb);
  				BX_FALLTHROUGH;
  
  			case ErrorState::InstanceCreated:
  				if (VK_NULL_HANDLE != m_debugReportCallback)
  				{
  					vkDestroyDebugReportCallbackEXT(m_instance, m_debugReportCallback, m_allocatorCb);
  				}
  
  				vkDestroyInstance(m_instance, m_allocatorCb);
  				BX_FALLTHROUGH;
  
  			case ErrorState::LoadedVulkan1:
  				bx::dlclose(m_vulkan1Dll);
  				m_vulkan1Dll  = NULL;
  				m_allocatorCb = NULL;
  				unloadRenderDoc(m_renderDocDll);
  				BX_FALLTHROUGH;
  
  			case ErrorState::Default:
  				break;
  			};
  
  			BX_CHECK(false, "Failed to initialize Vulkan.");
  			return false;
  		}
  
  		void shutdown()
  		{
  			VK_CHECK(vkQueueWaitIdle(m_queueGraphics) );
  			VK_CHECK(vkDeviceWaitIdle(m_device) );
  
  			m_pipelineStateCache.invalidate();
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_scratchBuffer); ++ii)
  			{
  				m_scratchBuffer[ii].destroy();
  			}
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_frameBuffers); ++ii)
  			{
  				m_frameBuffers[ii].destroy();
  			}
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_indexBuffers); ++ii)
  			{
  				m_indexBuffers[ii].destroy();
  			}
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_vertexBuffers); ++ii)
  			{
  				m_vertexBuffers[ii].destroy();
  			}
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_shaders); ++ii)
  			{
  				m_shaders[ii].destroy();
  			}
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_textures); ++ii)
  			{
  				m_textures[ii].destroy();
  			}
  
  			vkDestroy(m_pipelineCache);
  			vkDestroy(m_pipelineLayout);
  			vkDestroy(m_descriptorSetLayout);
  			vkDestroy(m_descriptorPool);
  
  			vkFreeCommandBuffers(m_device, m_commandPool, BX_COUNTOF(m_commandBuffers), m_commandBuffers);
  			vkDestroy(m_commandPool);
  			vkDestroy(m_fence);
  
  			for (uint32_t ii = 0; ii < BX_COUNTOF(m_backBufferColorImageView); ++ii)
  			{
  				if (VK_NULL_HANDLE != m_backBufferColorImageView[ii])
  				{
  					vkDestroy(m_backBufferColorImageView[ii]);
  				}
  
  				if (VK_NULL_HANDLE != m_backBufferColor[ii])
  				{
  					vkDestroy(m_backBufferColor[ii]);
  				}
  
  				if (VK_NULL_HANDLE != m_presentDone[ii])
  				{
  					vkDestroy(m_presentDone[ii]);
  				}
  			}
  			vkDestroy(m_swapchain);
  
  			vkDestroy(m_backBufferDepthStencilImageView);
  			vkFreeMemory(m_device, m_backBufferDepthStencilMemory, m_allocatorCb);
  			vkDestroy(m_backBufferDepthStencilImage);
  
  			vkDestroySurfaceKHR(m_instance, m_surface, m_allocatorCb);
  
  			vkDestroy(m_renderPass);
  
  			vkDestroyDevice(m_device, m_allocatorCb);
  
  			if (VK_NULL_HANDLE != m_debugReportCallback)
  			{
  				vkDestroyDebugReportCallbackEXT(m_instance, m_debugReportCallback, m_allocatorCb);
  			}
  
  			vkDestroyInstance(m_instance, m_allocatorCb);
  
  			bx::dlclose(m_vulkan1Dll);
  			m_vulkan1Dll  = NULL;
  			m_allocatorCb = NULL;
  			unloadRenderDoc(m_renderDocDll);
  		}
  
  		RendererType::Enum getRendererType() const override
  		{
  			return RendererType::Vulkan;
  		}
  
  		const char* getRendererName() const override
  		{
  			return BGFX_RENDERER_VULKAN_NAME;
  		}
  
  		bool isDeviceRemoved() override
  		{
  			return false;
  		}
  
  		void flip() override
  		{
  			if (VK_NULL_HANDLE != m_swapchain)
  			{
  				VkPresentInfoKHR pi;
  				pi.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
  				pi.pNext = NULL;
  				pi.waitSemaphoreCount = 0;
  				pi.pWaitSemaphores    = NULL; //&m_presentDone[0];
  				pi.swapchainCount = 1;
  				pi.pSwapchains    = &m_swapchain;
  				pi.pImageIndices  = &m_backBufferColorIdx;
  				pi.pResults       = NULL;
  				VK_CHECK(vkQueuePresentKHR(m_queueGraphics, &pi) );
  			}
  		}
  
  		void createIndexBuffer(IndexBufferHandle _handle, const Memory* _mem, uint16_t _flags) override
  		{
  			m_indexBuffers[_handle.idx].create(_mem->size, _mem->data, _flags, false);
  		}
  
  		void destroyIndexBuffer(IndexBufferHandle _handle) override
  		{
  			m_indexBuffers[_handle.idx].destroy();
  		}
  
  		void createVertexDecl(VertexDeclHandle _handle, const VertexDecl& _decl) override
  		{
  			VertexDecl& decl = m_vertexDecls[_handle.idx];
  			bx::memCopy(&decl, &_decl, sizeof(VertexDecl) );
  			dump(decl);
  		}
  
  		void destroyVertexDecl(VertexDeclHandle /*_handle*/) override
  		{
  		}
  
  		void createVertexBuffer(VertexBufferHandle _handle, const Memory* _mem, VertexDeclHandle _declHandle, uint16_t _flags) override
  		{
  			m_vertexBuffers[_handle.idx].create(_mem->size, _mem->data, _declHandle, _flags);
  		}
  
  		void destroyVertexBuffer(VertexBufferHandle _handle) override
  		{
  			m_vertexBuffers[_handle.idx].destroy();
  		}
  
  		void createDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _size, uint16_t _flags) override
  		{
  			m_indexBuffers[_handle.idx].create(_size, NULL, _flags, false);
  		}
  
  		void updateDynamicIndexBuffer(IndexBufferHandle _handle, uint32_t _offset, uint32_t _size, const Memory* _mem) override
  		{
  			BX_UNUSED(_handle, _offset, _size, _mem);
  //			m_indexBuffers[_handle.idx].update(m_commandBuffer, _offset, bx::uint32_min(_size, _mem->size), _mem->data);
  		}
  
  		void destroyDynamicIndexBuffer(IndexBufferHandle _handle) override
  		{
  			m_indexBuffers[_handle.idx].destroy();
  		}
  
  		void createDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _size, uint16_t _flags) override
  		{
  			VertexDeclHandle decl = BGFX_INVALID_HANDLE;
  			m_vertexBuffers[_handle.idx].create(_size, NULL, decl, _flags);
  		}
  
  		void updateDynamicVertexBuffer(VertexBufferHandle _handle, uint32_t _offset, uint32_t _size, const Memory* _mem) override
  		{
  			BX_UNUSED(_handle, _offset, _size, _mem);
  //			m_vertexBuffers[_handle.idx].update(m_commandBuffer, _offset, bx::uint32_min(_size, _mem->size), _mem->data);
  		}
  
  		void destroyDynamicVertexBuffer(VertexBufferHandle _handle) override
  		{
  			m_vertexBuffers[_handle.idx].destroy();
  		}
  
  		void createShader(ShaderHandle _handle, const Memory* _mem) override
  		{
  			m_shaders[_handle.idx].create(_mem);
  		}
  
  		void destroyShader(ShaderHandle _handle) override
  		{
  			m_shaders[_handle.idx].destroy();
  		}
  
  		void createProgram(ProgramHandle _handle, ShaderHandle _vsh, ShaderHandle _fsh) override
  		{
  			m_program[_handle.idx].create(&m_shaders[_vsh.idx], isValid(_fsh) ? &m_shaders[_fsh.idx] : NULL);
  		}
  
  		void destroyProgram(ProgramHandle _handle) override
  		{
  			m_program[_handle.idx].destroy();
  		}
  
  		void* createTexture(TextureHandle /*_handle*/, const Memory* /*_mem*/, uint64_t /*_flags*/, uint8_t /*_skip*/) override
  		{
  			return NULL;
  		}
  
  		void updateTextureBegin(TextureHandle /*_handle*/, uint8_t /*_side*/, uint8_t /*_mip*/) override
  		{
  		}
  
  		void updateTexture(TextureHandle /*_handle*/, uint8_t /*_side*/, uint8_t /*_mip*/, const Rect& /*_rect*/, uint16_t /*_z*/, uint16_t /*_depth*/, uint16_t /*_pitch*/, const Memory* /*_mem*/) override
  		{
  		}
  
  		void updateTextureEnd() override
  		{
  		}
  
  		void readTexture(TextureHandle /*_handle*/, void* /*_data*/, uint8_t /*_mip*/) override
  		{
  		}
  
  		void resizeTexture(TextureHandle /*_handle*/, uint16_t /*_width*/, uint16_t /*_height*/, uint8_t /*_numMips*/, uint16_t /*_numLayers*/) override
  		{
  		}
  
  		void overrideInternal(TextureHandle /*_handle*/, uintptr_t /*_ptr*/) override
  		{
  		}
  
  		uintptr_t getInternal(TextureHandle /*_handle*/) override
  		{
  			return 0;
  		}
  
  		void destroyTexture(TextureHandle /*_handle*/) override
  		{
  		}
  
  		void createFrameBuffer(FrameBufferHandle /*_handle*/, uint8_t /*_num*/, const Attachment* /*_attachment*/) override
  		{
  		}
  
  		void createFrameBuffer(FrameBufferHandle /*_handle*/, void* /*_nwh*/, uint32_t /*_width*/, uint32_t /*_height*/, TextureFormat::Enum /*_format*/, TextureFormat::Enum /*_depthFormat*/) override
  		{
  		}
  
  		void destroyFrameBuffer(FrameBufferHandle /*_handle*/) override
  		{
  		}
  
  		void createUniform(UniformHandle _handle, UniformType::Enum _type, uint16_t _num, const char* _name) override
  		{
  			if (NULL != m_uniforms[_handle.idx])
  			{
  				BX_FREE(g_allocator, m_uniforms[_handle.idx]);
  			}
  
  			uint32_t size = BX_ALIGN_16(g_uniformTypeSize[_type] * _num);
  			void* data = BX_ALLOC(g_allocator, size);
  			bx::memSet(data, 0, size);
  			m_uniforms[_handle.idx] = data;
  			m_uniformReg.add(_handle, _name);
  		}
  
  		void destroyUniform(UniformHandle _handle) override
  		{
  			BX_FREE(g_allocator, m_uniforms[_handle.idx]);
  			m_uniforms[_handle.idx] = NULL;
  		}
  
  		void requestScreenShot(FrameBufferHandle /*_handle*/, const char* /*_filePath*/) override
  		{
  		}
  
  		void updateViewName(ViewId _id, const char* _name) override
  		{
  			bx::strCopy(&s_viewName[_id][BGFX_CONFIG_MAX_VIEW_NAME_RESERVED]
  				, BX_COUNTOF(s_viewName[0]) - BGFX_CONFIG_MAX_VIEW_NAME_RESERVED
  				, _name
  				);
  		}
  
  		void updateUniform(uint16_t _loc, const void* _data, uint32_t _size) override
  		{
  			bx::memCopy(m_uniforms[_loc], _data, _size);
  		}
  
  		void setMarker(const char* /*_marker*/, uint32_t /*_size*/) override
  		{
  		}
  
  		void invalidateOcclusionQuery(OcclusionQueryHandle _handle) override
  		{
  			BX_UNUSED(_handle);
  		}
  
  		virtual void setName(Handle _handle, const char* _name) override
  		{
  			BX_UNUSED(_handle, _name)
  		}
  
  		void submitBlit(BlitState& _bs, uint16_t _view);
  
  		void submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter) override;
  
  		void blitSetup(TextVideoMemBlitter& /*_blitter*/) override
  		{
  		}
  
  		void blitRender(TextVideoMemBlitter& /*_blitter*/, uint32_t /*_numIndices*/) override
  		{
  		}
  
  		void updateResolution(const Resolution& _resolution)
  		{
  			if (!!(_resolution.reset & BGFX_RESET_MAXANISOTROPY) )
  			{
  				m_maxAnisotropy = UINT32_MAX;
  			}
  			else
  			{
  				m_maxAnisotropy = 1;
  			}
  
  			bool depthClamp = !!(_resolution.reset & BGFX_RESET_DEPTH_CLAMP);
  
  			if (m_depthClamp != depthClamp)
  			{
  				m_depthClamp = depthClamp;
  				m_pipelineStateCache.invalidate();
  			}
  
  			uint32_t flags = _resolution.reset & ~(BGFX_RESET_MAXANISOTROPY | BGFX_RESET_DEPTH_CLAMP);
  
  			if (m_resolution.width  != _resolution.width
  			||  m_resolution.height != _resolution.height
  			||  m_resolution.reset  != flags)
  			{
  				flags &= ~BGFX_RESET_INTERNAL_FORCE;
  
  				bool resize = (m_resolution.reset&BGFX_RESET_MSAA_MASK) == (_resolution.reset&BGFX_RESET_MSAA_MASK);
  
  				m_resolution = _resolution;
  				m_resolution.reset = flags;
  
  				m_textVideoMem.resize(false, _resolution.width, _resolution.height);
  				m_textVideoMem.clear();
  
  #if 1
  				BX_UNUSED(resize);
  #else
  				m_scd.BufferDesc.Width  = _resolution.m_width;
  				m_scd.BufferDesc.Height = _resolution.m_height;
  
  				preReset();
  
  				if (resize)
  				{
  					uint32_t nodeMask[] = { 1, 1, 1, 1 };
  					BX_STATIC_ASSERT(BX_COUNTOF(m_backBufferColor) == BX_COUNTOF(nodeMask) );
  					IUnknown* presentQueue[] ={ m_cmd.m_commandQueue, m_cmd.m_commandQueue, m_cmd.m_commandQueue, m_cmd.m_commandQueue };
  					BX_STATIC_ASSERT(BX_COUNTOF(m_backBufferColor) == BX_COUNTOF(presentQueue) );
  
  					DX_CHECK(m_swapChain->ResizeBuffers1(m_scd.BufferCount
  							, m_scd.BufferDesc.Width
  							, m_scd.BufferDesc.Height
  							, m_scd.BufferDesc.Format
  							, m_scd.Flags
  							, nodeMask
  							, presentQueue
  							) );
  				}
  				else
  				{
  					updateMsaa();
  					m_scd.SampleDesc = s_msaa[(m_resolution.m_flags&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT];
  
  					DX_RELEASE(m_swapChain, 0);
  
  					HRESULT hr;
  					hr = m_factory->CreateSwapChain(m_cmd.m_commandQueue
  							, &m_scd
  							, reinterpret_cast<IDXGISwapChain**>(&m_swapChain)
  							);
  					BGFX_FATAL(SUCCEEDED(hr), bgfx::Fatal::UnableToInitialize, "Failed to create swap chain.");
  				}
  
  				postReset();
  #endif // 0
  			}
  		}
  
  		void setShaderUniform(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
  		{
  			BX_UNUSED(_flags, _regIndex, _val, _numRegs);
  			if (_flags&BGFX_UNIFORM_FRAGMENTBIT)
  			{
  				bx::memCopy(&m_fsScratch[_regIndex], _val, _numRegs*16);
  				m_fsChanges += _numRegs;
  			}
  			else
  			{
  				bx::memCopy(&m_vsScratch[_regIndex], _val, _numRegs*16);
  				m_vsChanges += _numRegs;
  			}
  		}
  
  		void setShaderUniform4f(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
  		{
  			setShaderUniform(_flags, _regIndex, _val, _numRegs);
  		}
  
  		void setShaderUniform4x4f(uint8_t _flags, uint32_t _regIndex, const void* _val, uint32_t _numRegs)
  		{
  			setShaderUniform(_flags, _regIndex, _val, _numRegs);
  		}
  
  		void commitShaderUniforms(VkCommandBuffer _commandBuffer, ProgramHandle _program)
  		{
  			const ProgramVK& program = m_program[_program.idx];
  			VkDescriptorBufferInfo descriptorBufferInfo;
  			uint32_t total = 0
  				+ program.m_vsh->m_size
  				+ (NULL != program.m_fsh ? program.m_fsh->m_size : 0)
  				;
  			if (0 < total)
  			{
  				uint8_t* data = (uint8_t*)m_scratchBuffer[m_backBufferColorIdx].allocUbv(descriptorBufferInfo, total);
  
  				uint32_t size = program.m_vsh->m_size;
  				bx::memCopy(data, m_vsScratch, size);
  				data += size;
  
  				if (NULL != program.m_fsh)
  				{
  					bx::memCopy(data, m_fsScratch, program.m_fsh->m_size);
  				}
  
  				vkCmdBindDescriptorSets(_commandBuffer
  					, VK_PIPELINE_BIND_POINT_GRAPHICS
  					, m_pipelineLayout
  					, 0
  					, 1
  					, &m_scratchBuffer[m_backBufferColorIdx].m_descriptorSet
  						[m_scratchBuffer[m_backBufferColorIdx].m_currentDs - 1]
  					, 0
  					, NULL
  					);
  			}
  
  			m_vsChanges = 0;
  			m_fsChanges = 0;
  		}
  
  		void setFrameBuffer(FrameBufferHandle _fbh, bool _msaa = true)
  		{
  			BX_UNUSED(_msaa);
  
  			if (isValid(m_fbh)
  			&&  m_fbh.idx != _fbh.idx)
  			{
  				const FrameBufferVK& frameBuffer = m_frameBuffers[m_fbh.idx];
  				BX_UNUSED(frameBuffer);
  
  //				for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
  //				{
  //					TextureVK& texture = m_textures[frameBuffer.m_texture[ii].idx];
  //					texture.setState(m_commandList, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
  //				}
  //
  //				if (isValid(frameBuffer.m_depth) )
  //				{
  //					TextureVK& texture = m_textures[frameBuffer.m_depth.idx];
  //					const bool writeOnly  = 0 != (texture.m_flags&BGFX_TEXTURE_RT_WRITE_ONLY);
  //					if (!writeOnly)
  //					{
  //						texture.setState(m_commandList, D3D12_RESOURCE_STATE_DEPTH_READ);
  //					}
  //				}
  			}
  
  			if (!isValid(_fbh) )
  			{
  //				m_rtvHandle = m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
  //				uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
  //				m_rtvHandle.ptr += m_backBufferColorIdx * rtvDescriptorSize;
  //				m_dsvHandle = m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
  //
  //				m_currentColor        = &m_rtvHandle;
  //				m_currentDepthStencil = &m_dsvHandle;
  //				m_commandList->OMSetRenderTargets(1, m_currentColor, true, m_currentDepthStencil);
  			}
  			else
  			{
  				const FrameBufferVK& frameBuffer = m_frameBuffers[_fbh.idx];
  				BX_UNUSED(frameBuffer);
  
  				if (0 < frameBuffer.m_num)
  				{
  //					D3D12_CPU_DESCRIPTOR_HANDLE rtvDescriptor = m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
  //					uint32_t rtvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
  //					m_rtvHandle.ptr = rtvDescriptor.ptr + (BX_COUNTOF(m_backBufferColor) + _fbh.idx * BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS) * rtvDescriptorSize;
  //					m_currentColor  = &m_rtvHandle;
  				}
  				else
  				{
  //					m_currentColor = NULL;
  				}
  
  				if (isValid(frameBuffer.m_depth) )
  				{
  //					D3D12_CPU_DESCRIPTOR_HANDLE dsvDescriptor = m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart();
  //					uint32_t dsvDescriptorSize = m_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_DSV);
  //					m_dsvHandle.ptr = dsvDescriptor.ptr + (1 + _fbh.idx) * dsvDescriptorSize;
  //					m_currentDepthStencil = &m_dsvHandle;
  				}
  				else
  				{
  //					m_currentDepthStencil = NULL;
  				}
  
  				for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii)
  				{
  					TextureVK& texture = m_textures[frameBuffer.m_texture[ii].idx];
  					BX_UNUSED(texture);
  //					texture.setState(m_commandList, D3D12_RESOURCE_STATE_RENDER_TARGET);
  				}
  
  				if (isValid(frameBuffer.m_depth) )
  				{
  					TextureVK& texture = m_textures[frameBuffer.m_depth.idx];
  					BX_UNUSED(texture);
  //					texture.setState(m_commandList, D3D12_RESOURCE_STATE_DEPTH_WRITE);
  				}
  
  //				m_commandList->OMSetRenderTargets(frameBuffer.m_num
  //												, m_currentColor
  //												, true
  //												, m_currentDepthStencil
  //												);
  			}
  
  			m_fbh = _fbh;
  //			m_rtMsaa = _msaa;
  		}
  
  		void setBlendState(VkPipelineColorBlendStateCreateInfo& _desc, uint64_t _state, uint32_t _rgba = 0)
  		{
  			VkPipelineColorBlendAttachmentState* bas = const_cast<VkPipelineColorBlendAttachmentState*>(_desc.pAttachments);
  
  			uint8_t writeMask = 0;
  			writeMask |= (_state & BGFX_STATE_WRITE_R) ? VK_COLOR_COMPONENT_R_BIT : 0;
  			writeMask |= (_state & BGFX_STATE_WRITE_G) ? VK_COLOR_COMPONENT_G_BIT : 0;
  			writeMask |= (_state & BGFX_STATE_WRITE_B) ? VK_COLOR_COMPONENT_B_BIT : 0;
  			writeMask |= (_state & BGFX_STATE_WRITE_A) ? VK_COLOR_COMPONENT_A_BIT : 0;
  
  			bas->blendEnable = !!(BGFX_STATE_BLEND_MASK & _state);
  
  			{
  				const uint32_t blend    = uint32_t( (_state & BGFX_STATE_BLEND_MASK         ) >> BGFX_STATE_BLEND_SHIFT);
  				const uint32_t equation = uint32_t( (_state & BGFX_STATE_BLEND_EQUATION_MASK) >> BGFX_STATE_BLEND_EQUATION_SHIFT);
  
  				const uint32_t srcRGB = (blend      ) & 0xf;
  				const uint32_t dstRGB = (blend >>  4) & 0xf;
  				const uint32_t srcA   = (blend >>  8) & 0xf;
  				const uint32_t dstA   = (blend >> 12) & 0xf;
  
  				const uint32_t equRGB = (equation     ) & 0x7;
  				const uint32_t equA   = (equation >> 3) & 0x7;
  
  				bas->srcColorBlendFactor = s_blendFactor[srcRGB][0];
  				bas->dstColorBlendFactor = s_blendFactor[dstRGB][0];
  				bas->colorBlendOp        = s_blendEquation[equRGB];
  
  				bas->srcAlphaBlendFactor = s_blendFactor[srcA][1];
  				bas->dstAlphaBlendFactor = s_blendFactor[dstA][1];
  				bas->alphaBlendOp        = s_blendEquation[equA];
  
  				bas->colorWriteMask = writeMask;
  			}
  
  			uint32_t numAttachments = 1;
  			if (isValid(m_fbh) )
  			{
  				const FrameBufferVK& frameBuffer = m_frameBuffers[m_fbh.idx];
  				numAttachments = frameBuffer.m_num;
  			}
  
  			if (!!(BGFX_STATE_BLEND_INDEPENDENT & _state) )
  			{
  				for (uint32_t ii = 1, rgba = _rgba; ii < numAttachments; ++ii, rgba >>= 11)
  				{
  					++bas;
  					bas->blendEnable =  0 != (rgba & 0x7ff);
  
  					const uint32_t src      = (rgba     ) & 0xf;
  					const uint32_t dst      = (rgba >> 4) & 0xf;
  					const uint32_t equation = (rgba >> 8) & 0x7;
  
  					bas->srcColorBlendFactor = s_blendFactor[src][0];
  					bas->dstColorBlendFactor = s_blendFactor[dst][0];
  					bas->colorBlendOp        = s_blendEquation[equation];
  
  					bas->srcAlphaBlendFactor = s_blendFactor[src][1];
  					bas->dstAlphaBlendFactor = s_blendFactor[dst][1];
  					bas->alphaBlendOp        = s_blendEquation[equation];
  
  					bas->colorWriteMask = writeMask;
  				}
  			}
  			else
  			{
  				for (uint32_t ii = 1; ii < numAttachments; ++ii)
  				{
  					bx::memCopy(&bas[ii], bas, sizeof(VkPipelineColorBlendAttachmentState) );
  				}
  			}
  
  			_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
  			_desc.pNext = NULL;
  			_desc.flags = 0;
  			_desc.logicOpEnable = VK_FALSE;
  			_desc.logicOp       = VK_LOGIC_OP_CLEAR;
  			_desc.attachmentCount = numAttachments;
  			_desc.blendConstants[0] = 0.0f;
  			_desc.blendConstants[1] = 0.0f;
  			_desc.blendConstants[2] = 0.0f;
  			_desc.blendConstants[3] = 0.0f;
  		}
  
  		void setRasterizerState(VkPipelineRasterizationStateCreateInfo& _desc, uint64_t _state, bool _wireframe = false)
  		{
  			const uint32_t cull = (_state&BGFX_STATE_CULL_MASK) >> BGFX_STATE_CULL_SHIFT;
  
  			_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
  			_desc.pNext = NULL;
  			_desc.flags = 0;
  			_desc.depthClampEnable = m_depthClamp;
  			_desc.rasterizerDiscardEnable = VK_FALSE;
  			_desc.polygonMode = _wireframe
  				? VK_POLYGON_MODE_LINE
  				: VK_POLYGON_MODE_FILL
  				;
  			_desc.cullMode  = s_cullMode[cull];
  			_desc.frontFace = VK_FRONT_FACE_CLOCKWISE;
  			_desc.depthBiasEnable = VK_FALSE;
  			_desc.depthBiasConstantFactor = 0.0f;
  			_desc.depthBiasClamp          = 0.0f;
  			_desc.depthBiasSlopeFactor    = 0.0f;
  			_desc.lineWidth               = 1.0f;
  		}
  
  		void setDepthStencilState(VkPipelineDepthStencilStateCreateInfo& _desc, uint64_t _state, uint64_t _stencil = 0)
  		{
  			const uint32_t fstencil = unpackStencil(0, _stencil);
  			uint32_t func = (_state&BGFX_STATE_DEPTH_TEST_MASK)>>BGFX_STATE_DEPTH_TEST_SHIFT;
  
  			_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
  			_desc.pNext = NULL;
  			_desc.flags = 0;
  			_desc.depthTestEnable  = 0 != func;
  			_desc.depthWriteEnable = !!(BGFX_STATE_WRITE_Z & _state);
  			_desc.depthCompareOp   = s_cmpFunc[func];
  			_desc.depthBoundsTestEnable = VK_FALSE;
  
  			_desc.stencilTestEnable = 0 != _stencil;
  
  			uint32_t bstencil = unpackStencil(1, _stencil);
  			uint32_t frontAndBack = bstencil != BGFX_STENCIL_NONE && bstencil != fstencil;
  			bstencil = frontAndBack ? bstencil : fstencil;
  
  			_desc.front.failOp      = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT];
  			_desc.front.passOp      = s_stencilOp[(fstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT];
  			_desc.front.depthFailOp = s_stencilOp[(fstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT];
  			_desc.front.compareOp   = s_cmpFunc[(fstencil & BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT];
  			_desc.front.compareMask = UINT32_MAX;
  			_desc.front.writeMask   = UINT32_MAX;
  			_desc.front.reference   = 0;
  
  			_desc.back.failOp       = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_S_MASK) >> BGFX_STENCIL_OP_FAIL_S_SHIFT];
  			_desc.back.passOp       = s_stencilOp[(bstencil & BGFX_STENCIL_OP_PASS_Z_MASK) >> BGFX_STENCIL_OP_PASS_Z_SHIFT];
  			_desc.back.depthFailOp  = s_stencilOp[(bstencil & BGFX_STENCIL_OP_FAIL_Z_MASK) >> BGFX_STENCIL_OP_FAIL_Z_SHIFT];
  			_desc.back.compareOp    = s_cmpFunc[(bstencil&BGFX_STENCIL_TEST_MASK) >> BGFX_STENCIL_TEST_SHIFT];
  			_desc.back.compareMask  = UINT32_MAX;
  			_desc.back.writeMask    = UINT32_MAX;
  			_desc.back.reference    = 0;
  
  			_desc.minDepthBounds = 0.0f;
  			_desc.maxDepthBounds = 1.0f;
  		}
  
  		uint32_t setInputLayout(VkPipelineVertexInputStateCreateInfo& _vertexInputState, const VertexDecl& _vertexDecl, const ProgramVK& _program, uint8_t _numInstanceData)
  		{
  			_vertexInputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
  			_vertexInputState.pNext = NULL;
  			_vertexInputState.flags = 0;
  
  			VertexDecl decl;
  			bx::memCopy(&decl, &_vertexDecl, sizeof(VertexDecl) );
  			const uint16_t* attrMask = _program.m_vsh->m_attrMask;
  
  			for (uint32_t ii = 0; ii < Attrib::Count; ++ii)
  			{
  				uint16_t mask = attrMask[ii];
  				uint16_t attr = (decl.m_attributes[ii] & mask);
  				decl.m_attributes[ii] = attr == 0 ? UINT16_MAX : attr == UINT16_MAX ? 0 : attr;
  			}
  
  			uint32_t num = fillVertexDecl(_program.m_vsh, _vertexInputState, decl);
  
  //			const D3D12_INPUT_ELEMENT_DESC inst = { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 1 };
  
  			// VK_VERTEX_INPUT_RATE_INSTANCE
  
  			for (uint32_t ii = 0; ii < _numInstanceData; ++ii)
  			{
  				uint32_t index = 7 - ii; // TEXCOORD7 = i_data0, TEXCOORD6 = i_data1, etc.
  
  				BX_UNUSED(index);
  //				bx::memCopy(curr, &inst, sizeof(D3D12_INPUT_ELEMENT_DESC) );
  //				curr->InputSlot = 1;
  //				curr->SemanticIndex = index;
  //				curr->AlignedByteOffset = ii*16;
  			}
  
  			_vertexInputState.vertexAttributeDescriptionCount = num;
  			return num;
  		}
  
  		VkPipeline getPipeline(ProgramHandle _program)
  		{
  			BX_UNUSED(_program);
  			// vkCreateComputePipelines
  			return VK_NULL_HANDLE;
  		}
  
  		VkPipeline getPipeline(uint64_t _state, uint64_t _stencil, uint16_t _declIdx, ProgramHandle _program, uint8_t _numInstanceData)
  		{
  			ProgramVK& program = m_program[_program.idx];
  
  			_state &= 0
  				| BGFX_STATE_WRITE_RGB
  				| BGFX_STATE_WRITE_A
  				| BGFX_STATE_WRITE_Z
  				| BGFX_STATE_DEPTH_TEST_MASK
  				| BGFX_STATE_BLEND_MASK
  				| BGFX_STATE_BLEND_EQUATION_MASK
  				| BGFX_STATE_BLEND_INDEPENDENT
  				| BGFX_STATE_BLEND_ALPHA_TO_COVERAGE
  				| BGFX_STATE_CULL_MASK
  				| BGFX_STATE_MSAA
  				| BGFX_STATE_LINEAA
  				| BGFX_STATE_CONSERVATIVE_RASTER
  				| BGFX_STATE_PT_MASK
  				;
  
  			_stencil &= packStencil(~BGFX_STENCIL_FUNC_REF_MASK, ~BGFX_STENCIL_FUNC_REF_MASK);
  
  			VertexDecl decl;
  			bx::memCopy(&decl, &m_vertexDecls[_declIdx], sizeof(VertexDecl) );
  			const uint16_t* attrMask = program.m_vsh->m_attrMask;
  
  			for (uint32_t ii = 0; ii < Attrib::Count; ++ii)
  			{
  				uint16_t mask = attrMask[ii];
  				uint16_t attr = (decl.m_attributes[ii] & mask);
  				decl.m_attributes[ii] = attr == 0 ? UINT16_MAX : attr == UINT16_MAX ? 0 : attr;
  			}
  
  			bx::HashMurmur2A murmur;
  			murmur.begin();
  			murmur.add(_state);
  			murmur.add(_stencil);
  			murmur.add(program.m_vsh->m_hash);
  			murmur.add(program.m_vsh->m_attrMask, sizeof(program.m_vsh->m_attrMask) );
  			murmur.add(program.m_fsh->m_hash);
  			murmur.add(m_vertexDecls[_declIdx].m_hash);
  			murmur.add(decl.m_attributes, sizeof(decl.m_attributes) );
  			murmur.add(m_fbh.idx);
  			murmur.add(_numInstanceData);
  			const uint32_t hash = murmur.end();
  
  			VkPipeline pipeline = m_pipelineStateCache.find(hash);
  
  			if (VK_NULL_HANDLE != pipeline)
  			{
  				return pipeline;
  			}
  
  			VkPipelineColorBlendAttachmentState blendAttachmentState[BGFX_CONFIG_MAX_FRAME_BUFFER_ATTACHMENTS];
  			VkPipelineColorBlendStateCreateInfo colorBlendState;
  			colorBlendState.pAttachments = blendAttachmentState;
  			setBlendState(colorBlendState, _state);
  
  			VkPipelineInputAssemblyStateCreateInfo inputAssemblyState;
  			inputAssemblyState.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
  			inputAssemblyState.pNext = NULL;
  			inputAssemblyState.flags = 0;
  			inputAssemblyState.topology = s_primInfo[(_state&BGFX_STATE_PT_MASK) >> BGFX_STATE_PT_SHIFT].m_topology;
  			inputAssemblyState.primitiveRestartEnable = VK_FALSE;
  
  			VkPipelineRasterizationStateCreateInfo rasterizationState;
  			setRasterizerState(rasterizationState, _state);
  
  			VkPipelineDepthStencilStateCreateInfo depthStencilState;
  			setDepthStencilState(depthStencilState, _state, _stencil);
  
  			VkVertexInputBindingDescription  inputBinding[Attrib::Count + 1 + BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT];
  			VkVertexInputAttributeDescription inputAttrib[Attrib::Count + 1 + BGFX_CONFIG_MAX_INSTANCE_DATA_COUNT];
  
  			VkPipelineVertexInputStateCreateInfo vertexInputState;
  			vertexInputState.pVertexBindingDescriptions   = inputBinding;
  			vertexInputState.pVertexAttributeDescriptions = inputAttrib;
  			setInputLayout(vertexInputState, m_vertexDecls[_declIdx], program, _numInstanceData);
  
  			const VkDynamicState dynamicStates[] =
  			{
  				VK_DYNAMIC_STATE_VIEWPORT,
  				VK_DYNAMIC_STATE_SCISSOR,
  				VK_DYNAMIC_STATE_BLEND_CONSTANTS,
  				VK_DYNAMIC_STATE_STENCIL_REFERENCE,
  			};
  			VkPipelineDynamicStateCreateInfo dynamicState;
  			dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
  			dynamicState.pNext = NULL;
  			dynamicState.flags = 0;
  			dynamicState.dynamicStateCount = BX_COUNTOF(dynamicStates);
  			dynamicState.pDynamicStates    = dynamicStates;
  
  			VkPipelineShaderStageCreateInfo shaderStages[2];
  			shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
  			shaderStages[0].pNext = NULL;
  			shaderStages[0].flags = 0;
  			shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
  			shaderStages[0].module = program.m_vsh->m_module;
  			shaderStages[0].pName  = "main";
  			shaderStages[0].pSpecializationInfo = NULL;
  			shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
  			shaderStages[1].pNext = NULL;
  			shaderStages[1].flags = 0;
  			shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
  			shaderStages[1].module = program.m_fsh->m_module;
  			shaderStages[1].pName  = "main";
  			shaderStages[1].pSpecializationInfo = NULL;
  
  			VkPipelineViewportStateCreateInfo viewportState;
  			viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
  			viewportState.pNext = NULL;
  			viewportState.flags = 0;
  			viewportState.viewportCount = 1;
  			viewportState.pViewports    = NULL;
  			viewportState.scissorCount  = 1;
  			viewportState.pScissors     = NULL;
  
  			VkPipelineMultisampleStateCreateInfo multisampleState;
  			multisampleState.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
  			multisampleState.pNext = NULL;
  			multisampleState.flags = 0;
  			multisampleState.rasterizationSamples  = VK_SAMPLE_COUNT_1_BIT;
  			multisampleState.sampleShadingEnable   = VK_FALSE;
  			multisampleState.minSampleShading      = !!(BGFX_STATE_CONSERVATIVE_RASTER & _state) ? 1.0f : 0.0f;
  			multisampleState.pSampleMask           = NULL;
  			multisampleState.alphaToCoverageEnable = !!(BGFX_STATE_BLEND_ALPHA_TO_COVERAGE & _state);
  			multisampleState.alphaToOneEnable      = VK_FALSE;
  
  			VkGraphicsPipelineCreateInfo graphicsPipeline;
  			graphicsPipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
  			graphicsPipeline.pNext = NULL;
  			graphicsPipeline.flags = 0;
  			graphicsPipeline.stageCount = BX_COUNTOF(shaderStages);
  			graphicsPipeline.pStages    = shaderStages;
  			graphicsPipeline.pVertexInputState   = &vertexInputState;
  			graphicsPipeline.pInputAssemblyState = &inputAssemblyState;
  			graphicsPipeline.pTessellationState  = NULL;
  			graphicsPipeline.pViewportState      = &viewportState;
  			graphicsPipeline.pRasterizationState = &rasterizationState;
  			graphicsPipeline.pMultisampleState   = &multisampleState;
  			graphicsPipeline.pDepthStencilState  = &depthStencilState;
  			graphicsPipeline.pColorBlendState    = &colorBlendState;
  			graphicsPipeline.pDynamicState       = &dynamicState;
  			graphicsPipeline.layout     = m_pipelineLayout;
  			graphicsPipeline.renderPass = m_renderPass;
  			graphicsPipeline.subpass    = 0;
  			graphicsPipeline.basePipelineHandle = VK_NULL_HANDLE;
  			graphicsPipeline.basePipelineIndex  = 0;
  
  			uint32_t length = g_callback->cacheReadSize(hash);
  			bool cached = length > 0;
  
  			void* cachedData = NULL;
  
  			VkPipelineCacheCreateInfo pcci;
  			pcci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
  			pcci.pNext = NULL;
  			pcci.flags = 0;
  			pcci.initialDataSize = 0;
  			pcci.pInitialData    = NULL;
  
  			if (cached)
  			{
  				cachedData = BX_ALLOC(g_allocator, length);
  				if (g_callback->cacheRead(hash, cachedData, length) )
  				{
  					BX_TRACE("Loading cached pipeline state (size %d).", length);
  					bx::MemoryReader reader(cachedData, length);
  
  					pcci.initialDataSize = (size_t)reader.remaining();
  					pcci.pInitialData    = reader.getDataPtr();
  				}
  			}
  
  			VkPipelineCache cache;
  			VK_CHECK(vkCreatePipelineCache(m_device, &pcci, m_allocatorCb, &cache) );
  
  			VK_CHECK(vkCreateGraphicsPipelines(m_device
  				, cache
  				, 1
  				, &graphicsPipeline
  				, m_allocatorCb
  				, &pipeline
  				) );
  			m_pipelineStateCache.add(hash, pipeline);
  
  			size_t dataSize;
  			VK_CHECK(vkGetPipelineCacheData(m_device, cache, &dataSize, NULL) );
  
  			if (0 < dataSize)
  			{
  				if (length < dataSize)
  				{
  					cachedData = BX_REALLOC(g_allocator, cachedData, dataSize);
  				}
  				VK_CHECK(vkGetPipelineCacheData(m_device, cache, &dataSize, cachedData) );
  				g_callback->cacheWrite(hash, cachedData, (uint32_t)dataSize);
  			}
  
  			VK_CHECK(vkMergePipelineCaches(m_device, m_pipelineCache, 1, &cache) );
  			vkDestroy(cache);
  
  			if (NULL != cachedData)
  			{
  				BX_FREE(g_allocator, cachedData);
  			}
  
  			return pipeline;
  		}
  
  		void commit(UniformBuffer& _uniformBuffer)
  		{
  			_uniformBuffer.reset();
  
  			for (;;)
  			{
  				uint32_t opcode = _uniformBuffer.read();
  
  				if (UniformType::End == opcode)
  				{
  					break;
  				}
  
  				UniformType::Enum type;
  				uint16_t loc;
  				uint16_t num;
  				uint16_t copy;
  				UniformBuffer::decodeOpcode(opcode, type, loc, num, copy);
  
  				const char* data;
  				if (copy)
  				{
  					data = _uniformBuffer.read(g_uniformTypeSize[type]*num);
  				}
  				else
  				{
  					UniformHandle handle;
  					bx::memCopy(&handle, _uniformBuffer.read(sizeof(UniformHandle) ), sizeof(UniformHandle) );
  					data = (const char*)m_uniforms[handle.idx];
  				}
  
  #define CASE_IMPLEMENT_UNIFORM(_uniform, _dxsuffix, _type) \
  				case UniformType::_uniform: \
  				case UniformType::_uniform|BGFX_UNIFORM_FRAGMENTBIT: \
  						{ \
  							setShaderUniform(uint8_t(type), loc, data, num); \
  						} \
  						break;
  
  				switch ( (uint32_t)type)
  				{
  				case UniformType::Mat3:
  				case UniformType::Mat3|BGFX_UNIFORM_FRAGMENTBIT:
  					 {
  						 float* value = (float*)data;
  						 for (uint32_t ii = 0, count = num/3; ii < count; ++ii,  loc += 3*16, value += 9)
  						 {
  							 Matrix4 mtx;
  							 mtx.un.val[ 0] = value[0];
  							 mtx.un.val[ 1] = value[1];
  							 mtx.un.val[ 2] = value[2];
  							 mtx.un.val[ 3] = 0.0f;
  							 mtx.un.val[ 4] = value[3];
  							 mtx.un.val[ 5] = value[4];
  							 mtx.un.val[ 6] = value[5];
  							 mtx.un.val[ 7] = 0.0f;
  							 mtx.un.val[ 8] = value[6];
  							 mtx.un.val[ 9] = value[7];
  							 mtx.un.val[10] = value[8];
  							 mtx.un.val[11] = 0.0f;
  							 setShaderUniform(uint8_t(type), loc, &mtx.un.val[0], 3);
  						 }
  					}
  					break;
  
  				CASE_IMPLEMENT_UNIFORM(Int1, I, int);
  				CASE_IMPLEMENT_UNIFORM(Vec4, F, float);
  				CASE_IMPLEMENT_UNIFORM(Mat4, F, float);
  
  				case UniformType::End:
  					break;
  
  				default:
  					BX_TRACE("%4d: INVALID 0x%08x, t %d, l %d, n %d, c %d", _uniformBuffer.getPos(), opcode, type, loc, num, copy);
  					break;
  				}
  #undef CASE_IMPLEMENT_UNIFORM
  			}
  		}
  
  		void clearQuad(const Rect& _rect, const Clear& _clear, const float _palette[][4])
  		{
  			VkClearRect rect[1];
  			rect[0].rect.offset.x      = _rect.m_x;
  			rect[0].rect.offset.y      = _rect.m_y;
  			rect[0].rect.extent.width  = _rect.m_width;
  			rect[0].rect.extent.height = _rect.m_height;
  			rect[0].baseArrayLayer = 0;
  			rect[0].layerCount     = 1;
  
  			uint32_t numMrt = 1;
  //			FrameBufferHandle fbh = m_fbh;
  //			if (isValid(fbh) )
  //			{
  //				const FrameBufferVK& fb = m_frameBuffers[fbh.idx];
  //				numMrt = bx::uint32_max(1, fb.m_num);
  //			}
  
  			VkClearAttachment attachments[BGFX_CONFIG_MAX_FRAME_BUFFERS];
  			uint32_t mrt = 0;
  
  			if (true //NULL != m_currentColor
  			&&  BGFX_CLEAR_COLOR & _clear.m_flags)
  			{
  				if (BGFX_CLEAR_COLOR_USE_PALETTE & _clear.m_flags)
  				{
  					for (uint32_t ii = 0; ii < numMrt; ++ii)
  					{
  						attachments[mrt].colorAttachment = mrt;
  						attachments[mrt].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  						uint8_t index = (uint8_t)bx::uint32_min(BGFX_CONFIG_MAX_COLOR_PALETTE-1, _clear.m_index[ii]);
  						bx::memCopy(&attachments[mrt].clearValue.color.float32, _palette[index], 16);
  						++mrt;
  					}
  				}
  				else
  				{
  					float frgba[4] =
  					{
  						_clear.m_index[0] * 1.0f / 255.0f,
  						_clear.m_index[1] * 1.0f / 255.0f,
  						_clear.m_index[2] * 1.0f / 255.0f,
  						_clear.m_index[3] * 1.0f / 255.0f,
  					};
  
  					for (uint32_t ii = 0; ii < numMrt; ++ii)
  					{
  						attachments[mrt].colorAttachment = mrt;
  						attachments[mrt].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  						bx::memCopy(&attachments[mrt].clearValue.color.float32, frgba, 16);
  						++mrt;
  					}
  				}
  			}
  
  			if (true //NULL != m_currentDepthStencil
  			&& (BGFX_CLEAR_DEPTH | BGFX_CLEAR_STENCIL) & _clear.m_flags)
  			{
  				attachments[mrt].colorAttachment = mrt;
  				attachments[mrt].aspectMask = 0;
  				attachments[mrt].aspectMask |= (_clear.m_flags & BGFX_CLEAR_DEPTH  ) ? VK_IMAGE_ASPECT_DEPTH_BIT   : 0;
  				attachments[mrt].aspectMask |= (_clear.m_flags & BGFX_CLEAR_STENCIL) ? VK_IMAGE_ASPECT_STENCIL_BIT : 0;
  
  				attachments[mrt].clearValue.depthStencil.stencil = _clear.m_stencil;
  				attachments[mrt].clearValue.depthStencil.depth   = _clear.m_depth;
  				++mrt;
  			}
  
   			vkCmdClearAttachments(m_commandBuffer
  				, mrt
  				, attachments
  				, BX_COUNTOF(rect)
  				, rect
  				);
  		}
  
  		uint64_t kick(VkSemaphore _wait = VK_NULL_HANDLE, VkSemaphore _signal = VK_NULL_HANDLE)
  		{
  			VkPipelineStageFlags stageFlags = 0
  				| VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
  				;
  
  			VkSubmitInfo si;
  			si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
  			si.pNext = NULL;
  			si.waitSemaphoreCount = VK_NULL_HANDLE != _wait;
  			si.pWaitSemaphores    = &_wait;
  			si.pWaitDstStageMask  = &stageFlags;
  			si.commandBufferCount = 1;
  			si.pCommandBuffers    = &m_commandBuffers[m_backBufferColorIdx];
  			si.signalSemaphoreCount = VK_NULL_HANDLE != _signal;
  			si.pSignalSemaphores    = &_signal;
  
  //			VK_CHECK(vkResetFences(m_device, 1, &m_fence) );
  			VK_CHECK(vkQueueSubmit(m_queueGraphics, 1, &si, VK_NULL_HANDLE) );
  			return 0;
  		}
  
  		void finish()
  		{
  			finishAll();
  		}
  
  		void finishAll()
  		{
  			VK_CHECK(vkQueueWaitIdle(m_queueGraphics) );
  //			VK_CHECK(vkWaitForFences(m_device, 1, &m_fence, true, INT64_MAX) );
  		}
  
  		uint32_t selectMemoryType(uint32_t _memoryTypeBits, uint32_t _propertyFlags) const
  		{
  			for (uint32_t ii = 0, num = m_memoryProperties.memoryTypeCount; ii < num; ++ii)
  			{
  				const VkMemoryType& memType = m_memoryProperties.memoryTypes[ii];
  				if ( (0 != ( (1<<ii) & _memoryTypeBits) )
  				&& ( (memType.propertyFlags & _propertyFlags) == _propertyFlags) )
  				{
  					return ii;
  				}
  			}
  
  			BX_TRACE("Failed to find memory that supports flags 0x%08x.", _propertyFlags);
  			return 0;
  		}
  
  		VkAllocationCallbacks*   m_allocatorCb;
  		VkDebugReportCallbackEXT m_debugReportCallback;
  		VkInstance       m_instance;
  		VkPhysicalDevice m_physicalDevice;
  
  		VkPhysicalDeviceProperties       m_deviceProperties;
  		VkPhysicalDeviceMemoryProperties m_memoryProperties;
  
  		VkSwapchainCreateInfoKHR m_sci;
  		VkSurfaceKHR     m_surface;
  		VkSwapchainKHR   m_swapchain;
  		VkImage          m_backBufferColorImage[4];
  		VkImageView      m_backBufferColorImageView[4];
  		VkFramebuffer    m_backBufferColor[4];
  		VkCommandBuffer  m_commandBuffers[4];
  		VkCommandBuffer  m_commandBuffer;
  
  		VkFormat         m_backBufferDepthStencilFormat;
  		VkDeviceMemory   m_backBufferDepthStencilMemory;
  		VkImage          m_backBufferDepthStencilImage;
  		VkImageView      m_backBufferDepthStencilImageView;
  
  		ScratchBufferVK  m_scratchBuffer[4];
  		VkSemaphore      m_presentDone[4];
  
  		uint32_t m_qfiGraphics;
  		uint32_t m_qfiCompute;
  
  		VkDevice m_device;
  		VkQueue  m_queueGraphics;
  		VkQueue  m_queueCompute;
  		VkFence  m_fence;
  		VkRenderPass m_renderPass;
  		VkDescriptorPool m_descriptorPool;
  		VkDescriptorSetLayout m_descriptorSetLayout;
  		VkPipelineLayout m_pipelineLayout;
  		VkPipelineCache m_pipelineCache;
  		VkCommandPool m_commandPool;
  
  		void* m_renderDocDll;
  		void* m_vulkan1Dll;
  
  		IndexBufferVK m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS];
  		VertexBufferVK m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS];
  		ShaderVK m_shaders[BGFX_CONFIG_MAX_SHADERS];
  		ProgramVK m_program[BGFX_CONFIG_MAX_PROGRAMS];
  		TextureVK m_textures[BGFX_CONFIG_MAX_TEXTURES];
  		VertexDecl m_vertexDecls[BGFX_CONFIG_MAX_VERTEX_DECLS];
  		FrameBufferVK m_frameBuffers[BGFX_CONFIG_MAX_FRAME_BUFFERS];
  		void* m_uniforms[BGFX_CONFIG_MAX_UNIFORMS];
  		Matrix4 m_predefinedUniforms[PredefinedUniform::Count];
  		UniformRegistry m_uniformReg;
  
  		StateCacheT<VkPipeline> m_pipelineStateCache;
  
  		Resolution m_resolution;
  		uint32_t m_maxAnisotropy;
  		bool m_depthClamp;
  		bool m_wireframe;
  
  		TextVideoMem m_textVideoMem;
  
  		uint8_t m_fsScratch[64<<10];
  		uint8_t m_vsScratch[64<<10];
  		uint32_t m_fsChanges;
  		uint32_t m_vsChanges;
  
  		uint32_t m_backBufferColorIdx;
  		FrameBufferHandle m_fbh;
  	};
  
  	static RendererContextVK* s_renderVK;
  
  	RendererContextI* rendererCreate(const Init& _init)
  	{
  		s_renderVK = BX_NEW(g_allocator, RendererContextVK);
  		if (!s_renderVK->init(_init) )
  		{
  			BX_DELETE(g_allocator, s_renderVK);
  			s_renderVK = NULL;
  		}
  		return s_renderVK;
  	}
  
  	void rendererDestroy()
  	{
  		s_renderVK->shutdown();
  		BX_DELETE(g_allocator, s_renderVK);
  		s_renderVK = NULL;
  	}
  
  #define VK_DESTROY_FUNC(_name) \
  			void vkDestroy(Vk##_name& _obj) \
  			{ \
  				if (VK_NULL_HANDLE != _obj) \
  				{ \
  					vkDestroy##_name(s_renderVK->m_device, _obj, s_renderVK->m_allocatorCb); \
  					_obj = VK_NULL_HANDLE; \
  				} \
  			}
  VK_DESTROY
  #undef VK_DESTROY_FUNC
  
  	void ScratchBufferVK::create(uint32_t _size, uint32_t _maxDescriptors)
  	{
  		m_maxDescriptors = _maxDescriptors;
  		m_descriptorSet  = (VkDescriptorSet*)BX_ALLOC(g_allocator, _maxDescriptors * sizeof(VkDescriptorSet) );
  
  		VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
  		VkDevice device = s_renderVK->m_device;
  
  		VkDescriptorSetAllocateInfo dsai;
  		dsai.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
  		dsai.pNext = NULL;
  		dsai.descriptorPool = s_renderVK->m_descriptorPool;
  		dsai.descriptorSetCount = 1;
  		dsai.pSetLayouts        = &s_renderVK->m_descriptorSetLayout;
  		for (uint32_t ii = 0, num = m_maxDescriptors; ii < num; ++ii)
  		{
  			VK_CHECK(vkAllocateDescriptorSets(device, &dsai, &m_descriptorSet[ii]) );
  		}
  
  		VkBufferCreateInfo bci;
  		bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  		bci.pNext = NULL;
  		bci.flags = 0;
  		bci.size  = _size;
  		bci.usage = 0
  			| VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
  //			| VK_BUFFER_USAGE_TRANSFER_DST_BIT
  			;
  		bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  		bci.queueFamilyIndexCount = 0;
  		bci.pQueueFamilyIndices   = NULL;
  
  		VK_CHECK(vkCreateBuffer(device
  			, &bci
  			, allocatorCb
  			, &m_buffer
  			) );
  
  		VkMemoryRequirements mr;
  		vkGetBufferMemoryRequirements(device
  			, m_buffer
  			, &mr
  			);
  
  		VkMemoryAllocateInfo ma;
  		ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  		ma.pNext = NULL;
  		ma.allocationSize  = mr.size;
  		ma.memoryTypeIndex = s_renderVK->selectMemoryType(mr.memoryTypeBits
  			, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
  			);
  		VK_CHECK(vkAllocateMemory(device
  			, &ma
  			, allocatorCb
  			, &m_deviceMem
  			) );
  
  		m_size = (uint32_t)mr.size;
  		m_pos  = 0;
  
  		VK_CHECK(vkBindBufferMemory(device, m_buffer, m_deviceMem, 0) );
  
  		VK_CHECK(vkMapMemory(device, m_deviceMem, 0, ma.allocationSize, 0, (void**)&m_data) );
  	}
  
  	void ScratchBufferVK::destroy()
  	{
  		VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
  		VkDevice device = s_renderVK->m_device;
  
  		vkFreeDescriptorSets(device, s_renderVK->m_descriptorPool, m_maxDescriptors, m_descriptorSet);
  		BX_FREE(g_allocator, m_descriptorSet);
  
  		vkUnmapMemory(device, m_deviceMem);
  
  		vkDestroy(m_buffer);
  
  		vkFreeMemory(device
  			, m_deviceMem
  			, allocatorCb
  			);
  	}
  
  	void ScratchBufferVK::reset(VkDescriptorBufferInfo& /*_descriptorBufferInfo*/)
  	{
  		m_pos = 0;
  		m_currentDs = 0;
  	}
  
  	void* ScratchBufferVK::allocUbv(VkDescriptorBufferInfo& _descriptorBufferInfo, uint32_t _size)
  	{
  		uint32_t total = bx::strideAlign(_size
  			, uint32_t(s_renderVK->m_deviceProperties.limits.minUniformBufferOffsetAlignment)
  			);
  		_descriptorBufferInfo.buffer = m_buffer;
  		_descriptorBufferInfo.offset = m_pos;
  		_descriptorBufferInfo.range  = total;
  
  		VkWriteDescriptorSet wds[1];
  		wds[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
  		wds[0].pNext = NULL;
  		wds[0].dstSet     = m_descriptorSet[m_currentDs];
  		wds[0].dstBinding = DslBinding::UniformBuffer;
  		wds[0].dstArrayElement  = 0;
  		wds[0].descriptorCount  = 1;
  		wds[0].descriptorType   = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
  		wds[0].pImageInfo       = NULL;
  		wds[0].pBufferInfo      = &_descriptorBufferInfo;
  		wds[0].pTexelBufferView = NULL;
  		vkUpdateDescriptorSets(s_renderVK->m_device, BX_COUNTOF(wds), wds, 0, NULL);
  
  		void* data = &m_data[m_pos];
  		m_pos += total;
  		++m_currentDs;
  
  		return data;
  	}
  
  	VkResult ImageVK::create(VkFormat _format, const VkExtent3D& _extent)
  	{
  		VkResult result;
  
  		VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
  		VkDevice device = s_renderVK->m_device;
  
  		VkImageCreateInfo ici;
  		ici.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
  		ici.pNext = NULL;
  		ici.flags = 0;
  		ici.imageType = VK_IMAGE_TYPE_2D;
  		ici.format = _format;
  		ici.extent = _extent;
  		ici.mipLevels   = 1;
  		ici.arrayLayers = 1;
  		ici.samples = VK_SAMPLE_COUNT_1_BIT;
  		ici.tiling  = VK_IMAGE_TILING_OPTIMAL;
  		ici.usage   = 0
  			| VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
  			| VK_IMAGE_USAGE_TRANSFER_SRC_BIT
  			;
  		ici.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  		ici.queueFamilyIndexCount = 0;
  		ici.pQueueFamilyIndices   = 0;
  		ici.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
  		result = vkCreateImage(device, &ici, allocatorCb, &m_image);
  
  		if (VK_SUCCESS != result)
  		{
  			BX_TRACE("vkCreateImage failed %d: %s.", result, getName(result) );
  			return result;
  		}
  
  		VkMemoryRequirements mr;
  		vkGetImageMemoryRequirements(device, m_image, &mr);
  
  		VkMemoryAllocateInfo ma;
  		ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  		ma.pNext = NULL;
  		ma.allocationSize  = mr.size;
  		ma.memoryTypeIndex = s_renderVK->selectMemoryType(mr.memoryTypeBits
  			, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
  			);
  		result = vkAllocateMemory(device
  			, &ma
  			, allocatorCb
  			, &m_memory
  			);
  
  		if (VK_SUCCESS != result)
  		{
  			BX_TRACE("vkAllocateMemory failed %d: %s.", result, getName(result) );
  			destroy();
  			return result;
  		}
  
  		result = vkBindImageMemory(device, m_image, m_memory, 0);
  
  		if (VK_SUCCESS != result)
  		{
  			BX_TRACE("vkBindImageMemory failed %d: %s.", result, getName(result) );
  			destroy();
  			return result;
  		}
  
  		VkImageViewCreateInfo ivci;
  		ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
  		ivci.pNext = NULL;
  		ivci.flags = 0;
  		ivci.image    = m_image;
  		ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
  		ivci.format   = _format;
  		ivci.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
  		ivci.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
  		ivci.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
  		ivci.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
  		ivci.subresourceRange.aspectMask = 0
  			| VK_IMAGE_ASPECT_DEPTH_BIT
  			| VK_IMAGE_ASPECT_STENCIL_BIT
  			;
  		ivci.subresourceRange.baseMipLevel   = 0;
  		ivci.subresourceRange.levelCount     = 1;
  		ivci.subresourceRange.baseArrayLayer = 0;
  		ivci.subresourceRange.layerCount     = 1;
  		result = vkCreateImageView(device, &ivci, allocatorCb, &m_imageView);
  
  		if (VK_SUCCESS != result)
  		{
  			BX_TRACE("vkCreateImageView failed %d: %s.", result, getName(result) );
  			destroy();
  			return result;
  		}
  
  		return VK_SUCCESS;
  	}
  
  	void ImageVK::destroy()
  	{
  		vkDestroy(m_imageView);
  		vkDestroy(m_image);
  		if (VK_NULL_HANDLE != m_memory)
  		{
  			vkFreeMemory(s_renderVK->m_device, m_memory, s_renderVK->m_allocatorCb);
  			m_memory = VK_NULL_HANDLE;
  		}
  	}
  
  	void BufferVK::create(uint32_t _size, void* _data, uint16_t _flags, bool _vertex, uint32_t _stride)
  	{
  		BX_UNUSED(_stride);
  
  		m_size    = _size;
  		m_flags   = _flags;
  		m_dynamic = NULL == _data;
  
  		VkBufferCreateInfo bci;
  		bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  		bci.pNext = NULL;
  		bci.flags = 0;
  		bci.size  = _size;
  		bci.usage = 0
  			| (m_dynamic ? VK_BUFFER_USAGE_TRANSFER_DST_BIT  : 0)
  			| (_vertex   ? VK_BUFFER_USAGE_VERTEX_BUFFER_BIT : VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
  			;
  		bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
  		bci.queueFamilyIndexCount = 0;
  		bci.pQueueFamilyIndices   = NULL;
  
  		VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
  		VkDevice device = s_renderVK->m_device;
  		VK_CHECK(vkCreateBuffer(device
  			, &bci
  			, allocatorCb
  			, &m_buffer
  			) );
  
  		VkMemoryRequirements mr;
  		vkGetBufferMemoryRequirements(device
  			, m_buffer
  			, &mr
  			);
  
  		VkMemoryAllocateInfo ma;
  		ma.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  		ma.pNext = NULL;
  		ma.allocationSize  = mr.size;
  		ma.memoryTypeIndex = s_renderVK->selectMemoryType(mr.memoryTypeBits
  			, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
  			);
  		VK_CHECK(vkAllocateMemory(device
  			, &ma
  			, allocatorCb
  			, &m_deviceMem
  			) );
  
  		if (!m_dynamic)
  		{
  			void* dst;
  			VK_CHECK(vkMapMemory(device, m_deviceMem, 0, ma.allocationSize, 0, &dst) );
  			bx::memCopy(dst, _data, _size);
  			vkUnmapMemory(device, m_deviceMem);
  		}
  
  		VK_CHECK(vkBindBufferMemory(device, m_buffer, m_deviceMem, 0) );
  	}
  
  	void BufferVK::update(VkCommandBuffer _commandBuffer, uint32_t _offset, uint32_t _size, void* _data, bool _discard)
  	{
  		BX_UNUSED(_commandBuffer, _offset, _size, _data, _discard);
  	}
  
  	void BufferVK::destroy()
  	{
  		if (VK_NULL_HANDLE != m_buffer)
  		{
  			VkAllocationCallbacks* allocatorCb = s_renderVK->m_allocatorCb;
  			VkDevice device = s_renderVK->m_device;
  
  			vkDestroy(m_buffer);
  			vkFreeMemory(device
  				, m_deviceMem
  				, allocatorCb
  				);
  			m_dynamic = false;
  		}
  	}
  
  	void VertexBufferVK::create(uint32_t _size, void* _data, VertexDeclHandle _declHandle, uint16_t _flags)
  	{
  		BufferVK::create(_size, _data, _flags, true);
  		m_decl = _declHandle;
  	}
  
  	void ShaderVK::create(const Memory* _mem)
  	{
  		bx::MemoryReader reader(_mem->data, _mem->size);
  
  		uint32_t magic;
  		bx::read(&reader, magic);
  
  		VkShaderStageFlagBits shaderStage;
  		BX_UNUSED(shaderStage);
  
  		if (isShaderType(magic, 'C') )
  		{
  			shaderStage = VK_SHADER_STAGE_COMPUTE_BIT;
  		}
  		else if (isShaderType(magic, 'F') )
  		{
  			shaderStage = VK_SHADER_STAGE_FRAGMENT_BIT;
  		}
  		else if (isShaderType(magic, 'V') )
  		{
  			shaderStage = VK_SHADER_STAGE_VERTEX_BIT;
  		}
  
  		const bool fragment = isShaderType(magic, 'F');
  
  		uint32_t hashIn;
  		bx::read(&reader, hashIn);
  
  		uint32_t hashOut;
  
  		if (isShaderVerLess(magic, 6) )
  		{
  			hashOut = hashIn;
  		}
  		else
  		{
  			bx::read(&reader, hashOut);
  		}
  
  		uint16_t count;
  		bx::read(&reader, count);
  
  		m_numPredefined = 0;
  		m_numUniforms = count;
  
  		BX_TRACE("%s Shader consts %d"
  			, getShaderTypeName(magic)
  			, count
  			);
  
  		uint8_t fragmentBit = fragment ? BGFX_UNIFORM_FRAGMENTBIT : 0;
  
  		if (0 < count)
  		{
  			for (uint32_t ii = 0; ii < count; ++ii)
  			{
  				uint8_t nameSize = 0;
  				bx::read(&reader, nameSize);
  
  				char name[256];
  				bx::read(&reader, &name, nameSize);
  				name[nameSize] = '\0';
  
  				uint8_t type = 0;
  				bx::read(&reader, type);
  
  				uint8_t num;
  				bx::read(&reader, num);
  
  				uint16_t regIndex;
  				bx::read(&reader, regIndex);
  
  				uint16_t regCount;
  				bx::read(&reader, regCount);
  
  				const char* kind = "invalid";
  
  				PredefinedUniform::Enum predefined = nameToPredefinedUniformEnum(name);
  				if (PredefinedUniform::Count != predefined)
  				{
  					kind = "predefined";
  					m_predefined[m_numPredefined].m_loc   = regIndex;
  					m_predefined[m_numPredefined].m_count = regCount;
  					m_predefined[m_numPredefined].m_type  = uint8_t(predefined|fragmentBit);
  					m_numPredefined++;
  				}
  				else if (0 == (BGFX_UNIFORM_SAMPLERBIT & type) )
  				{
  					const UniformRegInfo* info = s_renderVK->m_uniformReg.find(name);
  					BX_CHECK(NULL != info, "User defined uniform '%s' is not found, it won't be set.", name);
  
  					if (NULL != info)
  					{
  						if (NULL == m_constantBuffer)
  						{
  							m_constantBuffer = UniformBuffer::create(1024);
  						}
  
  						kind = "user";
  						m_constantBuffer->writeUniformHandle( (UniformType::Enum)(type|fragmentBit), regIndex, info->m_handle, regCount);
  					}
  				}
  				else
  				{
  					kind = "sampler";
  				}
  
  				BX_TRACE("\t%s: %s (%s), num %2d, r.index %3d, r.count %2d"
  					, kind
  					, name
  					, getUniformTypeName(UniformType::Enum(type&~BGFX_UNIFORM_MASK) )
  					, num
  					, regIndex
  					, regCount
  					);
  				BX_UNUSED(kind);
  			}
  
  			if (NULL != m_constantBuffer)
  			{
  				m_constantBuffer->finish();
  			}
  		}
  
  		uint32_t shaderSize;
  		bx::read(&reader, shaderSize);
  
  		const void* code = reader.getDataPtr();
  		bx::skip(&reader, shaderSize+1);
  
  		m_code = alloc(shaderSize);
  		bx::memCopy(m_code->data
  			, code
  			, shaderSize
  			);
  
  		VkShaderModuleCreateInfo smci;
  		smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
  		smci.pNext = NULL;
  		smci.flags = 0;
  		smci.codeSize = m_code->size;
  		smci.pCode    = (const uint32_t*)m_code->data;
  		VK_CHECK(vkCreateShaderModule(
  			  s_renderVK->m_device
  			, &smci
  			, s_renderVK->m_allocatorCb
  			, &m_module
  			) );
  
  		bx::memSet(m_attrMask,  0, sizeof(m_attrMask) );
  		bx::memSet(m_attrRemap, 0, sizeof(m_attrRemap) );
  
  		bx::read(&reader, m_numAttrs);
  
  		for (uint8_t ii = 0; ii < m_numAttrs; ++ii)
  		{
  			uint16_t id;
  			bx::read(&reader, id);
  
  			Attrib::Enum attr = idToAttrib(id);
  
  			if (Attrib::Count != attr)
  			{
  				m_attrMask[attr]  = UINT16_MAX;
  				m_attrRemap[attr] = ii;
  			}
  		}
  
  		bx::HashMurmur2A murmur;
  		murmur.begin();
  		murmur.add(hashIn);
  		murmur.add(hashOut);
  		murmur.add(m_code->data, m_code->size);
  		murmur.add(m_numAttrs);
  		murmur.add(m_attrMask,  m_numAttrs);
  		murmur.add(m_attrRemap, m_numAttrs);
  		m_hash = murmur.end();
  
  		bx::read(&reader, m_size);
  	}
  
  	void ShaderVK::destroy()
  	{
  		if (NULL != m_constantBuffer)
  		{
  			UniformBuffer::destroy(m_constantBuffer);
  			m_constantBuffer = NULL;
  		}
  
  		m_numPredefined = 0;
  
  		if (NULL != m_code)
  		{
  			release(m_code);
  			m_code = NULL;
  			m_hash = 0;
  		}
  
  		if (VK_NULL_HANDLE != m_module)
  		{
  			vkDestroy(m_module);
  		}
  	}
  
  	void TextureVK::destroy()
  	{
  	}
  
  	void FrameBufferVK::destroy()
  	{
  	}
  
  	void RendererContextVK::submitBlit(BlitState& _bs, uint16_t _view)
  	{
  		while (_bs.hasItem(_view) )
  		{
  			const BlitItem& blit = _bs.advance();
  			BX_UNUSED(blit);
  		}
  	}
  
  	void RendererContextVK::submit(Frame* _render, ClearQuad& _clearQuad, TextVideoMemBlitter& _textVideoMemBlitter)
  	{
  		BX_UNUSED(_render, _clearQuad, _textVideoMemBlitter);
  
  		updateResolution(_render->m_resolution);
  
  		int64_t timeBegin = bx::getHPCounter();
  		int64_t captureElapsed = 0;
  
  //		m_gpuTimer.begin(m_commandList);
  
  		if (0 < _render->m_iboffset)
  		{
  //			TransientIndexBuffer* ib = _render->m_transientIb;
  //			m_indexBuffers[ib->handle.idx].update(m_commandList, 0, _render->m_iboffset, ib->data);
  		}
  
  		if (0 < _render->m_vboffset)
  		{
  //			TransientVertexBuffer* vb = _render->m_transientVb;
  //			m_vertexBuffers[vb->handle.idx].update(m_commandList, 0, _render->m_vboffset, vb->data);
  		}
  
  		_render->sort();
  
  		RenderDraw currentState;
  		currentState.clear();
  		currentState.m_stateFlags = BGFX_STATE_NONE;
  		currentState.m_stencil    = packStencil(BGFX_STENCIL_NONE, BGFX_STENCIL_NONE);
  
  		static ViewState viewState;
  		viewState.reset(_render);
  
  // 		bool wireframe = !!(_render->m_debug&BGFX_DEBUG_WIREFRAME);
  // 		setDebugWireframe(wireframe);
  
  		uint16_t currentSamplerStateIdx = kInvalidHandle;
  		ProgramHandle currentProgram    = BGFX_INVALID_HANDLE;
  		uint32_t currentBindHash        = 0;
  		bool     hasPredefined          = false;
  		bool     commandListChanged     = false;
  		VkPipeline currentPipeline = VK_NULL_HANDLE;
  		SortKey key;
  		uint16_t view = UINT16_MAX;
  		FrameBufferHandle fbh = { BGFX_CONFIG_MAX_FRAME_BUFFERS };
  
  		BlitState bs(_render);
  
  		uint32_t blendFactor = 0;
  
  		const uint64_t primType = _render->m_debug&BGFX_DEBUG_WIREFRAME ? BGFX_STATE_PT_LINES : 0;
  		uint8_t primIndex = uint8_t(primType >> BGFX_STATE_PT_SHIFT);
  		PrimInfo prim = s_primInfo[primIndex];
  
  		bool wasCompute = false;
  		bool viewHasScissor = false;
  		bool restoreScissor = false;
  		Rect viewScissorRect;
  		viewScissorRect.clear();
  
  		const uint32_t maxComputeBindings = g_caps.limits.maxComputeBindings;
  		BX_UNUSED(maxComputeBindings);
  
  		uint32_t statsNumPrimsSubmitted[BX_COUNTOF(s_primInfo)] = {};
  		uint32_t statsNumPrimsRendered[BX_COUNTOF(s_primInfo)] = {};
  		uint32_t statsNumInstances[BX_COUNTOF(s_primInfo)] = {};
  		uint32_t statsNumIndices = 0;
  		uint32_t statsKeyType[2] = {};
  
  		VkSemaphore renderWait = m_presentDone[m_backBufferColorIdx];
  		VK_CHECK(vkAcquireNextImageKHR(m_device
  				, m_swapchain
  				, UINT64_MAX
  				, renderWait
  				, VK_NULL_HANDLE
  				, &m_backBufferColorIdx
  				) );
  
  		const uint64_t f0 = BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_FACTOR, BGFX_STATE_BLEND_FACTOR);
  		const uint64_t f1 = BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_INV_FACTOR, BGFX_STATE_BLEND_INV_FACTOR);
  
  
  		ScratchBufferVK& scratchBuffer = m_scratchBuffer[m_backBufferColorIdx];
  		VkDescriptorBufferInfo descriptorBufferInfo;
  		scratchBuffer.reset(descriptorBufferInfo);
  
  		VkCommandBufferBeginInfo cbbi;
  		cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
  		cbbi.pNext = NULL;
  		cbbi.flags = 0
  			| VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
  //			| VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
  			;
  		cbbi.pInheritanceInfo = NULL;
  
  		m_commandBuffer = m_commandBuffers[m_backBufferColorIdx];
  		VK_CHECK(vkBeginCommandBuffer(m_commandBuffer, &cbbi) );
  
  		setImageMemoryBarrier(m_commandBuffer
  			, m_backBufferColorImage[m_backBufferColorIdx]
  			, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
  			, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
  			);
  
  		VkRenderPassBeginInfo rpbi;
  		rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
  		rpbi.pNext = NULL;
  		rpbi.renderPass  = m_renderPass;
  		rpbi.framebuffer = m_backBufferColor[m_backBufferColorIdx];
  		rpbi.renderArea.offset.x = 0;
  		rpbi.renderArea.offset.y = 0;
  		rpbi.renderArea.extent = m_sci.imageExtent;
  		rpbi.clearValueCount = 0;
  		rpbi.pClearValues    = NULL;
  
  		bool beginRenderPass = false;
  
  		if (0 == (_render->m_debug&BGFX_DEBUG_IFH) )
  		{
  //			m_batch.begin();
  
  			viewState.m_rect = _render->m_view[0].m_rect;
  
  			int32_t numItems = _render->m_numRenderItems;
  			for (int32_t item = 0; item < numItems;)
  			{
  				const uint64_t encodedKey = _render->m_sortKeys[item];
  				const bool isCompute = key.decode(encodedKey, _render->m_viewRemap);
  				statsKeyType[isCompute]++;
  
  				const bool viewChanged = 0
  					|| key.m_view != view
  					|| item == numItems
  					;
  
  				const uint32_t itemIdx       = _render->m_sortValues[item];
  				const RenderItem& renderItem = _render->m_renderItem[itemIdx];
  				const RenderBind& renderBind = _render->m_renderItemBind[itemIdx];
  				++item;
  
  				if (viewChanged)
  				{
  					if (beginRenderPass)
  					{
  						vkCmdEndRenderPass(m_commandBuffer);
  						beginRenderPass = false;
  					}
  
  					VK_CHECK(vkEndCommandBuffer(m_commandBuffer) );
  
  //					m_batch.flush(m_commandList, true);
  					kick(renderWait);
  					renderWait = VK_NULL_HANDLE;
  finishAll();
  
  					view = key.m_view;
  					currentPipeline = VK_NULL_HANDLE;
  					currentSamplerStateIdx = kInvalidHandle;
  BX_UNUSED(currentSamplerStateIdx);
  					currentProgram         = BGFX_INVALID_HANDLE;
  					hasPredefined          = false;
  
  					fbh = _render->m_view[view].m_fbh;
  					setFrameBuffer(fbh);
  
  					viewState.m_rect = _render->m_view[view].m_rect;
  					const Rect& rect        = _render->m_view[view].m_rect;
  					const Rect& scissorRect = _render->m_view[view].m_scissor;
  					viewHasScissor  = !scissorRect.isZero();
  					viewScissorRect = viewHasScissor ? scissorRect : rect;
  
  					rpbi.renderArea.offset.x = rect.m_x;
  					rpbi.renderArea.offset.y = rect.m_y;
  					rpbi.renderArea.extent.width  = rect.m_width;
  					rpbi.renderArea.extent.height = rect.m_height;
  					VK_CHECK(vkBeginCommandBuffer(m_commandBuffer, &cbbi) );
  					vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
  					beginRenderPass = true;
  
  					VkViewport vp;
  					vp.x        = rect.m_x;
  					vp.y        = rect.m_y;
  					vp.width    = rect.m_width;
  					vp.height   = rect.m_height;
  					vp.minDepth = 0.0f;
  					vp.maxDepth = 1.0f;
  					vkCmdSetViewport(m_commandBuffer, 0, 1, &vp);
  
  					VkRect2D rc;
  					rc.offset.x      = viewScissorRect.m_x;
  					rc.offset.y      = viewScissorRect.m_y;
  					rc.extent.width  = viewScissorRect.m_x + viewScissorRect.m_width;
  					rc.extent.height = viewScissorRect.m_y + viewScissorRect.m_height;
  					vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
  
  					restoreScissor = false;
  
  					Clear& clr = _render->m_view[view].m_clear;
  					if (BGFX_CLEAR_NONE != clr.m_flags)
  					{
  						Rect clearRect = rect;
  						clearRect.setIntersect(rect, viewScissorRect);
  						clearQuad(clearRect, clr, _render->m_colorPalette);
  					}
  
  					prim = s_primInfo[Topology::Count]; // Force primitive type update.
  
  					submitBlit(bs, view);
  				}
  
  				if (isCompute)
  				{
  					if (!wasCompute)
  					{
  						wasCompute = true;
  
  //						m_commandList->SetComputeRootSignature(m_rootSignature);
  //						ID3D12DescriptorHeap* heaps[] = {
  //							m_samplerAllocator.getHeap(),
  //							scratchBuffer.getHeap(),
  //						};
  //						m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
  					}
  
  					const RenderCompute& compute = renderItem.compute;
  
  					VkPipeline pipeline = getPipeline(key.m_program);
  					if (pipeline != currentPipeline)
  					{
  						currentPipeline = pipeline;
  						vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
  						currentBindHash = 0;
  					}
  
  //					uint32_t bindHash = bx::hash<bx::HashMurmur2A>(renderBind.m_bind, sizeof(renderBind.m_bind) );
  //					if (currentBindHash != bindHash)
  //					{
  //						currentBindHash  = bindHash;
  //
  //						Bind* bindCached = bindLru.find(bindHash);
  //						if (NULL == bindCached)
  //						{
  //							D3D12_GPU_DESCRIPTOR_HANDLE srvHandle[BGFX_MAX_COMPUTE_BINDINGS] = {};
  //							uint32_t samplerFlags[BGFX_MAX_COMPUTE_BINDINGS] = {};
  //
  //							for (uint32_t ii = 0; ii < maxComputeBindings; ++ii)
  //							{
  //								const Binding& bind = renderBind.m_bind[ii];
  //								if (kInvalidHandle != bind.m_idx)
  //								{
  //									switch (bind.m_type)
  //									{
  //									case Binding::Image:
  //										{
  //											TextureD3D12& texture = m_textures[bind.m_idx];
  //
  //											if (Access::Read != bind.m_access)
  //											{
  //												texture.setState(m_commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
  //												scratchBuffer.allocUav(srvHandle[ii], texture, bind.m_mip);
  //											}
  //											else
  //											{
  //												texture.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
  //												scratchBuffer.allocSrv(srvHandle[ii], texture, bind.m_mip);
  //												samplerFlags[ii] = texture.m_flags;
  //											}
  //										}
  //										break;
  //
  //									case Binding::IndexBuffer:
  //									case Binding::VertexBuffer:
  //										{
  //											BufferD3D12& buffer = Binding::IndexBuffer == bind.m_type
  //												? m_indexBuffers[bind.m_idx]
  //												: m_vertexBuffers[bind.m_idx]
  //												;
  //
  //											if (Access::Read != bind.m_access)
  //											{
  //												buffer.setState(m_commandList, D3D12_RESOURCE_STATE_UNORDERED_ACCESS);
  //												scratchBuffer.allocUav(srvHandle[ii], buffer);
  //											}
  //											else
  //											{
  //												buffer.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
  //												scratchBuffer.allocSrv(srvHandle[ii], buffer);
  //											}
  //										}
  //										break;
  //									}
  //								}
  //							}
  //
  //							uint16_t samplerStateIdx = getSamplerState(samplerFlags, maxComputeBindings, _render->m_colorPalette);
  //							if (samplerStateIdx != currentSamplerStateIdx)
  //							{
  //								currentSamplerStateIdx = samplerStateIdx;
  //								m_commandList->SetComputeRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
  //							}
  //
  //							m_commandList->SetComputeRootDescriptorTable(Rdt::SRV, srvHandle[0]);
  //							m_commandList->SetComputeRootDescriptorTable(Rdt::UAV, srvHandle[0]);
  //
  //							Bind bind;
  //							bind.m_srvHandle = srvHandle[0];
  //							bind.m_samplerStateIdx = samplerStateIdx;
  //							bindLru.add(bindHash, bind, 0);
  //						}
  //						else
  //						{
  //							uint16_t samplerStateIdx = bindCached->m_samplerStateIdx;
  //							if (samplerStateIdx != currentSamplerStateIdx)
  //							{
  //								currentSamplerStateIdx = samplerStateIdx;
  //								m_commandList->SetComputeRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
  //							}
  //							m_commandList->SetComputeRootDescriptorTable(Rdt::SRV, bindCached->m_srvHandle);
  //							m_commandList->SetComputeRootDescriptorTable(Rdt::UAV, bindCached->m_srvHandle);
  //						}
  //					}
  
  					bool constantsChanged = false;
  					if (compute.m_uniformBegin < compute.m_uniformEnd
  					||  currentProgram.idx != key.m_program.idx)
  					{
  						rendererUpdateUniforms(this, _render->m_uniformBuffer[compute.m_uniformIdx], compute.m_uniformBegin, compute.m_uniformEnd);
  
  						currentProgram = key.m_program;
  						ProgramVK& program = m_program[currentProgram.idx];
  
  						UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
  						if (NULL != vcb)
  						{
  							commit(*vcb);
  						}
  
  						hasPredefined = 0 < program.m_numPredefined;
  						constantsChanged = true;
  					}
  
  					if (constantsChanged
  					||  hasPredefined)
  					{
  						ProgramVK& program = m_program[currentProgram.idx];
  						viewState.setPredefined<4>(this, view, program, _render, compute);
  //						commitShaderConstants(key.m_program, gpuAddress);
  //						m_commandList->SetComputeRootConstantBufferView(Rdt::CBV, gpuAddress);
  					}
  
  					if (isValid(compute.m_indirectBuffer) )
  					{
  						const VertexBufferVK& vb = m_vertexBuffers[compute.m_indirectBuffer.idx];
  
  						uint32_t numDrawIndirect = UINT16_MAX == compute.m_numIndirect
  							? vb.m_size/BGFX_CONFIG_DRAW_INDIRECT_STRIDE
  							: compute.m_numIndirect
  							;
  
  						uint32_t args = compute.m_startIndirect * BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
  						for (uint32_t ii = 0; ii < numDrawIndirect; ++ii)
  						{
  //							m_commandList->ExecuteIndirect(ptr, args);
  							args += BGFX_CONFIG_DRAW_INDIRECT_STRIDE;
  						}
  					}
  					else
  					{
  //						m_commandList->Dispatch(compute.m_numX, compute.m_numY, compute.m_numZ);
  					}
  
  					continue;
  				}
  
  				const RenderDraw& draw = renderItem.draw;
  
  				const bool hasOcclusionQuery = false; //0 != (draw.m_stateFlags & BGFX_STATE_INTERNAL_OCCLUSION_QUERY);
  				{
  					const bool occluded = false //true
  //						&& isValid(draw.m_occlusionQuery)
  //						&& !hasOcclusionQuery
  //						&& !isVisible(_render, draw.m_occlusionQuery, 0 != (draw.m_submitFlags&BGFX_SUBMIT_INTERNAL_OCCLUSION_VISIBLE) )
  						;
  
  					if (occluded
  					||  _render->m_frameCache.isZeroArea(viewScissorRect, draw.m_scissor) )
  					{
  //						if (resetState)
  //						{
  //							currentState.clear();
  //							currentState.m_scissor = !draw.m_scissor;
  //							currentBind.clear();
  //						}
  
  						continue;
  					}
  				}
  
  				const uint64_t newFlags = draw.m_stateFlags;
  				uint64_t changedFlags = currentState.m_stateFlags ^ draw.m_stateFlags;
  				currentState.m_stateFlags = newFlags;
  
  				const uint64_t newStencil = draw.m_stencil;
  				uint64_t changedStencil = (currentState.m_stencil ^ draw.m_stencil) & BGFX_STENCIL_FUNC_REF_MASK;
  				currentState.m_stencil = newStencil;
  
  				if (viewChanged
  				||  wasCompute)
  				{
  					if (wasCompute)
  					{
  						wasCompute = false;
  					}
  
  					if (BX_ENABLED(BGFX_CONFIG_DEBUG_PIX) )
  					{
  						BX_UNUSED(s_viewName);
  // 						wchar_t* viewNameW = s_viewNameW[view];
  // 						viewNameW[3] = L' ';
  // 						PIX_ENDEVENT();
  // 						PIX_BEGINEVENT(toRgba8(0xff, 0x00, 0x00, 0xff), viewNameW);
  					}
  
  					commandListChanged = true;
  				}
  
  				if (commandListChanged)
  				{
  					commandListChanged = false;
  
  //					m_commandList->SetGraphicsRootSignature(m_rootSignature);
  //					ID3D12DescriptorHeap* heaps[] = {
  //						m_samplerAllocator.getHeap(),
  //						scratchBuffer.getHeap(),
  //					};
  //					m_commandList->SetDescriptorHeaps(BX_COUNTOF(heaps), heaps);
  
  					currentPipeline        = VK_NULL_HANDLE;
  					currentBindHash        = 0;
  					currentSamplerStateIdx = kInvalidHandle;
  					currentProgram         = BGFX_INVALID_HANDLE;
  					currentState.clear();
  					currentState.m_scissor = !draw.m_scissor;
  					changedFlags = BGFX_STATE_MASK;
  					changedStencil = packStencil(BGFX_STENCIL_MASK, BGFX_STENCIL_MASK);
  					currentState.m_stateFlags = newFlags;
  					currentState.m_stencil    = newStencil;
  
  					const uint64_t pt = newFlags&BGFX_STATE_PT_MASK;
  					primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT);
  				}
  
  				rendererUpdateUniforms(this, _render->m_uniformBuffer[draw.m_uniformIdx], draw.m_uniformBegin, draw.m_uniformEnd);
  
  				if (isValid(draw.m_stream[0].m_handle) )
  				{
  					const uint64_t state = draw.m_stateFlags;
  					bool hasFactor = 0
  						|| f0 == (state & f0)
  						|| f1 == (state & f1)
  						;
  
  					const VertexBufferVK& vb = m_vertexBuffers[draw.m_stream[0].m_handle.idx];
  					uint16_t declIdx = !isValid(vb.m_decl) ? draw.m_stream[0].m_decl.idx : vb.m_decl.idx;
  
  					VkPipeline pipeline =
  						getPipeline(state
  							, draw.m_stencil
  							, declIdx
  							, key.m_program
  							, uint8_t(draw.m_instanceDataStride/16)
  							);
  
  					uint16_t scissor = draw.m_scissor;
  					uint32_t bindHash = bx::hash<bx::HashMurmur2A>(renderBind.m_bind, sizeof(renderBind.m_bind) );
  					if (currentBindHash != bindHash
  					||  0 != changedStencil
  					|| (hasFactor && blendFactor != draw.m_rgba)
  					|| (0 != (BGFX_STATE_PT_MASK & changedFlags)
  					||  prim.m_topology != s_primInfo[primIndex].m_topology)
  					||  currentState.m_scissor != scissor
  					||  pipeline != currentPipeline
  					||  hasOcclusionQuery)
  					{
  //						m_batch.flush(m_commandList);
  					}
  
  //					if (currentBindHash != bindHash)
  //					{
  //						currentBindHash  = bindHash;
  //
  //						Bind* bindCached = bindLru.find(bindHash);
  //						if (NULL == bindCached)
  //						{
  //							D3D12_GPU_DESCRIPTOR_HANDLE srvHandle[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS];
  //							uint32_t samplerFlags[BGFX_CONFIG_MAX_TEXTURE_SAMPLERS];
  //							{
  //								srvHandle[0].ptr = 0;
  //								for (uint32_t stage = 0; stage < BGFX_CONFIG_MAX_TEXTURE_SAMPLERS; ++stage)
  //								{
  //									const Binding& bind = renderBind.m_bind[stage];
  //									if (kInvalidHandle != bind.m_idx)
  //									{
  //										TextureD3D12& texture = m_textures[bind.m_idx];
  //										texture.setState(m_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
  //										scratchBuffer.allocSrv(srvHandle[stage], texture);
  //										samplerFlags[stage] = (0 == (BGFX_TEXTURE_INTERNAL_DEFAULT_SAMPLER & bind.m_textureFlags)
  //											? bind.m_textureFlags
  //											: texture.m_flags
  //											) & (BGFX_TEXTURE_SAMPLER_BITS_MASK|BGFX_TEXTURE_BORDER_COLOR_MASK)
  //											;
  //									}
  //									else
  //									{
  //										bx::memCopy(&srvHandle[stage], &srvHandle[0], sizeof(D3D12_GPU_DESCRIPTOR_HANDLE) );
  //										samplerFlags[stage] = 0;
  //									}
  //								}
  //							}
  //
  //							if (srvHandle[0].ptr != 0)
  //							{
  //								uint16_t samplerStateIdx = getSamplerState(samplerFlags, BGFX_CONFIG_MAX_TEXTURE_SAMPLERS, _render->m_colorPalette);
  //								if (samplerStateIdx != currentSamplerStateIdx)
  //								{
  //									currentSamplerStateIdx = samplerStateIdx;
  //									m_commandList->SetGraphicsRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
  //								}
  //
  //								m_commandList->SetGraphicsRootDescriptorTable(Rdt::SRV, srvHandle[0]);
  //
  //								Bind bind;
  //								bind.m_srvHandle = srvHandle[0];
  //								bind.m_samplerStateIdx = samplerStateIdx;
  //								bindLru.add(bindHash, bind, 0);
  //							}
  //						}
  //						else
  //						{
  //							uint16_t samplerStateIdx = bindCached->m_samplerStateIdx;
  //							if (samplerStateIdx != currentSamplerStateIdx)
  //							{
  //								currentSamplerStateIdx = samplerStateIdx;
  //								m_commandList->SetGraphicsRootDescriptorTable(Rdt::Sampler, m_samplerAllocator.get(samplerStateIdx) );
  //							}
  //							m_commandList->SetGraphicsRootDescriptorTable(Rdt::SRV, bindCached->m_srvHandle);
  //						}
  //					}
  
  					if (pipeline != currentPipeline
  					||  0 != changedStencil)
  					{
  						const uint32_t fstencil = unpackStencil(0, draw.m_stencil);
  						const uint32_t ref = (fstencil&BGFX_STENCIL_FUNC_REF_MASK)>>BGFX_STENCIL_FUNC_REF_SHIFT;
  						vkCmdSetStencilReference(m_commandBuffer, VK_STENCIL_FRONT_AND_BACK, ref);
  					}
  
  					if (pipeline != currentPipeline
  					|| (hasFactor && blendFactor != draw.m_rgba) )
  					{
  						blendFactor = draw.m_rgba;
  
  						float bf[4];
  						bf[0] = ( (draw.m_rgba>>24)     )/255.0f;
  						bf[1] = ( (draw.m_rgba>>16)&0xff)/255.0f;
  						bf[2] = ( (draw.m_rgba>> 8)&0xff)/255.0f;
  						bf[3] = ( (draw.m_rgba    )&0xff)/255.0f;
  						vkCmdSetBlendConstants(m_commandBuffer, bf);
  					}
  
  					if (0 != (BGFX_STATE_PT_MASK & changedFlags)
  					||  prim.m_topology != s_primInfo[primIndex].m_topology)
  					{
  						const uint64_t pt = newFlags&BGFX_STATE_PT_MASK;
  						primIndex = uint8_t(pt>>BGFX_STATE_PT_SHIFT);
  						prim = s_primInfo[primIndex];
  //						m_commandList->IASetPrimitiveTopology(prim.m_topology);
  					}
  
  					if (currentState.m_scissor != scissor)
  					{
  						currentState.m_scissor = scissor;
  
  						if (UINT16_MAX == scissor)
  						{
  							if (restoreScissor
  							||  viewHasScissor)
  							{
  								restoreScissor = false;
  								VkRect2D rc;
  								rc.offset.x      = viewScissorRect.m_x;
  								rc.offset.y      = viewScissorRect.m_y;
  								rc.extent.width  = viewScissorRect.m_x + viewScissorRect.m_width;
  								rc.extent.height = viewScissorRect.m_y + viewScissorRect.m_height;
  								vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
  							}
  						}
  						else
  						{
  							restoreScissor = true;
  							Rect scissorRect;
  							scissorRect.setIntersect(viewScissorRect, _render->m_frameCache.m_rectCache.m_cache[scissor]);
  
  							VkRect2D rc;
  							rc.offset.x      = scissorRect.m_x;
  							rc.offset.y      = scissorRect.m_y;
  							rc.extent.width  = scissorRect.m_x + scissorRect.m_width;
  							rc.extent.height = scissorRect.m_y + scissorRect.m_height;
  							vkCmdSetScissor(m_commandBuffer, 0, 1, &rc);
  						}
  					}
  
  					if (pipeline != currentPipeline)
  					{
  						currentPipeline = pipeline;
  						vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
  					}
  
  					bool constantsChanged = false;
  					if (draw.m_uniformBegin < draw.m_uniformEnd
  					||  currentProgram.idx != key.m_program.idx
  					||  BGFX_STATE_ALPHA_REF_MASK & changedFlags)
  					{
  						currentProgram = key.m_program;
  						ProgramVK& program = m_program[currentProgram.idx];
  
  						UniformBuffer* vcb = program.m_vsh->m_constantBuffer;
  						if (NULL != vcb)
  						{
  							commit(*vcb);
  						}
  
  						UniformBuffer* fcb = program.m_fsh->m_constantBuffer;
  						if (NULL != fcb)
  						{
  							commit(*fcb);
  						}
  
  						hasPredefined = 0 < program.m_numPredefined;
  						constantsChanged = true;
  					}
  
  					if (constantsChanged
  					||  hasPredefined)
  					{
  						ProgramVK& program = m_program[currentProgram.idx];
  						uint32_t ref = (newFlags&BGFX_STATE_ALPHA_REF_MASK)>>BGFX_STATE_ALPHA_REF_SHIFT;
  						viewState.m_alphaRef = ref/255.0f;
  						viewState.setPredefined<4>(this, view, program, _render, draw);
  						commitShaderUniforms(m_commandBuffer, key.m_program); //, gpuAddress);
  					}
  
  
  //					vb.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
  
  					const VertexDecl& vertexDecl = m_vertexDecls[declIdx];
  					uint32_t numIndices = 0;
  
  					VkDeviceSize offset = 0;
  					vkCmdBindVertexBuffers(m_commandBuffer
  						, 0
  						, 1
  						, &vb.m_buffer
  						, &offset
  						);
  
  					if (!isValid(draw.m_indexBuffer) )
  					{
  						const uint32_t numVertices = UINT32_MAX == draw.m_numVertices
  							? vb.m_size / vertexDecl.m_stride
  							: draw.m_numVertices
  							;
  						vkCmdDraw(m_commandBuffer
  							, numVertices
  							, draw.m_numInstances
  							, draw.m_stream[0].m_startVertex
  							, 0
  							);
  					}
  					else
  					{
  						BufferVK& ib = m_indexBuffers[draw.m_indexBuffer.idx];
  //						ib.setState(_commandList, D3D12_RESOURCE_STATE_GENERIC_READ);
  
  						const bool hasIndex16 = 0 == (ib.m_flags & BGFX_BUFFER_INDEX32);
  						const uint32_t indexSize = hasIndex16 ? 2 : 4;
  
  						numIndices = UINT32_MAX == draw.m_numIndices
  							? ib.m_size / indexSize
  							: draw.m_numIndices
  							;
  
  						vkCmdBindIndexBuffer(m_commandBuffer
  							, ib.m_buffer
  							, 0
  							, hasIndex16
  								? VK_INDEX_TYPE_UINT16
  								: VK_INDEX_TYPE_UINT32
  							);
  						vkCmdDrawIndexed(m_commandBuffer
  							, numIndices
  							, draw.m_numInstances
  							, draw.m_startIndex
  							, draw.m_stream[0].m_startVertex
  							, 0
  							);
  					}
  
  					uint32_t numPrimsSubmitted = numIndices / prim.m_div - prim.m_sub;
  					uint32_t numPrimsRendered  = numPrimsSubmitted*draw.m_numInstances;
  
  					statsNumPrimsSubmitted[primIndex] += numPrimsSubmitted;
  					statsNumPrimsRendered[primIndex]  += numPrimsRendered;
  					statsNumInstances[primIndex]      += draw.m_numInstances;
  					statsNumIndices                   += numIndices;
  
  					if (hasOcclusionQuery)
  					{
  //						m_occlusionQuery.begin(m_commandList, _render, draw.m_occlusionQuery);
  //						m_batch.flush(m_commandList);
  //						m_occlusionQuery.end(m_commandList);
  					}
  				}
  			}
  
  			submitBlit(bs, BGFX_CONFIG_MAX_VIEWS);
  
  //			m_batch.end(m_commandList);
  		}
  
  		int64_t timeEnd = bx::getHPCounter();
  		int64_t frameTime = timeEnd - timeBegin;
  
  		static int64_t min = frameTime;
  		static int64_t max = frameTime;
  		min = bx::min<int64_t>(min, frameTime);
  		max = bx::max<int64_t>(max, frameTime);
  
  		static uint32_t maxGpuLatency = 0;
  		static double   maxGpuElapsed = 0.0f;
  		double elapsedGpuMs = 0.0;
  BX_UNUSED(maxGpuLatency, maxGpuElapsed, elapsedGpuMs);
  
  		static int64_t presentMin = 0; //m_presentElapsed;
  		static int64_t presentMax = 0; //m_presentElapsed;
  BX_UNUSED(presentMin, presentMax);
  //		presentMin = bx::min<int64_t>(presentMin, m_presentElapsed);
  //		presentMax = bx::max<int64_t>(presentMax, m_presentElapsed);
  
  //		m_gpuTimer.end(m_commandList);
  
  //		while (m_gpuTimer.get() )
  //		{
  //			double toGpuMs = 1000.0 / double(m_gpuTimer.m_frequency);
  //			elapsedGpuMs   = m_gpuTimer.m_elapsed * toGpuMs;
  //			maxGpuElapsed  = elapsedGpuMs > maxGpuElapsed ? elapsedGpuMs : maxGpuElapsed;
  //		}
  //		maxGpuLatency = bx::uint32_imax(maxGpuLatency, m_gpuTimer.m_control.available()-1);
  
  		const int64_t timerFreq = bx::getHPFrequency();
  
  		Stats& perfStats = _render->m_perfStats;
  		perfStats.cpuTimeBegin  = timeBegin;
  		perfStats.cpuTimeEnd    = timeEnd;
  		perfStats.cpuTimerFreq  = timerFreq;
  //		perfStats.gpuTimeBegin  = m_gpuTimer.m_begin;
  //		perfStats.gpuTimeEnd    = m_gpuTimer.m_end;
  //		perfStats.gpuTimerFreq  = m_gpuTimer.m_frequency;
  //		perfStats.numDraw       = statsKeyType[0];
  //		perfStats.numCompute    = statsKeyType[1];
  		perfStats.numBlit       = _render->m_numBlitItems;
  //		perfStats.maxGpuLatency = maxGpuLatency;
  		bx::memCopy(perfStats.numPrims, statsNumPrimsRendered, sizeof(perfStats.numPrims) );
  		perfStats.gpuMemoryMax  = -INT64_MAX;
  		perfStats.gpuMemoryUsed = -INT64_MAX;
  
  		if (_render->m_debug & (BGFX_DEBUG_IFH|BGFX_DEBUG_STATS) )
  		{
  //			PIX_BEGINEVENT(toRgba8(0x40, 0x40, 0x40, 0xff), L"debugstats");
  
  //			m_needPresent = true;
  			TextVideoMem& tvm = m_textVideoMem;
  
  			static int64_t next = timeEnd;
  
  			if (timeEnd >= next)
  			{
  				next = timeEnd + timerFreq;
  
  				double freq = double(timerFreq);
  				double toMs = 1000.0 / freq;
  
  				tvm.clear();
  				uint16_t pos = 0;
  				tvm.printf(0, pos++, BGFX_CONFIG_DEBUG ? 0x8c : 0x8f
  					, " %s / " BX_COMPILER_NAME " / " BX_CPU_NAME " / " BX_ARCH_NAME " / " BX_PLATFORM_NAME " "
  					, getRendererName()
  					);
  
  //				const DXGI_ADAPTER_DESC& desc = m_adapterDesc;
  //				char description[BX_COUNTOF(desc.Description)];
  //				wcstombs(description, desc.Description, BX_COUNTOF(desc.Description) );
  //				tvm.printf(0, pos++, 0x8f, " Device: %s", description);
  //
  //				char dedicatedVideo[16];
  //				bx::prettify(dedicatedVideo, BX_COUNTOF(dedicatedVideo), desc.DedicatedVideoMemory);
  //
  //				char dedicatedSystem[16];
  //				bx::prettify(dedicatedSystem, BX_COUNTOF(dedicatedSystem), desc.DedicatedSystemMemory);
  //
  //				char sharedSystem[16];
  //				bx::prettify(sharedSystem, BX_COUNTOF(sharedSystem), desc.SharedSystemMemory);
  //
  //				char processMemoryUsed[16];
  //				bx::prettify(processMemoryUsed, BX_COUNTOF(processMemoryUsed), bx::getProcessMemoryUsed() );
  //
  //				tvm.printf(0, pos++, 0x8f, " Memory: %s (video), %s (system), %s (shared), %s (process) "
  //					, dedicatedVideo
  //					, dedicatedSystem
  //					, sharedSystem
  //					, processMemoryUsed
  //					);
  
  //				DXGI_QUERY_VIDEO_MEMORY_INFO memInfo;
  //				DX_CHECK(m_adapter->QueryVideoMemoryInfo(0, DXGI_MEMORY_SEGMENT_GROUP_LOCAL, &memInfo) );
  //
  //				char budget[16];
  //				bx::prettify(budget, BX_COUNTOF(budget), memInfo.Budget);
  //
  //				char currentUsage[16];
  //				bx::prettify(currentUsage, BX_COUNTOF(currentUsage), memInfo.CurrentUsage);
  //
  //				char availableForReservation[16];
  //				bx::prettify(availableForReservation, BX_COUNTOF(currentUsage), memInfo.AvailableForReservation);
  //
  //				char currentReservation[16];
  //				bx::prettify(currentReservation, BX_COUNTOF(currentReservation), memInfo.CurrentReservation);
  //
  //				tvm.printf(0, pos++, 0x8f, " Budget: %s, Usage: %s, AvailRes: %s, CurrRes: %s "
  //					, budget
  //					, currentUsage
  //					, availableForReservation
  //					, currentReservation
  //					);
  
  				pos = 10;
  				tvm.printf(10, pos++, 0x8b, "       Frame: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] / % 6.2f FPS "
  					, double(frameTime)*toMs
  					, double(min)*toMs
  					, double(max)*toMs
  					, freq/frameTime
  					);
  //				tvm.printf(10, pos++, 0x8b, "     Present: % 7.3f, % 7.3f \x1f, % 7.3f \x1e [ms] "
  //					, double(m_presentElapsed)*toMs
  //					, double(presentMin)*toMs
  //					, double(presentMax)*toMs
  //					);
  
  				const uint32_t msaa = (m_resolution.reset&BGFX_RESET_MSAA_MASK)>>BGFX_RESET_MSAA_SHIFT;
  				tvm.printf(10, pos++, 0x8b, " Reset flags: [%c] vsync, [%c] MSAAx%d, [%c] MaxAnisotropy "
  					, !!(m_resolution.reset&BGFX_RESET_VSYNC) ? '\xfe' : ' '
  					, 0 != msaa ? '\xfe' : ' '
  					, 1<<msaa
  					, !!(m_resolution.reset&BGFX_RESET_MAXANISOTROPY) ? '\xfe' : ' '
  					);
  
  				double elapsedCpuMs = double(frameTime)*toMs;
  				tvm.printf(10, pos++, 0x8b, "   Submitted: %5d (draw %5d, compute %4d) / CPU %7.4f [ms] "
  					, _render->m_numRenderItems
  					, statsKeyType[0]
  					, statsKeyType[1]
  					, elapsedCpuMs
  					);
  
  				for (uint32_t ii = 0; ii < Topology::Count; ++ii)
  				{
  					tvm.printf(10, pos++, 0x8b, "   %9s: %7d (#inst: %5d), submitted: %7d "
  						, getName(Topology::Enum(ii) )
  						, statsNumPrimsRendered[ii]
  						, statsNumInstances[ii]
  						, statsNumPrimsSubmitted[ii]
  						);
  				}
  
  //				tvm.printf(10, pos++, 0x8b, "       Batch: %7dx%d indirect, %7d immediate "
  //					, m_batch.m_stats.m_numIndirect[BatchD3D12::Draw]
  //					, m_batch.m_maxDrawPerBatch
  //					, m_batch.m_stats.m_numImmediate[BatchD3D12::Draw]
  //					);
  
  //				tvm.printf(10, pos++, 0x8b, "              %7dx%d indirect, %7d immediate "
  //					, m_batch.m_stats.m_numIndirect[BatchD3D12::DrawIndexed]
  //					, m_batch.m_maxDrawPerBatch
  //					, m_batch.m_stats.m_numImmediate[BatchD3D12::DrawIndexed]
  //					);
  
   				if (NULL != m_renderDocDll)
   				{
   					tvm.printf(tvm.m_width-27, 0, 0x4f, " [F11 - RenderDoc capture] ");
   				}
  
  				tvm.printf(10, pos++, 0x8b, "      Indices: %7d ", statsNumIndices);
  //				tvm.printf(10, pos++, 0x8b, " Uniform size: %7d, Max: %7d ", _render->m_uniformEnd, _render->m_uniformMax);
  				tvm.printf(10, pos++, 0x8b, "     DVB size: %7d ", _render->m_vboffset);
  				tvm.printf(10, pos++, 0x8b, "     DIB size: %7d ", _render->m_iboffset);
  
  				pos++;
  				tvm.printf(10, pos++, 0x8b, " State cache:                        ");
  				tvm.printf(10, pos++, 0x8b, " PSO    | Sampler | Bind   | Queued  ");
  				tvm.printf(10, pos++, 0x8b, " %6d " //|  %6d | %6d | %6d  "
  					, m_pipelineStateCache.getCount()
  //					, m_samplerStateCache.getCount()
  //					, bindLru.getCount()
  //					, m_cmd.m_control.available()
  					);
  				pos++;
  
  				double captureMs = double(captureElapsed)*toMs;
  				tvm.printf(10, pos++, 0x8b, "     Capture: %7.4f [ms] ", captureMs);
  
  				uint8_t attr[2] = { 0x8c, 0x8a };
  				uint8_t attrIndex = _render->m_waitSubmit < _render->m_waitRender;
  
  				tvm.printf(10, pos++, attr[attrIndex&1], " Submit wait: %7.4f [ms] ", _render->m_waitSubmit*toMs);
  				tvm.printf(10, pos++, attr[(attrIndex+1)&1], " Render wait: %7.4f [ms] ", _render->m_waitRender*toMs);
  
  				min = frameTime;
  				max = frameTime;
  //				presentMin = m_presentElapsed;
  //				presentMax = m_presentElapsed;
  			}
  
  			blit(this, _textVideoMemBlitter, tvm);
  
  //			PIX_ENDEVENT();
  		}
  		else if (_render->m_debug & BGFX_DEBUG_TEXT)
  		{
  //			PIX_BEGINEVENT(toRgba8(0x40, 0x40, 0x40, 0xff), L"debugtext");
  
  			blit(this, _textVideoMemBlitter, _render->m_textVideoMem);
  
  //			PIX_ENDEVENT();
  		}
  
  		if (beginRenderPass)
  		{
  			vkCmdEndRenderPass(m_commandBuffer);
  			beginRenderPass = false;
  		}
  
  		setImageMemoryBarrier(m_commandBuffer
  			, m_backBufferColorImage[m_backBufferColorIdx]
  			, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
  			, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
  			);
  
  		VK_CHECK(vkEndCommandBuffer(m_commandBuffer) );
  
  		kick(renderWait); //, m_presentDone[m_backBufferColorIdx]);
  		finishAll();
  
  		VK_CHECK(vkResetCommandPool(m_device, m_commandPool, 0) );
  	}
  
  } /* namespace vk */ } // namespace bgfx
  
  #else
  
  namespace bgfx { namespace vk
  {
  	RendererContextI* rendererCreate(const Init& _init)
  	{
  		BX_UNUSED(_init);
  		return NULL;
  	}
  
  	void rendererDestroy()
  	{
  	}
  } /* namespace vk */ } // namespace bgfx
  
  #endif // BGFX_CONFIG_RENDERER_VULKAN
  