ris-ktx2-api 0.1.0-dev.2.4

package/dist/index.js

@@ -0,0 +1,1130 @@
+//#region src/ris-ktx2/KtxUastcFlags.ts
+/**
+* UASTC encoding configuration flags.
+*
+* Packed bitfield matching libktx `ktx_pack_uastc_flag_bits_e`.
+* Bits 0–3 hold the compression level ({@link KtxUastcFlags.LEVEL_MASK}).
+* {@link KtxUastcFlags.FAVOR_UASTC_ERROR} is `8`, so it sits inside that mask:
+* combining it with a level changes the value `LEVEL_MASK` extracts.
+* Hints at bit 4 and above (`16`, `64`, `128`, `256`) combine with a level
+* with bitwise OR and leave bits 0–3 unchanged.
+*/
+var KtxUastcFlags = /* @__PURE__ */ function(KtxUastcFlags) {
+	/**
+	* Fastest compression (lowest quality, highest speed). About 43.45 dB.
+	*/
+	KtxUastcFlags[KtxUastcFlags["LEVEL_FASTEST"] = 0] = "LEVEL_FASTEST";
+	/**
+	* Faster compression. About 46.49 dB.
+	*/
+	KtxUastcFlags[KtxUastcFlags["LEVEL_FASTER"] = 1] = "LEVEL_FASTER";
+	/**
+	* Default compression level. About 47.47 dB.
+	*/
+	KtxUastcFlags[KtxUastcFlags["LEVEL_DEFAULT"] = 2] = "LEVEL_DEFAULT";
+	/**
+	* Slower compression (higher quality). About 48.01 dB.
+	*/
+	KtxUastcFlags[KtxUastcFlags["LEVEL_SLOWER"] = 3] = "LEVEL_SLOWER";
+	/**
+	* Very slow compression (highest quality). About 48.24 dB.
+	*/
+	KtxUastcFlags[KtxUastcFlags["LEVEL_VERY_SLOW"] = 4] = "LEVEL_VERY_SLOW";
+	/**
+	* Mask for the compression level in bits 0–3.
+	*/
+	KtxUastcFlags[KtxUastcFlags["LEVEL_MASK"] = 15] = "LEVEL_MASK";
+	/**
+	* Optimize encoding for the lowest UASTC reconstruction error.
+	*/
+	KtxUastcFlags[KtxUastcFlags["FAVOR_UASTC_ERROR"] = 8] = "FAVOR_UASTC_ERROR";
+	/**
+	* Optimize encoding for the lowest BC7 decode error.
+	*/
+	KtxUastcFlags[KtxUastcFlags["FAVOR_BC7_ERROR"] = 16] = "FAVOR_BC7_ERROR";
+	/**
+	* Hint to optimize for faster ETC1 transcoding.
+	*/
+	KtxUastcFlags[KtxUastcFlags["ETC1_FASTER_HINTS"] = 64] = "ETC1_FASTER_HINTS";
+	/**
+	* Hint to optimize for the fastest ETC1 transcoding.
+	*/
+	KtxUastcFlags[KtxUastcFlags["ETC1_FASTEST_HINTS"] = 128] = "ETC1_FASTEST_HINTS";
+	/**
+	* Disables flip-and-individual optimizations for ETC1 transcoding.
+	*/
+	KtxUastcFlags[KtxUastcFlags["ETC1_DISABLE_FLIP_AND_INDIVIDUAL"] = 256] = "ETC1_DISABLE_FLIP_AND_INDIVIDUAL";
+	return KtxUastcFlags;
+}({});
+//#endregion
+//#region src/ris-ktx2/KtxCreateStorage.ts
+/**
+* How image storage is allocated when a KTX2 texture is created.
+*
+* Values match libktx `ktxTextureCreateStorageEnum`:
+* `KTX_TEXTURE_CREATE_NO_STORAGE` is `0` and
+* `KTX_TEXTURE_CREATE_ALLOC_STORAGE` is `1`.
+*/
+var KtxCreateStorage = /* @__PURE__ */ function(KtxCreateStorage) {
+	/** Do not allocate image storage. */
+	KtxCreateStorage[KtxCreateStorage["NO_STORAGE"] = 0] = "NO_STORAGE";
+	/** Allocate image storage for the texture. */
+	KtxCreateStorage[KtxCreateStorage["ALLOC_STORAGE"] = 1] = "ALLOC_STORAGE";
+	return KtxCreateStorage;
+}({});
+//#endregion
+//#region src/ris-ktx2/KtxTranscodeFlags.ts
+/**
+* Flags that select options for Basis Universal transcoding.
+*
+* Numeric values match the libktx `ktx_transcode_flag_bits_e` enumerators.
+* Combine them with bitwise OR when more than one option applies.
+*/
+var KtxTranscodeFlags = /* @__PURE__ */ function(KtxTranscodeFlags) {
+	/** No special transcoding options. */
+	KtxTranscodeFlags[KtxTranscodeFlags["NONE"] = 0] = "NONE";
+	/**
+	* For PVRTC1, decode a non-power-of-two ETC1S level to the next larger
+	* power of two.
+	*
+	* libktx still documents this option as not implemented. It is ignored
+	* when the slice dimensions are already powers of two.
+	*/
+	KtxTranscodeFlags[KtxTranscodeFlags["PVRTC_DECODE_TO_NEXT_POW2"] = 2] = "PVRTC_DECODE_TO_NEXT_POW2";
+	/**
+	* When transcoding to an opaque format, decode the alpha slice instead of
+	* the color slice if the Basis data has alpha. Has no effect when there
+	* is no alpha data.
+	*/
+	KtxTranscodeFlags[KtxTranscodeFlags["TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS"] = 4] = "TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS";
+	/**
+	* Request a higher-quality transcode of UASTC to BC1, BC3, ETC2 EAC R11,
+	* or ETC2 EAC RG11. Unused by other UASTC transcode targets.
+	*/
+	KtxTranscodeFlags[KtxTranscodeFlags["HIGH_QUALITY"] = 32] = "HIGH_QUALITY";
+	return KtxTranscodeFlags;
+}({});
+//#endregion
+//#region src/ris-ktx2/KtxTranscodeFormat.ts
+/**
+* Target formats for transcoding a Basis Universal (ETC1S or UASTC) texture.
+*
+* Numeric values match the libktx `ktx_transcode_fmt_e` enumerators.
+* Gaps in the numbering are formats libktx does not expose (there is no
+* equivalent `VkFormat` for the omitted targets).
+*/
+var KtxTranscodeFormat = /* @__PURE__ */ function(KtxTranscodeFormat) {
+	/**
+	* Opaque ETC1 RGB. Returns alpha data instead when
+	* {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} is set.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_ETC1_RGB"] = 0] = "KTX_TTF_ETC1_RGB";
+	/**
+	* ETC2 RGBA. An EAC alpha block followed by an ETC1 block.
+	* Textures without alpha get an opaque alpha channel.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["ETC2_RGBA"] = 1] = "ETC2_RGBA";
+	/**
+	* Opaque BC1 RGB. Returns alpha data instead when
+	* {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} is set.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_BC1_RGB"] = 2] = "KTX_TTF_BC1_RGB";
+	/**
+	* BC3 compressed RGBA.
+	* Common on desktop devices. Widely supported block compression for color textures.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["BC3_RGBA"] = 3] = "BC3_RGBA";
+	/**
+	* Single-channel BC4. The red channel is the opaque or alpha green component,
+	* depending on {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS}.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_BC4_R"] = 4] = "KTX_TTF_BC4_R";
+	/**
+	* Two-channel BC5 (red and green). Intended for tangent-space normal maps.
+	* The texture should have an alpha channel; otherwise green is 255.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_BC5_RG"] = 5] = "KTX_TTF_BC5_RG";
+	/**
+	* BC7 compressed RGBA.
+	* High quality block compression for color textures.
+	* Supports an alpha channel and is suitable for diffuse and physically based textures.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["BC7_RGBA"] = 6] = "BC7_RGBA";
+	/**
+	* Opaque PVRTC1 4bpp RGB. Returns alpha data instead when
+	* {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS} is set.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_PVRTC1_4_RGB"] = 8] = "KTX_TTF_PVRTC1_4_RGB";
+	/**
+	* PVRTC1 4bpp RGBA. Useful for simple opacity maps.
+	* If the texture has no alpha channel, PVRTC1 4bpp RGB is used instead.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_PVRTC1_4_RGBA"] = 9] = "KTX_TTF_PVRTC1_4_RGBA";
+	/**
+	* ASTC 4×4 RGBA.
+	* Common on mobile devices, especially Apple. High quality block compression
+	* for color textures, including an alpha channel.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["ASTC_4X4_RGBA"] = 10] = "ASTC_4X4_RGBA";
+	/**
+	* Uncompressed 32bpp RGBA in raster order (R, G, B, A).
+	* Supported on all devices.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["RGBA32"] = 13] = "RGBA32";
+	/** Uncompressed 16bpp RGB565 in raster order, with red in the high bits. */
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_RGB565"] = 14] = "KTX_TTF_RGB565";
+	/** Uncompressed 16bpp BGR565 in raster order, with red in the low bits. */
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_BGR565"] = 15] = "KTX_TTF_BGR565";
+	/** Uncompressed 16bpp RGBA4444 in raster order. */
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_RGBA4444"] = 16] = "KTX_TTF_RGBA4444";
+	/**
+	* Opaque PVRTC2 4bpp RGB. Supports arbitrary dimensions, unlike PVRTC1.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_PVRTC2_4_RGB"] = 18] = "KTX_TTF_PVRTC2_4_RGB";
+	/** PVRTC2 4bpp RGBA. Premultiplied alpha is recommended. */
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_PVRTC2_4_RGBA"] = 19] = "KTX_TTF_PVRTC2_4_RGBA";
+	/**
+	* Unsigned ETC2 EAC R11. The red channel is the opaque or alpha green
+	* component, depending on
+	* {@link KtxTranscodeFlags.TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS}.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_ETC2_EAC_R11"] = 20] = "KTX_TTF_ETC2_EAC_R11";
+	/**
+	* Unsigned ETC2 EAC RG11. Intended for tangent-space normal maps.
+	* The texture should have an alpha channel; otherwise green is 255.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_ETC2_EAC_RG11"] = 21] = "KTX_TTF_ETC2_EAC_RG11";
+	/**
+	* Selects {@link KtxTranscodeFormat.KTX_TTF_ETC1_RGB} or
+	* {@link KtxTranscodeFormat.ETC2_RGBA} according to whether the texture has alpha.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["KTX_TTF_ETC"] = 22] = "KTX_TTF_ETC";
+	/**
+	* Selects {@link KtxTranscodeFormat.KTX_TTF_BC1_RGB} or
+	* {@link KtxTranscodeFormat.BC3_RGBA} according to whether the texture has alpha.
+	*/
+	KtxTranscodeFormat[KtxTranscodeFormat["BC1_OR_3"] = 23] = "BC1_OR_3";
+	/** No transcode format selected. */
+	KtxTranscodeFormat[KtxTranscodeFormat["NO_SELECTION"] = 2147483647] = "NO_SELECTION";
+	return KtxTranscodeFormat;
+}({});
+//#endregion
+//#region src/ris-ktx2/VkFormat.ts
+/**
+* Vulkan `VkFormat` enumerators.
+*
+* Names and numeric values match the Vulkan API so they can be stored in
+* KTX2 files and passed through to graphics APIs. Extension enumerators that
+* share a value with a core enumerator are documented as aliases.
+* See THIRD_PARTY_NOTICES.md.
+*/
+var VkFormat = /* @__PURE__ */ function(VkFormat) {
+	/** No format is specified. */
+	VkFormat[VkFormat["UNDEFINED"] = 0] = "UNDEFINED";
+	/** 4-bit red and green, unsigned normalized, packed into an 8-bit word. */
+	VkFormat[VkFormat["R4G4_UNORM_PACK8"] = 1] = "R4G4_UNORM_PACK8";
+	/** 4-bit red, green, blue, and alpha, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["R4G4B4A4_UNORM_PACK16"] = 2] = "R4G4B4A4_UNORM_PACK16";
+	/** 4-bit blue, green, red, and alpha, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["B4G4R4A4_UNORM_PACK16"] = 3] = "B4G4R4A4_UNORM_PACK16";
+	/** 5-bit red, 6-bit green, and 5-bit blue, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["R5G6B5_UNORM_PACK16"] = 4] = "R5G6B5_UNORM_PACK16";
+	/** 5-bit blue, 6-bit green, and 5-bit red, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["B5G6R5_UNORM_PACK16"] = 5] = "B5G6R5_UNORM_PACK16";
+	/** 5-bit red, 5-bit green, 5-bit blue, and 1-bit alpha, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["R5G5B5A1_UNORM_PACK16"] = 6] = "R5G5B5A1_UNORM_PACK16";
+	/** 5-bit blue, 5-bit green, 5-bit red, and 1-bit alpha, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["B5G5R5A1_UNORM_PACK16"] = 7] = "B5G5R5A1_UNORM_PACK16";
+	/** 1-bit alpha, 5-bit red, 5-bit green, and 5-bit blue, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["A1R5G5B5_UNORM_PACK16"] = 8] = "A1R5G5B5_UNORM_PACK16";
+	/** 8-bit red, unsigned normalized. */
+	VkFormat[VkFormat["R8_UNORM"] = 9] = "R8_UNORM";
+	/** 8-bit red, signed normalized. */
+	VkFormat[VkFormat["R8_SNORM"] = 10] = "R8_SNORM";
+	/** 8-bit red, unsigned scaled. */
+	VkFormat[VkFormat["R8_USCALED"] = 11] = "R8_USCALED";
+	/** 8-bit red, signed scaled. */
+	VkFormat[VkFormat["R8_SSCALED"] = 12] = "R8_SSCALED";
+	/** 8-bit red, unsigned integer. */
+	VkFormat[VkFormat["R8_UINT"] = 13] = "R8_UINT";
+	/** 8-bit red, signed integer. */
+	VkFormat[VkFormat["R8_SINT"] = 14] = "R8_SINT";
+	/** 8-bit red, sRGB. */
+	VkFormat[VkFormat["R8_SRGB"] = 15] = "R8_SRGB";
+	/** 8-bit red and green, unsigned normalized. */
+	VkFormat[VkFormat["R8G8_UNORM"] = 16] = "R8G8_UNORM";
+	/** 8-bit red and green, signed normalized. */
+	VkFormat[VkFormat["R8G8_SNORM"] = 17] = "R8G8_SNORM";
+	/** 8-bit red and green, unsigned scaled. */
+	VkFormat[VkFormat["R8G8_USCALED"] = 18] = "R8G8_USCALED";
+	/** 8-bit red and green, signed scaled. */
+	VkFormat[VkFormat["R8G8_SSCALED"] = 19] = "R8G8_SSCALED";
+	/** 8-bit red and green, unsigned integer. */
+	VkFormat[VkFormat["R8G8_UINT"] = 20] = "R8G8_UINT";
+	/** 8-bit red and green, signed integer. */
+	VkFormat[VkFormat["R8G8_SINT"] = 21] = "R8G8_SINT";
+	/** 8-bit red and green, sRGB. */
+	VkFormat[VkFormat["R8G8_SRGB"] = 22] = "R8G8_SRGB";
+	/** 8-bit red, green, and blue, unsigned normalized. */
+	VkFormat[VkFormat["R8G8B8_UNORM"] = 23] = "R8G8B8_UNORM";
+	/** 8-bit red, green, and blue, signed normalized. */
+	VkFormat[VkFormat["R8G8B8_SNORM"] = 24] = "R8G8B8_SNORM";
+	/** 8-bit red, green, and blue, unsigned scaled. */
+	VkFormat[VkFormat["R8G8B8_USCALED"] = 25] = "R8G8B8_USCALED";
+	/** 8-bit red, green, and blue, signed scaled. */
+	VkFormat[VkFormat["R8G8B8_SSCALED"] = 26] = "R8G8B8_SSCALED";
+	/** 8-bit red, green, and blue, unsigned integer. */
+	VkFormat[VkFormat["R8G8B8_UINT"] = 27] = "R8G8B8_UINT";
+	/** 8-bit red, green, and blue, signed integer. */
+	VkFormat[VkFormat["R8G8B8_SINT"] = 28] = "R8G8B8_SINT";
+	/** 8-bit red, green, and blue, sRGB. */
+	VkFormat[VkFormat["R8G8B8_SRGB"] = 29] = "R8G8B8_SRGB";
+	/** 8-bit blue, green, and red, unsigned normalized. */
+	VkFormat[VkFormat["B8G8R8_UNORM"] = 30] = "B8G8R8_UNORM";
+	/** 8-bit blue, green, and red, signed normalized. */
+	VkFormat[VkFormat["B8G8R8_SNORM"] = 31] = "B8G8R8_SNORM";
+	/** 8-bit blue, green, and red, unsigned scaled. */
+	VkFormat[VkFormat["B8G8R8_USCALED"] = 32] = "B8G8R8_USCALED";
+	/** 8-bit blue, green, and red, signed scaled. */
+	VkFormat[VkFormat["B8G8R8_SSCALED"] = 33] = "B8G8R8_SSCALED";
+	/** 8-bit blue, green, and red, unsigned integer. */
+	VkFormat[VkFormat["B8G8R8_UINT"] = 34] = "B8G8R8_UINT";
+	/** 8-bit blue, green, and red, signed integer. */
+	VkFormat[VkFormat["B8G8R8_SINT"] = 35] = "B8G8R8_SINT";
+	/** 8-bit blue, green, and red, sRGB. */
+	VkFormat[VkFormat["B8G8R8_SRGB"] = 36] = "B8G8R8_SRGB";
+	/** 8-bit red, green, blue, and alpha, unsigned normalized. */
+	VkFormat[VkFormat["R8G8B8A8_UNORM"] = 37] = "R8G8B8A8_UNORM";
+	/** 8-bit red, green, blue, and alpha, signed normalized. */
+	VkFormat[VkFormat["R8G8B8A8_SNORM"] = 38] = "R8G8B8A8_SNORM";
+	/** 8-bit red, green, blue, and alpha, unsigned scaled. */
+	VkFormat[VkFormat["R8G8B8A8_USCALED"] = 39] = "R8G8B8A8_USCALED";
+	/** 8-bit red, green, blue, and alpha, signed scaled. */
+	VkFormat[VkFormat["R8G8B8A8_SSCALED"] = 40] = "R8G8B8A8_SSCALED";
+	/** 8-bit red, green, blue, and alpha, unsigned integer. */
+	VkFormat[VkFormat["R8G8B8A8_UINT"] = 41] = "R8G8B8A8_UINT";
+	/** 8-bit red, green, blue, and alpha, signed integer. */
+	VkFormat[VkFormat["R8G8B8A8_SINT"] = 42] = "R8G8B8A8_SINT";
+	/** 8-bit red, green, blue, and alpha, sRGB. */
+	VkFormat[VkFormat["R8G8B8A8_SRGB"] = 43] = "R8G8B8A8_SRGB";
+	/** 8-bit blue, green, red, and alpha, unsigned normalized. */
+	VkFormat[VkFormat["B8G8R8A8_UNORM"] = 44] = "B8G8R8A8_UNORM";
+	/** 8-bit blue, green, red, and alpha, signed normalized. */
+	VkFormat[VkFormat["B8G8R8A8_SNORM"] = 45] = "B8G8R8A8_SNORM";
+	/** 8-bit blue, green, red, and alpha, unsigned scaled. */
+	VkFormat[VkFormat["B8G8R8A8_USCALED"] = 46] = "B8G8R8A8_USCALED";
+	/** 8-bit blue, green, red, and alpha, signed scaled. */
+	VkFormat[VkFormat["B8G8R8A8_SSCALED"] = 47] = "B8G8R8A8_SSCALED";
+	/** 8-bit blue, green, red, and alpha, unsigned integer. */
+	VkFormat[VkFormat["B8G8R8A8_UINT"] = 48] = "B8G8R8A8_UINT";
+	/** 8-bit blue, green, red, and alpha, signed integer. */
+	VkFormat[VkFormat["B8G8R8A8_SINT"] = 49] = "B8G8R8A8_SINT";
+	/** 8-bit blue, green, red, and alpha, sRGB. */
+	VkFormat[VkFormat["B8G8R8A8_SRGB"] = 50] = "B8G8R8A8_SRGB";
+	/** 8-bit alpha, blue, green, and red, unsigned normalized, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_UNORM_PACK32"] = 51] = "A8B8G8R8_UNORM_PACK32";
+	/** 8-bit alpha, blue, green, and red, signed normalized, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_SNORM_PACK32"] = 52] = "A8B8G8R8_SNORM_PACK32";
+	/** 8-bit alpha, blue, green, and red, unsigned scaled, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_USCALED_PACK32"] = 53] = "A8B8G8R8_USCALED_PACK32";
+	/** 8-bit alpha, blue, green, and red, signed scaled, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_SSCALED_PACK32"] = 54] = "A8B8G8R8_SSCALED_PACK32";
+	/** 8-bit alpha, blue, green, and red, unsigned integer, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_UINT_PACK32"] = 55] = "A8B8G8R8_UINT_PACK32";
+	/** 8-bit alpha, blue, green, and red, signed integer, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_SINT_PACK32"] = 56] = "A8B8G8R8_SINT_PACK32";
+	/** 8-bit alpha, blue, green, and red, sRGB, packed into a 32-bit word. */
+	VkFormat[VkFormat["A8B8G8R8_SRGB_PACK32"] = 57] = "A8B8G8R8_SRGB_PACK32";
+	/** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, unsigned normalized, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2R10G10B10_UNORM_PACK32"] = 58] = "A2R10G10B10_UNORM_PACK32";
+	/** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, signed normalized, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2R10G10B10_SNORM_PACK32"] = 59] = "A2R10G10B10_SNORM_PACK32";
+	/** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, unsigned scaled, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2R10G10B10_USCALED_PACK32"] = 60] = "A2R10G10B10_USCALED_PACK32";
+	/** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, signed scaled, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2R10G10B10_SSCALED_PACK32"] = 61] = "A2R10G10B10_SSCALED_PACK32";
+	/** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, unsigned integer, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2R10G10B10_UINT_PACK32"] = 62] = "A2R10G10B10_UINT_PACK32";
+	/** 2-bit alpha, 10-bit red, 10-bit green, and 10-bit blue, signed integer, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2R10G10B10_SINT_PACK32"] = 63] = "A2R10G10B10_SINT_PACK32";
+	/** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, unsigned normalized, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2B10G10R10_UNORM_PACK32"] = 64] = "A2B10G10R10_UNORM_PACK32";
+	/** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, signed normalized, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2B10G10R10_SNORM_PACK32"] = 65] = "A2B10G10R10_SNORM_PACK32";
+	/** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, unsigned scaled, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2B10G10R10_USCALED_PACK32"] = 66] = "A2B10G10R10_USCALED_PACK32";
+	/** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, signed scaled, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2B10G10R10_SSCALED_PACK32"] = 67] = "A2B10G10R10_SSCALED_PACK32";
+	/** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, unsigned integer, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2B10G10R10_UINT_PACK32"] = 68] = "A2B10G10R10_UINT_PACK32";
+	/** 2-bit alpha, 10-bit blue, 10-bit green, and 10-bit red, signed integer, packed into a 32-bit word. */
+	VkFormat[VkFormat["A2B10G10R10_SINT_PACK32"] = 69] = "A2B10G10R10_SINT_PACK32";
+	/** 16-bit red, unsigned normalized. */
+	VkFormat[VkFormat["R16_UNORM"] = 70] = "R16_UNORM";
+	/** 16-bit red, signed normalized. */
+	VkFormat[VkFormat["R16_SNORM"] = 71] = "R16_SNORM";
+	/** 16-bit red, unsigned scaled. */
+	VkFormat[VkFormat["R16_USCALED"] = 72] = "R16_USCALED";
+	/** 16-bit red, signed scaled. */
+	VkFormat[VkFormat["R16_SSCALED"] = 73] = "R16_SSCALED";
+	/** 16-bit red, unsigned integer. */
+	VkFormat[VkFormat["R16_UINT"] = 74] = "R16_UINT";
+	/** 16-bit red, signed integer. */
+	VkFormat[VkFormat["R16_SINT"] = 75] = "R16_SINT";
+	/** 16-bit red, signed floating-point. */
+	VkFormat[VkFormat["R16_SFLOAT"] = 76] = "R16_SFLOAT";
+	/** 16-bit red and green, unsigned normalized. */
+	VkFormat[VkFormat["R16G16_UNORM"] = 77] = "R16G16_UNORM";
+	/** 16-bit red and green, signed normalized. */
+	VkFormat[VkFormat["R16G16_SNORM"] = 78] = "R16G16_SNORM";
+	/** 16-bit red and green, unsigned scaled. */
+	VkFormat[VkFormat["R16G16_USCALED"] = 79] = "R16G16_USCALED";
+	/** 16-bit red and green, signed scaled. */
+	VkFormat[VkFormat["R16G16_SSCALED"] = 80] = "R16G16_SSCALED";
+	/** 16-bit red and green, unsigned integer. */
+	VkFormat[VkFormat["R16G16_UINT"] = 81] = "R16G16_UINT";
+	/** 16-bit red and green, signed integer. */
+	VkFormat[VkFormat["R16G16_SINT"] = 82] = "R16G16_SINT";
+	/** 16-bit red and green, signed floating-point. */
+	VkFormat[VkFormat["R16G16_SFLOAT"] = 83] = "R16G16_SFLOAT";
+	/** 16-bit red, green, and blue, unsigned normalized. */
+	VkFormat[VkFormat["R16G16B16_UNORM"] = 84] = "R16G16B16_UNORM";
+	/** 16-bit red, green, and blue, signed normalized. */
+	VkFormat[VkFormat["R16G16B16_SNORM"] = 85] = "R16G16B16_SNORM";
+	/** 16-bit red, green, and blue, unsigned scaled. */
+	VkFormat[VkFormat["R16G16B16_USCALED"] = 86] = "R16G16B16_USCALED";
+	/** 16-bit red, green, and blue, signed scaled. */
+	VkFormat[VkFormat["R16G16B16_SSCALED"] = 87] = "R16G16B16_SSCALED";
+	/** 16-bit red, green, and blue, unsigned integer. */
+	VkFormat[VkFormat["R16G16B16_UINT"] = 88] = "R16G16B16_UINT";
+	/** 16-bit red, green, and blue, signed integer. */
+	VkFormat[VkFormat["R16G16B16_SINT"] = 89] = "R16G16B16_SINT";
+	/** 16-bit red, green, and blue, signed floating-point. */
+	VkFormat[VkFormat["R16G16B16_SFLOAT"] = 90] = "R16G16B16_SFLOAT";
+	/** 16-bit red, green, blue, and alpha, unsigned normalized. */
+	VkFormat[VkFormat["R16G16B16A16_UNORM"] = 91] = "R16G16B16A16_UNORM";
+	/** 16-bit red, green, blue, and alpha, signed normalized. */
+	VkFormat[VkFormat["R16G16B16A16_SNORM"] = 92] = "R16G16B16A16_SNORM";
+	/** 16-bit red, green, blue, and alpha, unsigned scaled. */
+	VkFormat[VkFormat["R16G16B16A16_USCALED"] = 93] = "R16G16B16A16_USCALED";
+	/** 16-bit red, green, blue, and alpha, signed scaled. */
+	VkFormat[VkFormat["R16G16B16A16_SSCALED"] = 94] = "R16G16B16A16_SSCALED";
+	/** 16-bit red, green, blue, and alpha, unsigned integer. */
+	VkFormat[VkFormat["R16G16B16A16_UINT"] = 95] = "R16G16B16A16_UINT";
+	/** 16-bit red, green, blue, and alpha, signed integer. */
+	VkFormat[VkFormat["R16G16B16A16_SINT"] = 96] = "R16G16B16A16_SINT";
+	/** 16-bit red, green, blue, and alpha, signed floating-point. */
+	VkFormat[VkFormat["R16G16B16A16_SFLOAT"] = 97] = "R16G16B16A16_SFLOAT";
+	/** 32-bit red, unsigned integer. */
+	VkFormat[VkFormat["R32_UINT"] = 98] = "R32_UINT";
+	/** 32-bit red, signed integer. */
+	VkFormat[VkFormat["R32_SINT"] = 99] = "R32_SINT";
+	/** 32-bit red, signed floating-point. */
+	VkFormat[VkFormat["R32_SFLOAT"] = 100] = "R32_SFLOAT";
+	/** 32-bit red and green, unsigned integer. */
+	VkFormat[VkFormat["R32G32_UINT"] = 101] = "R32G32_UINT";
+	/** 32-bit red and green, signed integer. */
+	VkFormat[VkFormat["R32G32_SINT"] = 102] = "R32G32_SINT";
+	/** 32-bit red and green, signed floating-point. */
+	VkFormat[VkFormat["R32G32_SFLOAT"] = 103] = "R32G32_SFLOAT";
+	/** 32-bit red, green, and blue, unsigned integer. */
+	VkFormat[VkFormat["R32G32B32_UINT"] = 104] = "R32G32B32_UINT";
+	/** 32-bit red, green, and blue, signed integer. */
+	VkFormat[VkFormat["R32G32B32_SINT"] = 105] = "R32G32B32_SINT";
+	/** 32-bit red, green, and blue, signed floating-point. */
+	VkFormat[VkFormat["R32G32B32_SFLOAT"] = 106] = "R32G32B32_SFLOAT";
+	/** 32-bit red, green, blue, and alpha, unsigned integer. */
+	VkFormat[VkFormat["R32G32B32A32_UINT"] = 107] = "R32G32B32A32_UINT";
+	/** 32-bit red, green, blue, and alpha, signed integer. */
+	VkFormat[VkFormat["R32G32B32A32_SINT"] = 108] = "R32G32B32A32_SINT";
+	/** 32-bit red, green, blue, and alpha, signed floating-point. */
+	VkFormat[VkFormat["R32G32B32A32_SFLOAT"] = 109] = "R32G32B32A32_SFLOAT";
+	/** 64-bit red, unsigned integer. */
+	VkFormat[VkFormat["R64_UINT"] = 110] = "R64_UINT";
+	/** 64-bit red, signed integer. */
+	VkFormat[VkFormat["R64_SINT"] = 111] = "R64_SINT";
+	/** 64-bit red, signed floating-point. */
+	VkFormat[VkFormat["R64_SFLOAT"] = 112] = "R64_SFLOAT";
+	/** 64-bit red and green, unsigned integer. */
+	VkFormat[VkFormat["R64G64_UINT"] = 113] = "R64G64_UINT";
+	/** 64-bit red and green, signed integer. */
+	VkFormat[VkFormat["R64G64_SINT"] = 114] = "R64G64_SINT";
+	/** 64-bit red and green, signed floating-point. */
+	VkFormat[VkFormat["R64G64_SFLOAT"] = 115] = "R64G64_SFLOAT";
+	/** 64-bit red, green, and blue, unsigned integer. */
+	VkFormat[VkFormat["R64G64B64_UINT"] = 116] = "R64G64B64_UINT";
+	/** 64-bit red, green, and blue, signed integer. */
+	VkFormat[VkFormat["R64G64B64_SINT"] = 117] = "R64G64B64_SINT";
+	/** 64-bit red, green, and blue, signed floating-point. */
+	VkFormat[VkFormat["R64G64B64_SFLOAT"] = 118] = "R64G64B64_SFLOAT";
+	/** 64-bit red, green, blue, and alpha, unsigned integer. */
+	VkFormat[VkFormat["R64G64B64A64_UINT"] = 119] = "R64G64B64A64_UINT";
+	/** 64-bit red, green, blue, and alpha, signed integer. */
+	VkFormat[VkFormat["R64G64B64A64_SINT"] = 120] = "R64G64B64A64_SINT";
+	/** 64-bit red, green, blue, and alpha, signed floating-point. */
+	VkFormat[VkFormat["R64G64B64A64_SFLOAT"] = 121] = "R64G64B64A64_SFLOAT";
+	/** 10-bit blue, 11-bit green, and 11-bit red, unsigned floating-point, packed into a 32-bit word. */
+	VkFormat[VkFormat["B10G11R11_UFLOAT_PACK32"] = 122] = "B10G11R11_UFLOAT_PACK32";
+	/** 5-bit shared exponent, 9-bit blue, 9-bit green, and 9-bit red, unsigned floating-point, packed into a 32-bit word. */
+	VkFormat[VkFormat["E5B9G9R9_UFLOAT_PACK32"] = 123] = "E5B9G9R9_UFLOAT_PACK32";
+	/** 16-bit unsigned normalized depth. */
+	VkFormat[VkFormat["D16_UNORM"] = 124] = "D16_UNORM";
+	/** 24-bit unsigned normalized depth packed into a 32-bit word with 8 unused bits. */
+	VkFormat[VkFormat["X8_D24_UNORM_PACK32"] = 125] = "X8_D24_UNORM_PACK32";
+	/** 32-bit signed floating-point depth. */
+	VkFormat[VkFormat["D32_SFLOAT"] = 126] = "D32_SFLOAT";
+	/** 8-bit unsigned integer stencil. */
+	VkFormat[VkFormat["S8_UINT"] = 127] = "S8_UINT";
+	/** 16-bit unsigned normalized depth and 8-bit unsigned integer stencil. */
+	VkFormat[VkFormat["D16_UNORM_S8_UINT"] = 128] = "D16_UNORM_S8_UINT";
+	/** 24-bit unsigned normalized depth and 8-bit unsigned integer stencil. */
+	VkFormat[VkFormat["D24_UNORM_S8_UINT"] = 129] = "D24_UNORM_S8_UINT";
+	/** 32-bit signed floating-point depth and 8-bit unsigned integer stencil. */
+	VkFormat[VkFormat["D32_SFLOAT_S8_UINT"] = 130] = "D32_SFLOAT_S8_UINT";
+	/** 4×4 BC1 RGB block compression, unsigned normalized (8 bytes per block). */
+	VkFormat[VkFormat["BC1_RGB_UNORM_BLOCK"] = 131] = "BC1_RGB_UNORM_BLOCK";
+	/** 4×4 BC1 RGB block compression, sRGB (8 bytes per block). */
+	VkFormat[VkFormat["BC1_RGB_SRGB_BLOCK"] = 132] = "BC1_RGB_SRGB_BLOCK";
+	/** 4×4 BC1 RGBA block compression with punch-through alpha, unsigned normalized (8 bytes per block). */
+	VkFormat[VkFormat["BC1_RGBA_UNORM_BLOCK"] = 133] = "BC1_RGBA_UNORM_BLOCK";
+	/** 4×4 BC1 RGBA block compression with punch-through alpha, sRGB (8 bytes per block). */
+	VkFormat[VkFormat["BC1_RGBA_SRGB_BLOCK"] = 134] = "BC1_RGBA_SRGB_BLOCK";
+	/** 4×4 BC2 RGBA block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["BC2_UNORM_BLOCK"] = 135] = "BC2_UNORM_BLOCK";
+	/** 4×4 BC2 RGBA block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["BC2_SRGB_BLOCK"] = 136] = "BC2_SRGB_BLOCK";
+	/** 4×4 BC3 RGBA block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["BC3_UNORM_BLOCK"] = 137] = "BC3_UNORM_BLOCK";
+	/** 4×4 BC3 RGBA block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["BC3_SRGB_BLOCK"] = 138] = "BC3_SRGB_BLOCK";
+	/** 4×4 BC4 single-channel block compression, unsigned normalized (8 bytes per block). */
+	VkFormat[VkFormat["BC4_UNORM_BLOCK"] = 139] = "BC4_UNORM_BLOCK";
+	/** 4×4 BC4 single-channel block compression, signed normalized (8 bytes per block). */
+	VkFormat[VkFormat["BC4_SNORM_BLOCK"] = 140] = "BC4_SNORM_BLOCK";
+	/** 4×4 BC5 two-channel block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["BC5_UNORM_BLOCK"] = 141] = "BC5_UNORM_BLOCK";
+	/** 4×4 BC5 two-channel block compression, signed normalized (16 bytes per block). */
+	VkFormat[VkFormat["BC5_SNORM_BLOCK"] = 142] = "BC5_SNORM_BLOCK";
+	/** 4×4 BC6H HDR block compression, unsigned floating-point (16 bytes per block). */
+	VkFormat[VkFormat["BC6H_UFLOAT_BLOCK"] = 143] = "BC6H_UFLOAT_BLOCK";
+	/** 4×4 BC6H HDR block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["BC6H_SFLOAT_BLOCK"] = 144] = "BC6H_SFLOAT_BLOCK";
+	/** 4×4 BC7 RGBA block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["BC7_UNORM_BLOCK"] = 145] = "BC7_UNORM_BLOCK";
+	/** 4×4 BC7 RGBA block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["BC7_SRGB_BLOCK"] = 146] = "BC7_SRGB_BLOCK";
+	/** 4×4 ETC2 RGB block compression, unsigned normalized (8 bytes per block). */
+	VkFormat[VkFormat["ETC2_R8G8B8_UNORM_BLOCK"] = 147] = "ETC2_R8G8B8_UNORM_BLOCK";
+	/** 4×4 ETC2 RGB block compression, sRGB (8 bytes per block). */
+	VkFormat[VkFormat["ETC2_R8G8B8_SRGB_BLOCK"] = 148] = "ETC2_R8G8B8_SRGB_BLOCK";
+	/** 4×4 ETC2 RGB block compression with 1-bit alpha, unsigned normalized (8 bytes per block). */
+	VkFormat[VkFormat["ETC2_R8G8B8A1_UNORM_BLOCK"] = 149] = "ETC2_R8G8B8A1_UNORM_BLOCK";
+	/** 4×4 ETC2 RGB block compression with 1-bit alpha, sRGB (8 bytes per block). */
+	VkFormat[VkFormat["ETC2_R8G8B8A1_SRGB_BLOCK"] = 150] = "ETC2_R8G8B8A1_SRGB_BLOCK";
+	/** 4×4 ETC2 RGBA block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ETC2_R8G8B8A8_UNORM_BLOCK"] = 151] = "ETC2_R8G8B8A8_UNORM_BLOCK";
+	/** 4×4 ETC2 RGBA block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ETC2_R8G8B8A8_SRGB_BLOCK"] = 152] = "ETC2_R8G8B8A8_SRGB_BLOCK";
+	/** 4×4 EAC single-channel block compression, unsigned normalized (8 bytes per block). */
+	VkFormat[VkFormat["EAC_R11_UNORM_BLOCK"] = 153] = "EAC_R11_UNORM_BLOCK";
+	/** 4×4 EAC single-channel block compression, signed normalized (8 bytes per block). */
+	VkFormat[VkFormat["EAC_R11_SNORM_BLOCK"] = 154] = "EAC_R11_SNORM_BLOCK";
+	/** 4×4 EAC two-channel block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["EAC_R11G11_UNORM_BLOCK"] = 155] = "EAC_R11G11_UNORM_BLOCK";
+	/** 4×4 EAC two-channel block compression, signed normalized (16 bytes per block). */
+	VkFormat[VkFormat["EAC_R11G11_SNORM_BLOCK"] = 156] = "EAC_R11G11_SNORM_BLOCK";
+	/** ASTC 4×4 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_4X4_UNORM_BLOCK"] = 157] = "ASTC_4X4_UNORM_BLOCK";
+	/** ASTC 4×4 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_4X4_SRGB_BLOCK"] = 158] = "ASTC_4X4_SRGB_BLOCK";
+	/** ASTC 5×4 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_5X4_UNORM_BLOCK"] = 159] = "ASTC_5X4_UNORM_BLOCK";
+	/** ASTC 5×4 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_5X4_SRGB_BLOCK"] = 160] = "ASTC_5X4_SRGB_BLOCK";
+	/** ASTC 5×5 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_5X5_UNORM_BLOCK"] = 161] = "ASTC_5X5_UNORM_BLOCK";
+	/** ASTC 5×5 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_5X5_SRGB_BLOCK"] = 162] = "ASTC_5X5_SRGB_BLOCK";
+	/** ASTC 6×5 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_6X5_UNORM_BLOCK"] = 163] = "ASTC_6X5_UNORM_BLOCK";
+	/** ASTC 6×5 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_6X5_SRGB_BLOCK"] = 164] = "ASTC_6X5_SRGB_BLOCK";
+	/** ASTC 6×6 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_6X6_UNORM_BLOCK"] = 165] = "ASTC_6X6_UNORM_BLOCK";
+	/** ASTC 6×6 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_6X6_SRGB_BLOCK"] = 166] = "ASTC_6X6_SRGB_BLOCK";
+	/** ASTC 8×5 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X5_UNORM_BLOCK"] = 167] = "ASTC_8X5_UNORM_BLOCK";
+	/** ASTC 8×5 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X5_SRGB_BLOCK"] = 168] = "ASTC_8X5_SRGB_BLOCK";
+	/** ASTC 8×6 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X6_UNORM_BLOCK"] = 169] = "ASTC_8X6_UNORM_BLOCK";
+	/** ASTC 8×6 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X6_SRGB_BLOCK"] = 170] = "ASTC_8X6_SRGB_BLOCK";
+	/** ASTC 8×8 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X8_UNORM_BLOCK"] = 171] = "ASTC_8X8_UNORM_BLOCK";
+	/** ASTC 8×8 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X8_SRGB_BLOCK"] = 172] = "ASTC_8X8_SRGB_BLOCK";
+	/** ASTC 10×5 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X5_UNORM_BLOCK"] = 173] = "ASTC_10X5_UNORM_BLOCK";
+	/** ASTC 10×5 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X5_SRGB_BLOCK"] = 174] = "ASTC_10X5_SRGB_BLOCK";
+	/** ASTC 10×6 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X6_UNORM_BLOCK"] = 175] = "ASTC_10X6_UNORM_BLOCK";
+	/** ASTC 10×6 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X6_SRGB_BLOCK"] = 176] = "ASTC_10X6_SRGB_BLOCK";
+	/** ASTC 10×8 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X8_UNORM_BLOCK"] = 177] = "ASTC_10X8_UNORM_BLOCK";
+	/** ASTC 10×8 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X8_SRGB_BLOCK"] = 178] = "ASTC_10X8_SRGB_BLOCK";
+	/** ASTC 10×10 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X10_UNORM_BLOCK"] = 179] = "ASTC_10X10_UNORM_BLOCK";
+	/** ASTC 10×10 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X10_SRGB_BLOCK"] = 180] = "ASTC_10X10_SRGB_BLOCK";
+	/** ASTC 12×10 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_12X10_UNORM_BLOCK"] = 181] = "ASTC_12X10_UNORM_BLOCK";
+	/** ASTC 12×10 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_12X10_SRGB_BLOCK"] = 182] = "ASTC_12X10_SRGB_BLOCK";
+	/** ASTC 12×12 block compression, unsigned normalized (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_12X12_UNORM_BLOCK"] = 183] = "ASTC_12X12_UNORM_BLOCK";
+	/** ASTC 12×12 block compression, sRGB (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_12X12_SRGB_BLOCK"] = 184] = "ASTC_12X12_SRGB_BLOCK";
+	/** Packed 4:2:2 format with 8-bit unsigned normalized components in order G, B, G, R. */
+	VkFormat[VkFormat["G8B8G8R8_422_UNORM"] = 1000156e3] = "G8B8G8R8_422_UNORM";
+	/** Packed 4:2:2 format with 8-bit unsigned normalized components in order B, G, R, G. */
+	VkFormat[VkFormat["B8G8R8G8_422_UNORM"] = 1000156001] = "B8G8R8G8_422_UNORM";
+	/** 4:2:0 format stored as three planes (G, B, and R), 8-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G8_B8_R8_3PLANE_420_UNORM"] = 1000156002] = "G8_B8_R8_3PLANE_420_UNORM";
+	/** 4:2:0 format stored as two planes (G, and interleaved B and R), 8-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G8_B8R8_2PLANE_420_UNORM"] = 1000156003] = "G8_B8R8_2PLANE_420_UNORM";
+	/** 4:2:2 format stored as three planes (G, B, and R), 8-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G8_B8_R8_3PLANE_422_UNORM"] = 1000156004] = "G8_B8_R8_3PLANE_422_UNORM";
+	/** 4:2:2 format stored as two planes (G, and interleaved B and R), 8-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G8_B8R8_2PLANE_422_UNORM"] = 1000156005] = "G8_B8R8_2PLANE_422_UNORM";
+	/** 4:4:4 format stored as three planes (G, B, and R), 8-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G8_B8_R8_3PLANE_444_UNORM"] = 1000156006] = "G8_B8_R8_3PLANE_444_UNORM";
+	/** red with 10 significant bits and 6 unused bits, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["R10X6_UNORM_PACK16"] = 1000156007] = "R10X6_UNORM_PACK16";
+	/** red and green, each with 10 significant bits and 6 unused bits, unsigned normalized, packed into two 16-bit words. */
+	VkFormat[VkFormat["R10X6G10X6_UNORM_2PACK16"] = 1000156008] = "R10X6G10X6_UNORM_2PACK16";
+	/** red, green, blue, and alpha, each with 10 significant bits and 6 unused bits, unsigned normalized, packed into four 16-bit words. */
+	VkFormat[VkFormat["R10X6G10X6B10X6A10X6_UNORM_4PACK16"] = 1000156009] = "R10X6G10X6B10X6A10X6_UNORM_4PACK16";
+	/** Packed 4:2:2 format, unsigned normalized, each component with 10 significant bits and 6 unused bits, component order G, B, G, R. */
+	VkFormat[VkFormat["G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"] = 1000156010] = "G10X6B10X6G10X6R10X6_422_UNORM_4PACK16";
+	/** Packed 4:2:2 format, unsigned normalized, each component with 10 significant bits and 6 unused bits, component order B, G, R, G. */
+	VkFormat[VkFormat["B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"] = 1000156011] = "B10X6G10X6R10X6G10X6_422_UNORM_4PACK16";
+	/** 4:2:0 format stored as three planes (G, B, and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+	VkFormat[VkFormat["G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"] = 1000156012] = "G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16";
+	/** 4:2:0 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+	VkFormat[VkFormat["G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"] = 1000156013] = "G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16";
+	/** 4:2:2 format stored as three planes (G, B, and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+	VkFormat[VkFormat["G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"] = 1000156014] = "G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16";
+	/** 4:2:2 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+	VkFormat[VkFormat["G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"] = 1000156015] = "G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16";
+	/** 4:4:4 format stored as three planes (G, B, and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+	VkFormat[VkFormat["G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"] = 1000156016] = "G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16";
+	/** red with 12 significant bits and 4 unused bits, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["R12X4_UNORM_PACK16"] = 1000156017] = "R12X4_UNORM_PACK16";
+	/** red and green, each with 12 significant bits and 4 unused bits, unsigned normalized, packed into two 16-bit words. */
+	VkFormat[VkFormat["R12X4G12X4_UNORM_2PACK16"] = 1000156018] = "R12X4G12X4_UNORM_2PACK16";
+	/** red, green, blue, and alpha, each with 12 significant bits and 4 unused bits, unsigned normalized, packed into four 16-bit words. */
+	VkFormat[VkFormat["R12X4G12X4B12X4A12X4_UNORM_4PACK16"] = 1000156019] = "R12X4G12X4B12X4A12X4_UNORM_4PACK16";
+	/** Packed 4:2:2 format, unsigned normalized, each component with 12 significant bits and 4 unused bits, component order G, B, G, R. */
+	VkFormat[VkFormat["G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"] = 1000156020] = "G12X4B12X4G12X4R12X4_422_UNORM_4PACK16";
+	/** Packed 4:2:2 format, unsigned normalized, each component with 12 significant bits and 4 unused bits, component order B, G, R, G. */
+	VkFormat[VkFormat["B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"] = 1000156021] = "B12X4G12X4R12X4G12X4_422_UNORM_4PACK16";
+	/** 4:2:0 format stored as three planes (G, B, and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+	VkFormat[VkFormat["G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"] = 1000156022] = "G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16";
+	/** 4:2:0 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+	VkFormat[VkFormat["G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"] = 1000156023] = "G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16";
+	/** 4:2:2 format stored as three planes (G, B, and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+	VkFormat[VkFormat["G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"] = 1000156024] = "G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16";
+	/** 4:2:2 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+	VkFormat[VkFormat["G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"] = 1000156025] = "G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16";
+	/** 4:4:4 format stored as three planes (G, B, and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+	VkFormat[VkFormat["G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"] = 1000156026] = "G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16";
+	/** Packed 4:2:2 format with 16-bit unsigned normalized components in order G, B, G, R. */
+	VkFormat[VkFormat["G16B16G16R16_422_UNORM"] = 1000156027] = "G16B16G16R16_422_UNORM";
+	/** Packed 4:2:2 format with 16-bit unsigned normalized components in order B, G, R, G. */
+	VkFormat[VkFormat["B16G16R16G16_422_UNORM"] = 1000156028] = "B16G16R16G16_422_UNORM";
+	/** 4:2:0 format stored as three planes (G, B, and R), 16-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G16_B16_R16_3PLANE_420_UNORM"] = 1000156029] = "G16_B16_R16_3PLANE_420_UNORM";
+	/** 4:2:0 format stored as two planes (G, and interleaved B and R), 16-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G16_B16R16_2PLANE_420_UNORM"] = 1000156030] = "G16_B16R16_2PLANE_420_UNORM";
+	/** 4:2:2 format stored as three planes (G, B, and R), 16-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G16_B16_R16_3PLANE_422_UNORM"] = 1000156031] = "G16_B16_R16_3PLANE_422_UNORM";
+	/** 4:2:2 format stored as two planes (G, and interleaved B and R), 16-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G16_B16R16_2PLANE_422_UNORM"] = 1000156032] = "G16_B16R16_2PLANE_422_UNORM";
+	/** 4:4:4 format stored as three planes (G, B, and R), 16-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G16_B16_R16_3PLANE_444_UNORM"] = 1000156033] = "G16_B16_R16_3PLANE_444_UNORM";
+	/** 4:4:4 format stored as two planes (G, and interleaved B and R), 8-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G8_B8R8_2PLANE_444_UNORM"] = 100033e4] = "G8_B8R8_2PLANE_444_UNORM";
+	/** 4:4:4 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 10 significant bits and 6 unused bits. */
+	VkFormat[VkFormat["G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"] = 1000330001] = "G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16";
+	/** 4:4:4 format stored as two planes (G, and interleaved B and R), unsigned normalized samples with 12 significant bits and 4 unused bits. */
+	VkFormat[VkFormat["G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"] = 1000330002] = "G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16";
+	/** 4:4:4 format stored as two planes (G, and interleaved B and R), 16-bit unsigned normalized samples. */
+	VkFormat[VkFormat["G16_B16R16_2PLANE_444_UNORM"] = 1000330003] = "G16_B16R16_2PLANE_444_UNORM";
+	/** 4-bit alpha, red, green, and blue, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["A4R4G4B4_UNORM_PACK16"] = 100034e4] = "A4R4G4B4_UNORM_PACK16";
+	/** 4-bit alpha, blue, green, and red, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["A4B4G4R4_UNORM_PACK16"] = 1000340001] = "A4B4G4R4_UNORM_PACK16";
+	/** ASTC 4×4 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_4X4_SFLOAT_BLOCK"] = 1000066e3] = "ASTC_4X4_SFLOAT_BLOCK";
+	/** ASTC 5×4 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_5X4_SFLOAT_BLOCK"] = 1000066001] = "ASTC_5X4_SFLOAT_BLOCK";
+	/** ASTC 5×5 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_5X5_SFLOAT_BLOCK"] = 1000066002] = "ASTC_5X5_SFLOAT_BLOCK";
+	/** ASTC 6×5 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_6X5_SFLOAT_BLOCK"] = 1000066003] = "ASTC_6X5_SFLOAT_BLOCK";
+	/** ASTC 6×6 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_6X6_SFLOAT_BLOCK"] = 1000066004] = "ASTC_6X6_SFLOAT_BLOCK";
+	/** ASTC 8×5 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X5_SFLOAT_BLOCK"] = 1000066005] = "ASTC_8X5_SFLOAT_BLOCK";
+	/** ASTC 8×6 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X6_SFLOAT_BLOCK"] = 1000066006] = "ASTC_8X6_SFLOAT_BLOCK";
+	/** ASTC 8×8 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_8X8_SFLOAT_BLOCK"] = 1000066007] = "ASTC_8X8_SFLOAT_BLOCK";
+	/** ASTC 10×5 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X5_SFLOAT_BLOCK"] = 1000066008] = "ASTC_10X5_SFLOAT_BLOCK";
+	/** ASTC 10×6 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X6_SFLOAT_BLOCK"] = 1000066009] = "ASTC_10X6_SFLOAT_BLOCK";
+	/** ASTC 10×8 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X8_SFLOAT_BLOCK"] = 1000066010] = "ASTC_10X8_SFLOAT_BLOCK";
+	/** ASTC 10×10 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_10X10_SFLOAT_BLOCK"] = 1000066011] = "ASTC_10X10_SFLOAT_BLOCK";
+	/** ASTC 12×10 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_12X10_SFLOAT_BLOCK"] = 1000066012] = "ASTC_12X10_SFLOAT_BLOCK";
+	/** ASTC 12×12 block compression, signed floating-point (16 bytes per block). */
+	VkFormat[VkFormat["ASTC_12X12_SFLOAT_BLOCK"] = 1000066013] = "ASTC_12X12_SFLOAT_BLOCK";
+	/** 1-bit alpha, 5-bit blue, 5-bit green, and 5-bit red, unsigned normalized, packed into a 16-bit word. */
+	VkFormat[VkFormat["A1B5G5R5_UNORM_PACK16"] = 100047e4] = "A1B5G5R5_UNORM_PACK16";
+	/** 8-bit alpha, unsigned normalized. */
+	VkFormat[VkFormat["A8_UNORM"] = 1000470001] = "A8_UNORM";
+	/** PVRTC1 2 bits per pixel, unsigned normalized. */
+	VkFormat[VkFormat["PVRTC1_2BPP_UNORM_BLOCK_IMG"] = 1000054e3] = "PVRTC1_2BPP_UNORM_BLOCK_IMG";
+	/** PVRTC1 4 bits per pixel, unsigned normalized. */
+	VkFormat[VkFormat["PVRTC1_4BPP_UNORM_BLOCK_IMG"] = 1000054001] = "PVRTC1_4BPP_UNORM_BLOCK_IMG";
+	/** PVRTC2 2 bits per pixel, unsigned normalized. */
+	VkFormat[VkFormat["PVRTC2_2BPP_UNORM_BLOCK_IMG"] = 1000054002] = "PVRTC2_2BPP_UNORM_BLOCK_IMG";
+	/** PVRTC2 4 bits per pixel, unsigned normalized. */
+	VkFormat[VkFormat["PVRTC2_4BPP_UNORM_BLOCK_IMG"] = 1000054003] = "PVRTC2_4BPP_UNORM_BLOCK_IMG";
+	/** PVRTC1 2 bits per pixel, sRGB. */
+	VkFormat[VkFormat["PVRTC1_2BPP_SRGB_BLOCK_IMG"] = 1000054004] = "PVRTC1_2BPP_SRGB_BLOCK_IMG";
+	/** PVRTC1 4 bits per pixel, sRGB. */
+	VkFormat[VkFormat["PVRTC1_4BPP_SRGB_BLOCK_IMG"] = 1000054005] = "PVRTC1_4BPP_SRGB_BLOCK_IMG";
+	/** PVRTC2 2 bits per pixel, sRGB. */
+	VkFormat[VkFormat["PVRTC2_2BPP_SRGB_BLOCK_IMG"] = 1000054006] = "PVRTC2_2BPP_SRGB_BLOCK_IMG";
+	/** PVRTC2 4 bits per pixel, sRGB. */
+	VkFormat[VkFormat["PVRTC2_4BPP_SRGB_BLOCK_IMG"] = 1000054007] = "PVRTC2_4BPP_SRGB_BLOCK_IMG";
+	/** Two 16-bit signed fixed-point components (red and green). Each component has 10 integer bits and 5 fractional bits (NVIDIA). */
+	VkFormat[VkFormat["R16G16_SFIXED5_NV"] = 1000464e3] = "R16G16_SFIXED5_NV";
+	/** Alias of {@link VkFormat.ASTC_4X4_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_4X4_SFLOAT_BLOCK_EXT"] = 1000066e3] = "ASTC_4X4_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_5X4_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_5X4_SFLOAT_BLOCK_EXT"] = 1000066001] = "ASTC_5X4_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_5X5_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_5X5_SFLOAT_BLOCK_EXT"] = 1000066002] = "ASTC_5X5_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_6X5_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_6X5_SFLOAT_BLOCK_EXT"] = 1000066003] = "ASTC_6X5_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_6X6_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_6X6_SFLOAT_BLOCK_EXT"] = 1000066004] = "ASTC_6X6_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_8X5_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_8X5_SFLOAT_BLOCK_EXT"] = 1000066005] = "ASTC_8X5_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_8X6_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_8X6_SFLOAT_BLOCK_EXT"] = 1000066006] = "ASTC_8X6_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_8X8_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_8X8_SFLOAT_BLOCK_EXT"] = 1000066007] = "ASTC_8X8_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_10X5_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_10X5_SFLOAT_BLOCK_EXT"] = 1000066008] = "ASTC_10X5_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_10X6_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_10X6_SFLOAT_BLOCK_EXT"] = 1000066009] = "ASTC_10X6_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_10X8_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_10X8_SFLOAT_BLOCK_EXT"] = 1000066010] = "ASTC_10X8_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_10X10_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_10X10_SFLOAT_BLOCK_EXT"] = 1000066011] = "ASTC_10X10_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_12X10_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_12X10_SFLOAT_BLOCK_EXT"] = 1000066012] = "ASTC_12X10_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.ASTC_12X12_SFLOAT_BLOCK}. */
+	VkFormat[VkFormat["ASTC_12X12_SFLOAT_BLOCK_EXT"] = 1000066013] = "ASTC_12X12_SFLOAT_BLOCK_EXT";
+	/** Alias of {@link VkFormat.G8B8G8R8_422_UNORM}. */
+	VkFormat[VkFormat["G8B8G8R8_422_UNORM_KHR"] = 1000156e3] = "G8B8G8R8_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.B8G8R8G8_422_UNORM}. */
+	VkFormat[VkFormat["B8G8R8G8_422_UNORM_KHR"] = 1000156001] = "B8G8R8G8_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.G8_B8_R8_3PLANE_420_UNORM}. */
+	VkFormat[VkFormat["G8_B8_R8_3PLANE_420_UNORM_KHR"] = 1000156002] = "G8_B8_R8_3PLANE_420_UNORM_KHR";
+	/** Alias of {@link VkFormat.G8_B8R8_2PLANE_420_UNORM}. */
+	VkFormat[VkFormat["G8_B8R8_2PLANE_420_UNORM_KHR"] = 1000156003] = "G8_B8R8_2PLANE_420_UNORM_KHR";
+	/** Alias of {@link VkFormat.G8_B8_R8_3PLANE_422_UNORM}. */
+	VkFormat[VkFormat["G8_B8_R8_3PLANE_422_UNORM_KHR"] = 1000156004] = "G8_B8_R8_3PLANE_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.G8_B8R8_2PLANE_422_UNORM}. */
+	VkFormat[VkFormat["G8_B8R8_2PLANE_422_UNORM_KHR"] = 1000156005] = "G8_B8R8_2PLANE_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.G8_B8_R8_3PLANE_444_UNORM}. */
+	VkFormat[VkFormat["G8_B8_R8_3PLANE_444_UNORM_KHR"] = 1000156006] = "G8_B8_R8_3PLANE_444_UNORM_KHR";
+	/** Alias of {@link VkFormat.R10X6_UNORM_PACK16}. */
+	VkFormat[VkFormat["R10X6_UNORM_PACK16_KHR"] = 1000156007] = "R10X6_UNORM_PACK16_KHR";
+	/** Alias of {@link VkFormat.R10X6G10X6_UNORM_2PACK16}. */
+	VkFormat[VkFormat["R10X6G10X6_UNORM_2PACK16_KHR"] = 1000156008] = "R10X6G10X6_UNORM_2PACK16_KHR";
+	/** Alias of {@link VkFormat.R10X6G10X6B10X6A10X6_UNORM_4PACK16}. */
+	VkFormat[VkFormat["R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR"] = 1000156009] = "R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR";
+	/** Alias of {@link VkFormat.G10X6B10X6G10X6R10X6_422_UNORM_4PACK16}. */
+	VkFormat[VkFormat["G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR"] = 1000156010] = "G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR";
+	/** Alias of {@link VkFormat.B10X6G10X6R10X6G10X6_422_UNORM_4PACK16}. */
+	VkFormat[VkFormat["B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR"] = 1000156011] = "B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR";
+	/** Alias of {@link VkFormat.G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR"] = 1000156012] = "G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR"] = 1000156013] = "G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR"] = 1000156014] = "G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR"] = 1000156015] = "G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR"] = 1000156016] = "G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.R12X4_UNORM_PACK16}. */
+	VkFormat[VkFormat["R12X4_UNORM_PACK16_KHR"] = 1000156017] = "R12X4_UNORM_PACK16_KHR";
+	/** Alias of {@link VkFormat.R12X4G12X4_UNORM_2PACK16}. */
+	VkFormat[VkFormat["R12X4G12X4_UNORM_2PACK16_KHR"] = 1000156018] = "R12X4G12X4_UNORM_2PACK16_KHR";
+	/** Alias of {@link VkFormat.R12X4G12X4B12X4A12X4_UNORM_4PACK16}. */
+	VkFormat[VkFormat["R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR"] = 1000156019] = "R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR";
+	/** Alias of {@link VkFormat.G12X4B12X4G12X4R12X4_422_UNORM_4PACK16}. */
+	VkFormat[VkFormat["G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR"] = 1000156020] = "G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR";
+	/** Alias of {@link VkFormat.B12X4G12X4R12X4G12X4_422_UNORM_4PACK16}. */
+	VkFormat[VkFormat["B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR"] = 1000156021] = "B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR";
+	/** Alias of {@link VkFormat.G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR"] = 1000156022] = "G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR"] = 1000156023] = "G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR"] = 1000156024] = "G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR"] = 1000156025] = "G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR"] = 1000156026] = "G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR";
+	/** Alias of {@link VkFormat.G16B16G16R16_422_UNORM}. */
+	VkFormat[VkFormat["G16B16G16R16_422_UNORM_KHR"] = 1000156027] = "G16B16G16R16_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.B16G16R16G16_422_UNORM}. */
+	VkFormat[VkFormat["B16G16R16G16_422_UNORM_KHR"] = 1000156028] = "B16G16R16G16_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.G16_B16_R16_3PLANE_420_UNORM}. */
+	VkFormat[VkFormat["G16_B16_R16_3PLANE_420_UNORM_KHR"] = 1000156029] = "G16_B16_R16_3PLANE_420_UNORM_KHR";
+	/** Alias of {@link VkFormat.G16_B16R16_2PLANE_420_UNORM}. */
+	VkFormat[VkFormat["G16_B16R16_2PLANE_420_UNORM_KHR"] = 1000156030] = "G16_B16R16_2PLANE_420_UNORM_KHR";
+	/** Alias of {@link VkFormat.G16_B16_R16_3PLANE_422_UNORM}. */
+	VkFormat[VkFormat["G16_B16_R16_3PLANE_422_UNORM_KHR"] = 1000156031] = "G16_B16_R16_3PLANE_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.G16_B16R16_2PLANE_422_UNORM}. */
+	VkFormat[VkFormat["G16_B16R16_2PLANE_422_UNORM_KHR"] = 1000156032] = "G16_B16R16_2PLANE_422_UNORM_KHR";
+	/** Alias of {@link VkFormat.G16_B16_R16_3PLANE_444_UNORM}. */
+	VkFormat[VkFormat["G16_B16_R16_3PLANE_444_UNORM_KHR"] = 1000156033] = "G16_B16_R16_3PLANE_444_UNORM_KHR";
+	/** Alias of {@link VkFormat.G8_B8R8_2PLANE_444_UNORM}. */
+	VkFormat[VkFormat["G8_B8R8_2PLANE_444_UNORM_EXT"] = 100033e4] = "G8_B8R8_2PLANE_444_UNORM_EXT";
+	/** Alias of {@link VkFormat.G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT"] = 1000330001] = "G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT";
+	/** Alias of {@link VkFormat.G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16}. */
+	VkFormat[VkFormat["G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT"] = 1000330002] = "G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT";
+	/** Alias of {@link VkFormat.G16_B16R16_2PLANE_444_UNORM}. */
+	VkFormat[VkFormat["G16_B16R16_2PLANE_444_UNORM_EXT"] = 1000330003] = "G16_B16R16_2PLANE_444_UNORM_EXT";
+	/** Alias of {@link VkFormat.A4R4G4B4_UNORM_PACK16}. */
+	VkFormat[VkFormat["A4R4G4B4_UNORM_PACK16_EXT"] = 100034e4] = "A4R4G4B4_UNORM_PACK16_EXT";
+	/** Alias of {@link VkFormat.A4B4G4R4_UNORM_PACK16}. */
+	VkFormat[VkFormat["A4B4G4R4_UNORM_PACK16_EXT"] = 1000340001] = "A4B4G4R4_UNORM_PACK16_EXT";
+	/** Alias of {@link VkFormat.R16G16_SFIXED5_NV}. */
+	VkFormat[VkFormat["R16G16_S10_5_NV"] = 1000464e3] = "R16G16_S10_5_NV";
+	/** Alias of {@link VkFormat.A1B5G5R5_UNORM_PACK16}. */
+	VkFormat[VkFormat["A1B5G5R5_UNORM_PACK16_KHR"] = 100047e4] = "A1B5G5R5_UNORM_PACK16_KHR";
+	/** Alias of {@link VkFormat.A8_UNORM}. */
+	VkFormat[VkFormat["A8_UNORM_KHR"] = 1000470001] = "A8_UNORM_KHR";
+	/** Largest enumerator value. Not a texture format. */
+	VkFormat[VkFormat["MAX_ENUM"] = 2147483647] = "MAX_ENUM";
+	return VkFormat;
+}({});
+//#endregion
+//#region src/ris-ktx2/TextureFormatInfo.ts
+/**
+* Describes how a texture format is laid out in memory, in blocks.
+*
+* For uncompressed formats a block is one pixel:
+* `blockWidth` and `blockHeight` are `1`, and `bytesPerBlock` is the bytes per pixel.
+*
+* For compressed formats such as BC7, a block is a group of pixels
+* (typically 4×4) stored in a fixed number of bytes.
+*/
+var TextureFormatInfo = class TextureFormatInfo {
+	/** Width of one block, in pixels. */
+	blockWidth;
+	/** Height of one block, in pixels. */
+	blockHeight;
+	/** Depth of one block, in pixels. */
+	blockDepth;
+	/** Size of one block, in bytes. */
+	bytesPerBlock;
+	/**
+	* Average number of bytes used per pixel.
+	*
+	* For uncompressed formats this is the bytes per pixel.
+	* For compressed formats this is the average storage cost per pixel.
+	*/
+	get pixelSize() {
+		return this.bytesPerBlock / (this.blockWidth * this.blockHeight * this.blockDepth);
+	}
+	/**
+	* Creates a block-layout description.
+	*
+	* @param blockWidth - Block width, in pixels.
+	* @param blockHeight - Block height, in pixels.
+	* @param blockDepth - Block depth, in pixels.
+	* @param bytesPerBlock - Bytes stored in one block.
+	*/
+	constructor(blockWidth, blockHeight, blockDepth, bytesPerBlock) {
+		this.blockWidth = blockWidth;
+		this.blockHeight = blockHeight;
+		this.blockDepth = blockDepth;
+		this.bytesPerBlock = bytesPerBlock;
+	}
+	/**
+	* Number of blocks needed to cover `width` pixels.
+	*
+	* @param width - Texture width, in pixels.
+	* @returns Block count, rounded up to a whole block.
+	*/
+	getBlocksPerRow(width) {
+		return Math.ceil(width / this.blockWidth);
+	}
+	/**
+	* Number of block rows needed to cover `height` pixels.
+	*
+	* @param height - Texture height, in pixels.
+	* @returns Block-row count, rounded up to a whole block.
+	*/
+	getBlocksPerColumn(height) {
+		return Math.ceil(height / this.blockHeight);
+	}
+	/**
+	* Number of block slices needed to cover `depth` pixels.
+	*
+	* @param depth - Texture depth, in pixels.
+	* @returns Block-slice count, rounded up to a whole block.
+	*/
+	getBlocksPerSlice(depth) {
+		return Math.ceil(depth / this.blockDepth);
+	}
+	/**
+	* Unaligned number of bytes in one row of blocks.
+	*
+	* @param width - Texture width, in pixels.
+	* @returns Bytes per row, without a 256-byte alignment.
+	*/
+	getBytesPerRow(width) {
+		return this.getBlocksPerRow(width) * this.bytesPerBlock;
+	}
+	/**
+	* WebGPU `bytesPerRow` for `width`.
+	*
+	* WebGPU requires `bytesPerRow` to be a multiple of 256.
+	*
+	* @param width - Texture width, in pixels.
+	* @returns `getBytesPerRow(width)` rounded up to a multiple of 256.
+	*/
+	getAlignedBytesPerRow(width) {
+		const bytesPerRow = this.getBytesPerRow(width);
+		return Math.ceil(bytesPerRow / 256) * 256;
+	}
+	/**
+	* Byte size of one 2D mip level.
+	*
+	* @param width - Level width, in pixels.
+	* @param height - Level height, in pixels.
+	* @returns Level size, in bytes.
+	*/
+	getDataSize(width, height) {
+		return this.getBlocksPerRow(width) * this.getBlocksPerColumn(height) * this.bytesPerBlock;
+	}
+	/**
+	* Byte size of one 3D mip level.
+	*
+	* @param width - Level width, in pixels.
+	* @param height - Level height, in pixels.
+	* @param depth - Level depth, in pixels.
+	* @returns Level size, in bytes.
+	*/
+	getDataSize3D(width, height, depth) {
+		const blocksX = this.getBlocksPerRow(width);
+		const blocksY = this.getBlocksPerColumn(height);
+		const blocksZ = this.getBlocksPerSlice(depth);
+		return blocksX * blocksY * blocksZ * this.bytesPerBlock;
+	}
+	/**
+	* BC7 layout: 4×4 blocks, 16 bytes per block.
+	*
+	* @returns The BC7 {@link TextureFormatInfo}.
+	*/
+	static bc7() {
+		return new TextureFormatInfo(4, 4, 1, 16);
+	}
+	/**
+	* BC3 layout: 4×4 blocks, 16 bytes per block.
+	*
+	* @returns The BC3 {@link TextureFormatInfo}.
+	*/
+	static bc3() {
+		return new TextureFormatInfo(4, 4, 1, 16);
+	}
+	/**
+	* ETC2 RGBA layout: 4×4 blocks, 16 bytes per block.
+	*
+	* @returns The ETC2 RGBA {@link TextureFormatInfo}.
+	*/
+	static etc2rgba() {
+		return new TextureFormatInfo(4, 4, 1, 16);
+	}
+	/**
+	* ASTC 4×4 RGBA layout: 4×4 blocks, 16 bytes per block.
+	*
+	* @returns The ASTC 4×4 RGBA {@link TextureFormatInfo}.
+	*/
+	static astc4x4rgba() {
+		return new TextureFormatInfo(4, 4, 1, 16);
+	}
+	/**
+	* Uncompressed 8-bit 4-channel layout: 1×1 blocks, 4 bytes per pixel.
+	*
+	* Channel order does not change the size. `B8G8R8A8_*` and
+	* `A8B8G8R8_*_PACK32` use this same layout.
+	*
+	* @returns The 4-byte {@link TextureFormatInfo}.
+	*/
+	static rgba32() {
+		return new TextureFormatInfo(1, 1, 1, 4);
+	}
+	/**
+	* `D24_UNORM_S8_UINT` layout: 4 bytes per pixel.
+	*
+	* @returns The depth/stencil {@link TextureFormatInfo}.
+	*/
+	static depth24Stencil8() {
+		return new TextureFormatInfo(1, 1, 1, 4);
+	}
+	/**
+	* `D32_SFLOAT` layout: 4 bytes per pixel.
+	*
+	* @returns The 32-bit float depth {@link TextureFormatInfo}.
+	*/
+	static depth32float() {
+		return new TextureFormatInfo(1, 1, 1, 4);
+	}
+	/**
+	* Block layout for a Vulkan format this package knows how to size.
+	*
+	* sRGB, signed, integer, and scaled variants share the block size of the
+	* matching unsigned normalized format. Channel order does not change the
+	* byte size.
+	*
+	* - `R8G8B8A8_*`, `B8G8R8A8_*`, and `A8B8G8R8_*_PACK32` use {@link TextureFormatInfo.rgba32}.
+	* - `D24_UNORM_S8_UINT` uses {@link TextureFormatInfo.depth24Stencil8}.
+	* - `D32_SFLOAT` uses {@link TextureFormatInfo.depth32float}.
+	* - `BC3_UNORM_BLOCK` and `BC3_SRGB_BLOCK` use {@link TextureFormatInfo.bc3}.
+	* - `BC7_UNORM_BLOCK` and `BC7_SRGB_BLOCK` use {@link TextureFormatInfo.bc7}.
+	* - `ETC2_R8G8B8A8_UNORM_BLOCK` and `ETC2_R8G8B8A8_SRGB_BLOCK` use {@link TextureFormatInfo.etc2rgba}.
+	* - `ASTC_4X4_UNORM_BLOCK`, `ASTC_4X4_SRGB_BLOCK`, and `ASTC_4X4_SFLOAT_BLOCK`
+	*   use {@link TextureFormatInfo.astc4x4rgba}. `ASTC_4X4_SFLOAT_BLOCK_EXT`
+	*   is the same value as `ASTC_4X4_SFLOAT_BLOCK`.
+	*
+	* @param vkFormat - Vulkan format.
+	* @returns The matching layout.
+	* @throws {Error} When `vkFormat` has no layout in this package.
+	*/
+	static fromVkFormat(vkFormat) {
+		switch (vkFormat) {
+			case VkFormat.R8G8B8A8_UNORM:
+			case VkFormat.R8G8B8A8_SNORM:
+			case VkFormat.R8G8B8A8_USCALED:
+			case VkFormat.R8G8B8A8_SSCALED:
+			case VkFormat.R8G8B8A8_UINT:
+			case VkFormat.R8G8B8A8_SINT:
+			case VkFormat.R8G8B8A8_SRGB:
+			case VkFormat.B8G8R8A8_UNORM:
+			case VkFormat.B8G8R8A8_SNORM:
+			case VkFormat.B8G8R8A8_USCALED:
+			case VkFormat.B8G8R8A8_SSCALED:
+			case VkFormat.B8G8R8A8_UINT:
+			case VkFormat.B8G8R8A8_SINT:
+			case VkFormat.B8G8R8A8_SRGB:
+			case VkFormat.A8B8G8R8_UNORM_PACK32:
+			case VkFormat.A8B8G8R8_SNORM_PACK32:
+			case VkFormat.A8B8G8R8_USCALED_PACK32:
+			case VkFormat.A8B8G8R8_SSCALED_PACK32:
+			case VkFormat.A8B8G8R8_UINT_PACK32:
+			case VkFormat.A8B8G8R8_SINT_PACK32:
+			case VkFormat.A8B8G8R8_SRGB_PACK32: return this.rgba32();
+			case VkFormat.D24_UNORM_S8_UINT: return this.depth24Stencil8();
+			case VkFormat.D32_SFLOAT: return this.depth32float();
+			case VkFormat.ASTC_4X4_UNORM_BLOCK:
+			case VkFormat.ASTC_4X4_SRGB_BLOCK:
+			case VkFormat.ASTC_4X4_SFLOAT_BLOCK: return this.astc4x4rgba();
+			case VkFormat.BC7_UNORM_BLOCK:
+			case VkFormat.BC7_SRGB_BLOCK: return this.bc7();
+			case VkFormat.BC3_UNORM_BLOCK:
+			case VkFormat.BC3_SRGB_BLOCK: return this.bc3();
+			case VkFormat.ETC2_R8G8B8A8_UNORM_BLOCK:
+			case VkFormat.ETC2_R8G8B8A8_SRGB_BLOCK: return this.etc2rgba();
+			default: throw new Error(`TextureFormatInfo.fromVkFormat has no layout for VkFormat ${vkFormat}.`);
+		}
+	}
+};
+//#endregion
+//#region src/ris-ktx2/KtxErrorCode.ts
+/**
+* Result codes returned by KTX2 texture operations.
+*
+* Names and numeric values match libktx `ktx_error_code_e`.
+* `KTX_ERROR_MAX_ENUM` is not a member: in libktx it aliases
+* {@link KtxErrorCode.DECOMPRESS_CHECKSUM_ERROR} and is not a distinct result.
+*/
+var KtxErrorCode = /* @__PURE__ */ function(KtxErrorCode) {
+	/** The operation succeeded. */
+	KtxErrorCode[KtxErrorCode["SUCCESS"] = 0] = "SUCCESS";
+	/** The file data does not match the KTX specification. */
+	KtxErrorCode[KtxErrorCode["FILE_DATA_ERROR"] = 1] = "FILE_DATA_ERROR";
+	/** The file is a pipe or a named pipe. */
+	KtxErrorCode[KtxErrorCode["FILE_ISPIPE"] = 2] = "FILE_ISPIPE";
+	/** The target file could not be opened. */
+	KtxErrorCode[KtxErrorCode["FILE_OPEN_FAILED"] = 3] = "FILE_OPEN_FAILED";
+	/** The operation would exceed the maximum file size. */
+	KtxErrorCode[KtxErrorCode["FILE_OVERFLOW"] = 4] = "FILE_OVERFLOW";
+	/** Reading the file failed. */
+	KtxErrorCode[KtxErrorCode["FILE_READ_ERROR"] = 5] = "FILE_READ_ERROR";
+	/** Seeking in the file failed. */
+	KtxErrorCode[KtxErrorCode["FILE_SEEK_ERROR"] = 6] = "FILE_SEEK_ERROR";
+	/** The file ended before the requested data was read. */
+	KtxErrorCode[KtxErrorCode["FILE_UNEXPECTED_EOF"] = 7] = "FILE_UNEXPECTED_EOF";
+	/** Writing the file failed. */
+	KtxErrorCode[KtxErrorCode["FILE_WRITE_ERROR"] = 8] = "FILE_WRITE_ERROR";
+	/** An OpenGL call failed. */
+	KtxErrorCode[KtxErrorCode["GL_ERROR"] = 9] = "GL_ERROR";
+	/** The operation is not allowed in the current state. */
+	KtxErrorCode[KtxErrorCode["INVALID_OPERATION"] = 10] = "INVALID_OPERATION";
+	/** A parameter value was not valid. */
+	KtxErrorCode[KtxErrorCode["INVALID_VALUE"] = 11] = "INVALID_VALUE";
+	/** A metadata key was missing, or a required GPU entry point was not found. */
+	KtxErrorCode[KtxErrorCode["NOT_FOUND"] = 12] = "NOT_FOUND";
+	/** Not enough memory to complete the operation. */
+	KtxErrorCode[KtxErrorCode["OUT_OF_MEMORY"] = 13] = "OUT_OF_MEMORY";
+	/** Transcoding a block-compressed texture failed. */
+	KtxErrorCode[KtxErrorCode["TRANSCODE_FAILED"] = 14] = "TRANSCODE_FAILED";
+	/** The file is not a KTX file. */
+	KtxErrorCode[KtxErrorCode["UNKNOWN_FILE_FORMAT"] = 15] = "UNKNOWN_FILE_FORMAT";
+	/** The file requests a texture type this library does not support. */
+	KtxErrorCode[KtxErrorCode["UNSUPPORTED_TEXTURE_TYPE"] = 16] = "UNSUPPORTED_TEXTURE_TYPE";
+	/** The feature is not built into this library, or it is not implemented yet. */
+	KtxErrorCode[KtxErrorCode["UNSUPPORTED_FEATURE"] = 17] = "UNSUPPORTED_FEATURE";
+	/** An OpenGL or Vulkan dependency is not linked into the application. */
+	KtxErrorCode[KtxErrorCode["LIBRARY_NOT_LINKED"] = 18] = "LIBRARY_NOT_LINKED";
+	/** The decompressed byte count does not match the expected size. */
+	KtxErrorCode[KtxErrorCode["DECOMPRESS_LENGTH_ERROR"] = 19] = "DECOMPRESS_LENGTH_ERROR";
+	/** A checksum did not match while decompressing. */
+	KtxErrorCode[KtxErrorCode["DECOMPRESS_CHECKSUM_ERROR"] = 20] = "DECOMPRESS_CHECKSUM_ERROR";
+	return KtxErrorCode;
+}({});
+//#endregion
+export { KtxCreateStorage, KtxErrorCode, KtxTranscodeFlags, KtxTranscodeFormat, KtxUastcFlags, TextureFormatInfo, VkFormat };
+
+//# sourceMappingURL=index.js.map