@zephyr3d/device 0.1.0

package/dist/base_types.js

@@ -0,0 +1,602 @@
+import { floatToHalf } from '@zephyr3d/base';
+
+const RED_SHIFT = 0;
+const GREEN_SHIFT = 1;
+const BLUE_SHIFT = 2;
+const ALPHA_SHIFT = 3;
+const DEPTH_SHIFT = 4;
+const STENCIL_SHIFT = 5;
+const FLOAT_SHIFT = 6;
+const INTEGER_SHIFT = 7;
+const SIGNED_SHIFT = 8;
+const SRGB_SHIFT = 9;
+const BGR_SHIFT = 10;
+const BLOCK_SIZE_SHIFT = 11;
+const BLOCK_SIZE_MASK = 0x1f << BLOCK_SIZE_SHIFT;
+const BLOCK_WIDTH_SHIFT = 16;
+const BLOCK_WIDTH_MASK = 0xf << BLOCK_WIDTH_SHIFT;
+const BLOCK_HEIGHT_SHIFT = 20;
+const BLOCK_HEIGHT_MASK = 0xf << BLOCK_HEIGHT_SHIFT;
+const COMPRESSED_FORMAT_SHIFT = 24;
+const COMPRESSION_FORMAT_BC1 = 1 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC2 = 2 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC3 = 3 << COMPRESSED_FORMAT_SHIFT;
+/*
+const COMPRESSION_FORMAT_BC4 = 4 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC5 = 5 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC6 = 6 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_BC7 = 7 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ETC2_RGB8 = 8 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ETC2_RGB8_A1 = 9 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ETC2_RGBA8 = 10 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_4x4 = 11 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_5x4 = 12 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_5x5 = 13 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_6x5 = 14 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_6x6 = 15 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_8x5 = 16 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_8x6 = 17 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_8x8 = 18 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_10x5 = 19 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_10x6 = 20 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_10x8 = 21 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_10x10 = 22 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_12x10 = 23 << COMPRESSED_FORMAT_SHIFT;
+const COMPRESSION_FORMAT_ASTC_12x12 = 24 << COMPRESSED_FORMAT_SHIFT;
+*/ const COMPRESSION_FORMAT_BITMASK = 0x1f << COMPRESSED_FORMAT_SHIFT;
+const RED_BITMASK = 1 << RED_SHIFT;
+const GREEN_BITMASK = 1 << GREEN_SHIFT;
+const BLUE_BITMASK = 1 << BLUE_SHIFT;
+const ALPHA_BITMASK = 1 << ALPHA_SHIFT;
+const DEPTH_BITMASK = 1 << DEPTH_SHIFT;
+const STENCIL_BITMASK = 1 << STENCIL_SHIFT;
+const FLOAT_BITMASK = 1 << FLOAT_SHIFT;
+const INTEGER_BITMASK = 1 << INTEGER_SHIFT;
+const SIGNED_BITMASK = 1 << SIGNED_SHIFT;
+const SRGB_BITMASK = 1 << SRGB_SHIFT;
+const BGR_BITMASK = 1 << BGR_SHIFT;
+function makeTextureFormat(compression, r, g, b, a, depth, stencil, float, integer, signed, srgb, bgr, blockWidth, blockHeight, blockSize) {
+    const compressionBits = compression;
+    const colorBits = (r ? RED_BITMASK : 0) | (g ? GREEN_BITMASK : 0) | (b ? BLUE_BITMASK : 0) | (a ? ALPHA_BITMASK : 0);
+    const depthStencilBits = (depth ? DEPTH_BITMASK : 0) | (stencil ? STENCIL_BITMASK : 0);
+    const floatBits = float ? FLOAT_BITMASK : 0;
+    const integerBits = integer ? INTEGER_BITMASK : 0;
+    const signedBits = signed ? SIGNED_BITMASK : 0;
+    const srgbBits = srgb ? SRGB_BITMASK : 0;
+    const bgrBits = bgr ? BGR_BITMASK : 0;
+    const blockBits = blockWidth << BLOCK_WIDTH_SHIFT | blockHeight << BLOCK_HEIGHT_SHIFT | blockSize << BLOCK_SIZE_SHIFT;
+    return compressionBits | colorBits | depthStencilBits | floatBits | integerBits | signedBits | srgbBits | bgrBits | blockBits;
+}
+const textureFormatMap = {
+    'unknown': 0,
+    'r8unorm': makeTextureFormat(0, true, false, false, false, false, false, false, false, false, false, false, 1, 1, 1),
+    'r8snorm': makeTextureFormat(0, true, false, false, false, false, false, false, false, true, false, false, 1, 1, 1),
+    'r16f': makeTextureFormat(0, true, false, false, false, false, false, true, false, true, false, false, 1, 1, 2),
+    'r32f': makeTextureFormat(0, true, false, false, false, false, false, true, false, true, false, false, 1, 1, 4),
+    'r8ui': makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 1),
+    'r8i': makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 1),
+    'r16ui': makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 2),
+    'r16i': makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 2),
+    'r32ui': makeTextureFormat(0, true, false, false, false, false, false, false, true, false, false, false, 1, 1, 4),
+    'r32i': makeTextureFormat(0, true, false, false, false, false, false, false, true, true, false, false, 1, 1, 4),
+    'rg8unorm': makeTextureFormat(0, true, true, false, false, false, false, false, false, false, false, false, 1, 1, 2),
+    'rg8snorm': makeTextureFormat(0, true, true, false, false, false, false, false, false, true, false, false, 1, 1, 2),
+    'rg16f': makeTextureFormat(0, true, true, false, false, false, false, true, false, true, false, false, 1, 1, 4),
+    'rg32f': makeTextureFormat(0, true, true, false, false, false, false, true, false, true, false, false, 1, 1, 8),
+    'rg8ui': makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 2),
+    'rg8i': makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 2),
+    'rg16ui': makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 4),
+    'rg16i': makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 4),
+    'rg32ui': makeTextureFormat(0, true, true, false, false, false, false, false, true, false, false, false, 1, 1, 8),
+    'rg32i': makeTextureFormat(0, true, true, false, false, false, false, false, true, true, false, false, 1, 1, 8),
+    'rgba8unorm': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, false, false, 1, 1, 4),
+    'rgba8unorm-srgb': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, true, false, 1, 1, 4),
+    'rgba8snorm': makeTextureFormat(0, true, true, true, true, false, false, false, false, true, false, false, 1, 1, 4),
+    'bgra8unorm': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, false, true, 1, 1, 4),
+    'bgra8unorm-srgb': makeTextureFormat(0, true, true, true, true, false, false, false, false, false, true, true, 1, 1, 4),
+    'rgba16f': makeTextureFormat(0, true, true, true, true, false, false, true, false, true, false, false, 1, 1, 8),
+    'rgba32f': makeTextureFormat(0, true, true, true, true, false, false, true, false, true, false, false, 1, 1, 16),
+    'rgba8ui': makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 4),
+    'rgba8i': makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 4),
+    'rgba16ui': makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 8),
+    'rgba16i': makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 8),
+    'rgba32ui': makeTextureFormat(0, true, true, true, true, false, false, false, true, false, false, false, 1, 1, 16),
+    'rgba32i': makeTextureFormat(0, true, true, true, true, false, false, false, true, true, false, false, 1, 1, 16),
+    'rg11b10uf': makeTextureFormat(0, true, true, true, false, false, false, true, false, false, false, false, 1, 1, 4),
+    'd16': makeTextureFormat(0, false, false, false, false, true, false, false, false, false, false, false, 1, 1, 2),
+    'd24': makeTextureFormat(0, false, false, false, false, true, false, false, false, false, false, false, 0, 0, 0),
+    'd32f': makeTextureFormat(0, false, false, false, false, true, false, true, false, true, false, false, 1, 1, 4),
+    'd24s8': makeTextureFormat(0, false, false, false, false, true, true, false, false, false, false, false, 1, 1, 4),
+    'd32fs8': makeTextureFormat(0, false, false, false, false, true, true, true, false, true, false, false, 1, 1, 5),
+    // compressed texture formats
+    'dxt1': makeTextureFormat(COMPRESSION_FORMAT_BC1, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 8),
+    'dxt1-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC1, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 8),
+    'dxt3': makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
+    'dxt3-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC2, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16),
+    'dxt5': makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, false, false, 4, 4, 16),
+    'dxt5-srgb': makeTextureFormat(COMPRESSION_FORMAT_BC3, true, true, true, true, false, false, false, false, false, true, false, 4, 4, 16)
+};
+/**
+ * Converts a non-sRGB texture format to the corresponding sRGB texture format
+ * @param format - The texture format to be converted
+ * @returns The sRGB texture format
+ * @public
+ */ function linearTextureFormatToSRGB(format) {
+    switch(format){
+        case 'rgba8unorm':
+            return 'rgba8unorm-srgb';
+        case 'bgra8unorm':
+            return 'bgra8unorm-srgb';
+        case 'dxt1':
+            return 'dxt1-srgb';
+        case 'dxt3':
+            return 'dxt3-srgb';
+        case 'dxt5':
+            return 'dxt5-srgb';
+        default:
+            return format;
+    }
+}
+/**
+ * Check if a given texture format contains an alpha channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains an alpha channel, otherwise false
+ * @public
+ */ function hasAlphaChannel(format) {
+    return !!(textureFormatMap[format] & ALPHA_BITMASK);
+}
+/**
+ * Check if a given texture format contains a red channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a red channel, otherwise false
+ * @public
+ */ function hasRedChannel(format) {
+    return !!(textureFormatMap[format] & RED_BITMASK);
+}
+/**
+ * Check if a given texture format contains a green channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a green channel, otherwise false
+ * @public
+ */ function hasGreenChannel(format) {
+    return !!(textureFormatMap[format] & GREEN_BITMASK);
+}
+/**
+ * Check if a given texture format contains a blue channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a blue channel, otherwise false
+ * @public
+ */ function hasBlueChannel(format) {
+    return !!(textureFormatMap[format] & BLUE_BITMASK);
+}
+/**
+ * Check if a given texture format contains a depth channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a depth channel, otherwise false
+ * @public
+ */ function hasDepthChannel(format) {
+    return !!(textureFormatMap[format] & DEPTH_BITMASK);
+}
+/**
+ * Check if a given texture format contains a stencil channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a stencil channel, otherwise false
+ * @public
+ */ function hasStencilChannel(format) {
+    return !!(textureFormatMap[format] & STENCIL_BITMASK);
+}
+/**
+ * Check whether a given texture format is floating-point.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is floating-point, otherwise false
+ * @public
+ */ function isFloatTextureFormat(format) {
+    return !!(textureFormatMap[format] & FLOAT_BITMASK);
+}
+/**
+ * Check whether a given texture format is integer.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is integer, otherwise false
+ * @public
+ */ function isIntegerTextureFormat(format) {
+    return !!(textureFormatMap[format] & INTEGER_BITMASK);
+}
+/**
+ * Check whether a given texture format is signed.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is signed, otherwise false
+ * @public
+ */ function isSignedTextureFormat(format) {
+    return !!(textureFormatMap[format] & SIGNED_BITMASK);
+}
+/**
+ * Check whether a given texture format is a compressed format.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is a compressed format, otherwise false
+ * @public
+ */ function isCompressedTextureFormat(format) {
+    return !!(textureFormatMap[format] & COMPRESSION_FORMAT_BITMASK);
+}
+/**
+ * Check whether a given texture format is sRGB format.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is sRGB format, otherwise false
+ * @public
+ */ function isSRGBTextureFormat(format) {
+    return !!(textureFormatMap[format] & SRGB_BITMASK);
+}
+/**
+ * Get block size of given texture format
+ * @param format - The texture format
+ * @returns The block size
+ * @public
+ */ function getTextureFormatBlockSize(format) {
+    return (textureFormatMap[format] & BLOCK_SIZE_MASK) >> BLOCK_SIZE_SHIFT;
+}
+/**
+ * Get block width of given texture format
+ * @param format - The texture format
+ * @returns The block width
+ * @public
+ */ function getTextureFormatBlockWidth(format) {
+    return (textureFormatMap[format] & BLOCK_WIDTH_MASK) >> BLOCK_WIDTH_SHIFT;
+}
+/**
+ * Get block height of given texture format
+ * @param format - The texture format
+ * @returns The block height
+ * @public
+ */ function getTextureFormatBlockHeight(format) {
+    return (textureFormatMap[format] & BLOCK_HEIGHT_MASK) >> BLOCK_HEIGHT_SHIFT;
+}
+function normalizeColorComponent(val, maxval) {
+    return Math.min(maxval, Math.max(Math.floor(val * maxval), 0));
+}
+function normalizeColorComponentSigned(val, maxval) {
+    return normalizeColorComponent(val * 0.5 + 0.5, maxval) - (maxval + 1) / 2;
+}
+/** @internal */ function encodePixel(format, r, g, b, a) {
+    switch(format){
+        case 'r8unorm':
+            return new Uint8Array([
+                normalizeColorComponent(r, 255)
+            ]);
+        case 'r8snorm':
+            return new Int8Array([
+                normalizeColorComponentSigned(r, 255)
+            ]);
+        case 'r16f':
+            return new Uint16Array([
+                floatToHalf(r)
+            ]);
+        case 'r32f':
+            return new Float32Array([
+                r
+            ]);
+        case 'r8ui':
+            return new Uint8Array([
+                r | 0
+            ]);
+        case 'r8i':
+            return new Int8Array([
+                r | 0
+            ]);
+        case 'r16ui':
+            return new Uint16Array([
+                r | 0
+            ]);
+        case 'r16i':
+            return new Int16Array([
+                r | 0
+            ]);
+        case 'r32ui':
+            return new Uint32Array([
+                r | 0
+            ]);
+        case 'r32i':
+            return new Int32Array([
+                r | 0
+            ]);
+        case 'rg8unorm':
+            return new Uint8Array([
+                normalizeColorComponent(r, 255),
+                normalizeColorComponent(g, 255)
+            ]);
+        case 'rg8snorm':
+            return new Int8Array([
+                normalizeColorComponentSigned(r, 255),
+                normalizeColorComponentSigned(g, 255)
+            ]);
+        case 'rg16f':
+            return new Uint16Array([
+                floatToHalf(r),
+                floatToHalf(g)
+            ]);
+        case 'rg32f':
+            return new Float32Array([
+                r,
+                g
+            ]);
+        case 'rg8ui':
+            return new Uint8Array([
+                r | 0,
+                g | 0
+            ]);
+        case 'rg8i':
+            return new Int8Array([
+                r | 0,
+                g | 0
+            ]);
+        case 'rg16ui':
+            return new Uint16Array([
+                r | 0,
+                g | 0
+            ]);
+        case 'rg16i':
+            return new Int16Array([
+                r | 0,
+                g | 0
+            ]);
+        case 'rg32ui':
+            return new Uint32Array([
+                r | 0,
+                g | 0
+            ]);
+        case 'rg32i':
+            return new Int32Array([
+                r | 0,
+                g | 0
+            ]);
+        case 'rgba8unorm':
+        case 'rgba8unorm-srgb':
+            return new Uint8Array([
+                normalizeColorComponent(r, 255),
+                normalizeColorComponent(g, 255),
+                normalizeColorComponent(b, 255),
+                normalizeColorComponent(a, 255)
+            ]);
+        case 'bgra8unorm':
+        case 'bgra8unorm-srgb':
+            return new Uint8Array([
+                normalizeColorComponent(b, 255),
+                normalizeColorComponent(g, 255),
+                normalizeColorComponent(r, 255),
+                normalizeColorComponent(a, 255)
+            ]);
+        case 'rgba8snorm':
+            return new Int8Array([
+                normalizeColorComponentSigned(r, 255),
+                normalizeColorComponentSigned(g, 255),
+                normalizeColorComponentSigned(b, 255),
+                normalizeColorComponentSigned(a, 255)
+            ]);
+        case 'rgba16f':
+            return new Uint16Array([
+                floatToHalf(r),
+                floatToHalf(g),
+                floatToHalf(b),
+                floatToHalf(a)
+            ]);
+        case 'rgba32f':
+            return new Float32Array([
+                r,
+                g,
+                b,
+                a
+            ]);
+        case 'rgba8ui':
+            return new Uint8Array([
+                r | 0,
+                g | 0,
+                b | 0,
+                a | 0
+            ]);
+        case 'rgba8i':
+            return new Int8Array([
+                r | 0,
+                g | 0,
+                b | 0,
+                a | 0
+            ]);
+        case 'rgba16ui':
+            return new Uint16Array([
+                r | 0,
+                g | 0,
+                b | 0,
+                a | 0
+            ]);
+        case 'rgba16i':
+            return new Int16Array([
+                r | 0,
+                g | 0,
+                b | 0,
+                a | 0
+            ]);
+        case 'rgba32ui':
+            return new Uint32Array([
+                r | 0,
+                g | 0,
+                b | 0,
+                a | 0
+            ]);
+        case 'rgba32i':
+            return new Int32Array([
+                r | 0,
+                g | 0,
+                b | 0,
+                a | 0
+            ]);
+        default:
+            return null;
+    }
+}
+/** @internal */ function encodePixelToArray(format, r, g, b, a, arr) {
+    switch(format){
+        case 'r8unorm':
+            arr.push(normalizeColorComponent(r, 255));
+            break;
+        case 'r8snorm':
+            arr.push(normalizeColorComponentSigned(r, 255));
+            break;
+        case 'r16f':
+            arr.push(floatToHalf(r));
+            break;
+        case 'r32f':
+            arr.push(r);
+            break;
+        case 'r8ui':
+            arr.push(r | 0);
+            break;
+        case 'r8i':
+            arr.push(r | 0);
+            break;
+        case 'r16ui':
+            arr.push(r | 0);
+            break;
+        case 'r16i':
+            arr.push(r | 0);
+            break;
+        case 'r32ui':
+            arr.push(r | 0);
+            break;
+        case 'r32i':
+            arr.push(r | 0);
+            break;
+        case 'rg8unorm':
+            arr.push(normalizeColorComponent(r, 255), normalizeColorComponent(g, 255));
+            break;
+        case 'rg8snorm':
+            arr.push(normalizeColorComponentSigned(r, 255), normalizeColorComponentSigned(g, 255));
+            break;
+        case 'rg16f':
+            arr.push(floatToHalf(r), floatToHalf(g));
+            break;
+        case 'rg32f':
+            arr.push(r, g);
+            break;
+        case 'rg8ui':
+            arr.push(r | 0, g | 0);
+            break;
+        case 'rg8i':
+            arr.push(r | 0, g | 0);
+            break;
+        case 'rg16ui':
+            arr.push(r | 0, g | 0);
+            break;
+        case 'rg16i':
+            arr.push(r | 0, g | 0);
+            break;
+        case 'rg32ui':
+            arr.push(r | 0, g | 0);
+            break;
+        case 'rg32i':
+            arr.push(r | 0, g | 0);
+            break;
+        case 'rgba8unorm':
+        case 'rgba8unorm-srgb':
+            arr.push(normalizeColorComponent(r, 255), normalizeColorComponent(g, 255), normalizeColorComponent(b, 255), normalizeColorComponent(a, 255));
+            break;
+        case 'bgra8unorm':
+        case 'bgra8unorm-srgb':
+            arr.push(normalizeColorComponent(b, 255), normalizeColorComponent(g, 255), normalizeColorComponent(r, 255), normalizeColorComponent(a, 255));
+            break;
+        case 'rgba8snorm':
+            arr.push(normalizeColorComponentSigned(r, 255), normalizeColorComponentSigned(g, 255), normalizeColorComponentSigned(b, 255), normalizeColorComponentSigned(a, 255));
+            break;
+        case 'rgba16f':
+            arr.push(floatToHalf(r), floatToHalf(g), floatToHalf(b), floatToHalf(a));
+            break;
+        case 'rgba32f':
+            arr.push(r, g, b, a);
+            break;
+        case 'rgba8ui':
+            arr.push(r | 0, g | 0, b | 0, a | 0);
+            break;
+        case 'rgba8i':
+            arr.push(r | 0, g | 0, b | 0, a | 0);
+            break;
+        case 'rgba16ui':
+            arr.push(r | 0, g | 0, b | 0, a | 0);
+            break;
+        case 'rgba16i':
+            arr.push(r | 0, g | 0, b | 0, a | 0);
+            break;
+        case 'rgba32ui':
+            arr.push(r | 0, g | 0, b | 0, a | 0);
+            break;
+        case 'rgba32i':
+            arr.push(r | 0, g | 0, b | 0, a | 0);
+            break;
+    }
+}
+var ShaderType;
+(function(ShaderType) {
+    ShaderType[ShaderType["Vertex"] = 1] = "Vertex";
+    ShaderType[ShaderType["Fragment"] = 2] = "Fragment";
+    ShaderType[ShaderType["Compute"] = 4] = "Compute";
+})(ShaderType || (ShaderType = {}));
+/**
+ * Event that will be fired when device is lost
+ * @public
+ */ class DeviceLostEvent {
+    /** The event name */ static NAME = 'devicelost';
+    type = DeviceLostEvent.NAME;
+}
+/**
+ * Event that will be fired when device has just been restored
+ * @public
+ */ class DeviceRestoreEvent {
+    /** The event name */ static NAME = 'devicerestored';
+    type = DeviceRestoreEvent.NAME;
+}
+/**
+ * Event that will be fired when size of back buffer has changed
+ * @public
+ */ class DeviceResizeEvent {
+    /** The event name */ static NAME = 'resize';
+    width;
+    height;
+    type = DeviceResizeEvent.NAME;
+    constructor(width, height){
+        this.width = width;
+        this.height = height;
+    }
+}
+/**
+ * Event that will be fired when any gpu object is created
+ * @public
+ */ class DeviceGPUObjectAddedEvent {
+    /** the event name */ static NAME = 'gpuobject_added';
+    object;
+    type = DeviceGPUObjectAddedEvent.NAME;
+    constructor(obj){
+        this.object = obj;
+    }
+}
+/**
+ * Event that will be fired when any gpu object is disposed
+ * @public
+ */ class DeviceGPUObjectRemovedEvent {
+    /** The event name */ static NAME = 'gpuobject_removed';
+    object;
+    type = DeviceGPUObjectRemovedEvent.NAME;
+    constructor(obj){
+        this.object = obj;
+    }
+}
+/**
+ * Event that will be fired when any gpu object name is changed
+ * @public
+ */ class DeviceGPUObjectRenameEvent {
+    /** The event name */ static NAME = 'gpuobject_rename';
+    object;
+    lastName;
+    type = DeviceGPUObjectRenameEvent.NAME;
+    constructor(obj, lastName){
+        this.object = obj;
+        this.lastName = lastName;
+    }
+}
+
+export { DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceResizeEvent, DeviceRestoreEvent, ShaderType, encodePixel, encodePixelToArray, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB };
+//# sourceMappingURL=base_types.js.map

package/dist/base_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_types.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}