@galacean/engine-rhi-webgl 1.6.8 → 1.6.10

package/types/GLCapability.d.ts

@@ -0,0 +1,53 @@
+import { GLCapabilityType } from "@galacean/engine-core";
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+import { GLCompressedTextureInternalFormat } from "./type";
+/**
+ * GL capability.
+ */
+export declare class GLCapability {
+    private _maxDrawBuffers;
+    private _maxAnisoLevel;
+    private _maxAntiAliasing;
+    _rhi: WebGLGraphicDevice;
+    capabilityList: Map<GLCapabilityType, boolean>;
+    get maxTextureSize(): boolean;
+    get canUseFloatTextureBlendShape(): boolean;
+    /**
+     * Whether can use more joints.
+     */
+    get canIUseMoreJoints(): boolean;
+    get maxDrawBuffers(): number;
+    /**
+     * Max anisoLevel.
+     */
+    get maxAnisoLevel(): number;
+    /**
+     * Max MSAA count.
+     */
+    get maxAntiAliasing(): number;
+    get isFragmentHighPrecision(): boolean;
+    get rhi(): WebGLGraphicDevice;
+    constructor(rhi: WebGLGraphicDevice);
+    /**
+     * Check device capabilities.
+     */
+    canIUse(capabilityType: GLCapabilityType): boolean;
+    /**
+     * Check if can use some compressed texture format.
+     */
+    canIUseCompressedTextureInternalFormat(internalType: GLCompressedTextureInternalFormat): boolean;
+    /**
+     *  Init capabilities.
+     */
+    private _init;
+    /**
+     * If there are extensions that can supplement this ability, smooth out the difference.
+     * @example
+     * compatible(GLCapabilityType.depthTexture,{
+     *    UNSIGNED_INT_24_8: "UNSIGNED_INT_24_8_WEBGL"
+     * })
+     * gl.UNSIGNED_INT_24_8 = ext.UNSIGNED_INT_24_8_WEBGL
+     */
+    private _compatibleInterface;
+    private _compatibleAllInterface;
+}

package/types/GLExtensions.d.ts

@@ -0,0 +1,14 @@
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+import { GLCapabilityType } from "@galacean/engine-core";
+/**
+ * GLContext extension.
+ */
+export declare class GLExtensions {
+    private rhi;
+    private _requireResult;
+    constructor(rhi: WebGLGraphicDevice);
+    /**
+     * Require an extension.
+     */
+    requireExtension(ext: GLCapabilityType): any;
+}

package/types/GLPrimitive.d.ts

@@ -0,0 +1 @@
+export {};

package/types/GLRenderStates.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @private
+ */
+export declare class GLRenderStates {
+    private _gl;
+    private _parameters;
+    /**
+     * @param {WebGLRenderingContext} gl
+     */
+    constructor(gl: WebGLRenderingContext);
+    /**
+     * Get a parameter.
+     */
+    getParameter(pname: any): any;
+}

package/types/GLRenderTarget.d.ts

@@ -0,0 +1,40 @@
+import { IPlatformRenderTarget, RenderTarget, TextureCubeFace } from "@galacean/engine-core";
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+/**
+ * The render target in WebGL platform is used for off-screen rendering.
+ */
+export declare class GLRenderTarget implements IPlatformRenderTarget {
+    private _gl;
+    private _isWebGL2;
+    private _target;
+    private _frameBuffer;
+    private _MSAAFrameBuffer;
+    private _depthRenderBuffer;
+    private _MSAAColorRenderBuffers;
+    private _MSAADepthRenderBuffer;
+    private _oriDrawBuffers;
+    private _blitDrawBuffers;
+    private _curMipLevel;
+    private _curFaceIndex;
+    /**
+     * Create render target in WebGL platform.
+     */
+    constructor(rhi: WebGLGraphicDevice, target: RenderTarget);
+    /**
+     * Set which face and mipLevel of the cube texture to render to.
+     * @param mipLevel - Set mip level the data want to write
+     * @param faceIndex - Cube texture face
+     */
+    activeRenderTarget(mipLevel: number, faceIndex?: TextureCubeFace): void;
+    /**
+     * Blit FBO.
+     */
+    blitRenderTarget(): void;
+    /**
+     * Destroy render target.
+     */
+    destroy(): void;
+    private _bindMainFBO;
+    private _bindMSAAFBO;
+    private _checkFrameBuffer;
+}

package/types/GLTexture.d.ts

@@ -0,0 +1,55 @@
+import { IPlatformTexture, Texture, TextureCubeFace, TextureDepthCompareFunction, TextureFilterMode, TextureWrapMode } from "@galacean/engine-core";
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+/**
+ * Texture in WebGL platform.
+ */
+export declare class GLTexture implements IPlatformTexture {
+    /**
+     * Wrapping mode for texture coordinate S.
+     */
+    set wrapModeU(value: TextureWrapMode);
+    /**
+     * Wrapping mode for texture coordinate T.
+     */
+    set wrapModeV(value: TextureWrapMode);
+    /**
+     * Filter mode for texture.
+     */
+    set filterMode(value: TextureFilterMode);
+    /**
+     * Anisotropic level for texture.
+     */
+    set anisoLevel(value: number);
+    set depthCompareFunction(value: TextureDepthCompareFunction);
+    /**
+     * Create texture in WebGL platform.
+     */
+    constructor(rhi: WebGLGraphicDevice, texture: Texture, target: GLenum);
+    /**
+     * Destroy texture.
+     */
+    destroy(): void;
+    /**
+     * Generate multi-level textures based on the 0th level data.
+     */
+    generateMipmaps(): void;
+    protected _bind(): void;
+    /**
+     * Pre-development mipmapping GPU memory.
+     */
+    protected _init(isCube: boolean): void;
+    /**
+     * Get the pixel color buffer according to the specified cube face and area.
+     * @param face - You can choose which cube face to read
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param out - Color buffer
+     * @param mipLevel - Set mip level the data want to get from
+     */
+    protected _getPixelBuffer(face: TextureCubeFace | null, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+    protected _getReadFrameBuffer(): WebGLFramebuffer;
+    protected _validate(texture: Texture, rhi: WebGLGraphicDevice): void;
+    private _setWrapMode;
+}

package/types/GLTexture2D.d.ts

@@ -0,0 +1,23 @@
+import { IPlatformTexture2D, Texture2D } from "@galacean/engine-core";
+import { GLTexture } from "./GLTexture";
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+/**
+ * Texture 2d in WebGL platform.
+ */
+export declare class GLTexture2D extends GLTexture implements IPlatformTexture2D {
+    /** Backward compatible with WebGL1.0. */
+    private _compressedMipFilled;
+    constructor(rhi: WebGLGraphicDevice, texture2D: Texture2D);
+    /**
+     * {@inheritDoc IPlatformTexture2D.setPixelBuffer}
+     */
+    setPixelBuffer(colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2D.setImageSource}
+     */
+    setImageSource(imageSource: TexImageSource, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2D.getPixelBuffer }
+     */
+    getPixelBuffer(x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/GLTexture2DArray.d.ts

@@ -0,0 +1,22 @@
+import { IPlatformTexture2DArray, Texture2DArray } from "@galacean/engine-core";
+import { GLTexture } from "./GLTexture";
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+/**
+ * Texture 2D array in WebGL platform.
+ */
+export declare class GLTexture2DArray extends GLTexture implements IPlatformTexture2DArray {
+    constructor(rhi: WebGLGraphicDevice, texture2DArray: Texture2DArray);
+    /**
+     * {@inheritDoc IPlatformTexture2DArray.setPixelBuffer}
+     */
+    setPixelBuffer(offsetIndex: number, colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number, length?: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2DArray.setImageSource}
+     */
+    setImageSource(elementIndex: number, imageSource: TexImageSource, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * {@inheritDoc IPlatformTexture2DArray.getPixelBuffer}
+     */
+    getPixelBuffer(elementIndex: number, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+    protected _validate(texture: Texture2DArray, rhi: WebGLGraphicDevice): void;
+}

package/types/GLTextureCube.d.ts

@@ -0,0 +1,23 @@
+import { IPlatformTextureCube, TextureCube, TextureCubeFace } from "@galacean/engine-core";
+import { GLTexture } from "./GLTexture";
+import { WebGLGraphicDevice } from "./WebGLGraphicDevice";
+/**
+ * Cube texture in WebGL platform.
+ */
+export declare class GLTextureCube extends GLTexture implements IPlatformTextureCube {
+    /** Backward compatible with WebGL1.0. */
+    private _compressedFaceFilled;
+    constructor(rhi: WebGLGraphicDevice, textureCube: TextureCube);
+    /**
+     * {@inheritDoc IPlatformTextureCube.setPixelBuffer}
+     */
+    setPixelBuffer(face: TextureCubeFace, colorBuffer: ArrayBufferView, mipLevel: number, x: number, y: number, width?: number, height?: number): void;
+    /**
+     * {@inheritDoc IPlatformTextureCube.setImageSource}
+     */
+    setImageSource(face: TextureCubeFace, imageSource: TexImageSource, mipLevel: number, flipY: boolean, premultiplyAlpha: boolean, x: number, y: number): void;
+    /**
+     * {@inheritDoc IPlatformTextureCube.getPixelBuffer}
+     */
+    getPixelBuffer(face: TextureCubeFace, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/WebCanvas.d.ts

@@ -0,0 +1,35 @@
+import { Canvas } from "@galacean/engine-core";
+import { Vector2 } from "@galacean/engine-math";
+type OffscreenCanvas = any;
+/**
+ * The canvas used on the web, which can support HTMLCanvasElement and OffscreenCanvas.
+ */
+export declare class WebCanvas extends Canvas {
+    _webCanvas: HTMLCanvasElement | OffscreenCanvas;
+    private _scale;
+    /**
+     * The scale of canvas, the value is visible width/height divide the render width/height.
+     * @remarks Need to re-assign after modification to ensure that the modification takes effect.
+     */
+    get scale(): Vector2;
+    set scale(value: Vector2);
+    /**
+     * Resize the rendering size according to the clientWidth and clientHeight of the canvas.
+     * @param pixelRatio - Pixel ratio
+     */
+    resizeByClientSize(pixelRatio?: number): void;
+    /**
+     * Create a web canvas.
+     * @param webCanvas - Web native canvas
+     */
+    constructor(webCanvas: HTMLCanvasElement | OffscreenCanvas);
+    /**
+     * Set scale.
+     * @param x - Scale along the X axis
+     * @param y - Scale along the Y axis
+     */
+    setScale(x: number, y: number): void;
+    protected _onWidthChanged(value: number): void;
+    protected _onHeightChange(value: number): void;
+}
+export {};

package/types/WebGLEngine.d.ts

@@ -0,0 +1,27 @@
+import { Engine, EngineConfiguration } from "@galacean/engine-core";
+import { WebGLGraphicDeviceOptions } from "./";
+import { WebCanvas } from "./WebCanvas";
+/**
+ * WebGL platform engine,support includes WebGL1.0 and WebGL2.0.
+ */
+export declare class WebGLEngine extends Engine {
+    /**
+     * Create a WebGL engine.
+     * @param configuration - WebGL engine configuration
+     * @returns A promise that will resolve when the engine is created
+     */
+    static create(configuration: WebGLEngineConfiguration): Promise<WebGLEngine>;
+    /**
+     * Web canvas.
+     */
+    get canvas(): WebCanvas;
+}
+/**
+ * WebGL engine configuration.
+ */
+export interface WebGLEngineConfiguration extends EngineConfiguration {
+    /** Canvas element or canvas id. */
+    canvas: HTMLCanvasElement | OffscreenCanvas | string;
+    /** Graphic device options. */
+    graphicDeviceOptions?: WebGLGraphicDeviceOptions;
+}

package/types/WebGLGraphicDevice.d.ts

@@ -0,0 +1,106 @@
+import { BufferBindFlag, BufferUsage, CameraClearFlags, Canvas, Engine, GLCapabilityType, IPlatformBuffer, IPlatformRenderTarget, IPlatformTexture2D, IPlatformTextureCube, Mesh, RenderTarget, SubMesh, Texture2D, Texture2DArray, TextureCube, TextureCubeFace } from "@galacean/engine-core";
+import { IHardwareRenderer, IPlatformPrimitive, IPlatformShaderProgram } from "@galacean/engine-design";
+import { Color, Vector4 } from "@galacean/engine-math";
+import { GLCapability } from "./GLCapability";
+import { GLPrimitive } from "./GLPrimitive";
+import { GLRenderStates } from "./GLRenderStates";
+import { GLTexture } from "./GLTexture";
+import { GLTexture2DArray } from "./GLTexture2DArray";
+import { WebGLExtension } from "./type";
+/**
+ * WebGL mode.
+ */
+export declare enum WebGLMode {
+    /** Auto, use WebGL2.0 if support, or will fallback to WebGL1.0. */
+    Auto = 0,
+    /** WebGL2.0. */
+    WebGL2 = 1,
+    /** WebGL1.0, */
+    WebGL1 = 2
+}
+/**
+ * WebGL graphic device options.
+ */
+export interface WebGLGraphicDeviceOptions {
+    /** WebGL mode.*/
+    webGLMode?: WebGLMode;
+    alpha?: boolean;
+    depth?: boolean;
+    desynchronized?: boolean;
+    failIfMajorPerformanceCaveat?: boolean;
+    powerPreference?: WebGLPowerPreference;
+    premultipliedAlpha?: boolean;
+    preserveDrawingBuffer?: boolean;
+    stencil?: boolean;
+    xrCompatible?: boolean;
+}
+/**
+ * WebGL graphic device, including WebGL1.0 and WebGL2.0.
+ */
+export declare class WebGLGraphicDevice implements IHardwareRenderer {
+    private _options;
+    private _webGLOptions;
+    private _gl;
+    private _renderStates;
+    private _extensions;
+    private _capability;
+    private _isWebGL2;
+    private _renderer;
+    private _webCanvas;
+    private _activeTextureID;
+    private _activeTextures;
+    private _lastViewport;
+    private _lastScissor;
+    private _lastClearColor;
+    private _scissorEnable;
+    private _onDeviceLost;
+    private _onDeviceRestored;
+    get isWebGL2(): boolean;
+    get renderer(): string;
+    /**
+     * GL Context
+     * @member {WebGLRenderingContext}
+     */
+    get gl(): (WebGLRenderingContext & WebGLExtension) | WebGL2RenderingContext;
+    get renderStates(): GLRenderStates;
+    get capability(): GLCapability;
+    get canIUseMoreJoints(): boolean;
+    constructor(initializeOptions?: WebGLGraphicDeviceOptions);
+    init(canvas: Canvas, onDeviceLost: () => void, onDeviceRestored: () => void): void;
+    createPlatformPrimitive(primitive: Mesh): IPlatformPrimitive;
+    createPlatformTexture2D(texture2D: Texture2D): IPlatformTexture2D;
+    createPlatformTexture2DArray(texture2D: Texture2DArray): GLTexture2DArray;
+    createPlatformTextureCube(textureCube: TextureCube): IPlatformTextureCube;
+    createPlatformRenderTarget(target: RenderTarget): IPlatformRenderTarget;
+    createPlatformBuffer(type: BufferBindFlag, byteLength: number, bufferUsage?: BufferUsage, data?: ArrayBuffer | ArrayBufferView): IPlatformBuffer;
+    requireExtension(ext: any): any;
+    canIUse(capabilityType: GLCapabilityType): boolean;
+    canIUseCompressedTextureInternalFormat(type: number): boolean;
+    viewport(x: number, y: number, width: number, height: number): void;
+    scissor(x: number, y: number, width: number, height: number): void;
+    colorMask(r: boolean, g: boolean, b: boolean, a: boolean): void;
+    clearRenderTarget(engine: Engine, clearFlags: CameraClearFlags, clearColor?: Color): void;
+    drawPrimitive(primitive: GLPrimitive, subPrimitive: SubMesh, shaderProgram: IPlatformShaderProgram): void;
+    getMainFrameBufferWidth(): number;
+    getMainFrameBufferHeight(): number;
+    activeRenderTarget(renderTarget: RenderTarget, viewport: Vector4, isFlipProjection: boolean, mipLevel?: number, faceIndex?: TextureCubeFace): void;
+    blitInternalRTByBlitFrameBuffer(srcRT: RenderTarget, destRT: RenderTarget, clearFlags: CameraClearFlags, viewport: Vector4): void;
+    copyRenderTargetToSubTexture(srcRT: RenderTarget, grabTexture: Texture2D, viewport: Vector4): void;
+    activeTexture(textureID: number): void;
+    bindTexture(texture: GLTexture): void;
+    setGlobalDepthBias(bias: number, slopeBias: number): void;
+    flush(): void;
+    forceLoseDevice(): void;
+    forceRestoreDevice(): void;
+    /**
+     * @remarks
+     * WebGL context loss and restore can happen at any GPU execution point. refs to: https://www.khronos.org/webgl/wiki/HandlingContextLost
+     */
+    isContextLost(): boolean;
+    resetState(): void;
+    protected _initGLState(gl: (WebGLRenderingContext & WebGLExtension) | WebGL2RenderingContext): void;
+    destroy(): void;
+    private _onContextCreationError;
+    private _onWebGLContextLost;
+    private _onWebGLContextRestored;
+}

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export { GLCompressedTextureInternalFormat } from "./type";
+export { WebCanvas } from "./WebCanvas";
+export { WebGLEngine } from "./WebGLEngine";
+export type { WebGLEngineConfiguration } from "./WebGLEngine";
+export { WebGLMode, WebGLGraphicDevice } from "./WebGLGraphicDevice";
+export type { WebGLGraphicDeviceOptions } from "./WebGLGraphicDevice";

package/types/type.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Smoothing plug-in.
+ * */
+export interface WebGLExtension {
+    MAX_DRAW_BUFFERS: GLenum;
+    UNSIGNED_INT_24_8: GLenum;
+    MAX_SAMPLES: GLenum;
+    RGBA8: GLenum;
+    RGBA16F: GLenum;
+    RGBA32F: GLenum;
+    DEPTH_COMPONENT32F: GLenum;
+    READ_FRAMEBUFFER: GLenum;
+    DRAW_FRAMEBUFFER: GLenum;
+    createVertexArray(): WebGLVertexArrayObject | null;
+    deleteVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
+    isVertexArray(vertexArray: WebGLVertexArrayObject | null): GLboolean;
+    bindVertexArray(array: WebGLVertexArrayObject | null): void;
+    renderbufferStorageMultisample(target: GLenum, samples: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
+    blitFramebuffer(srcX0: GLint, srcY0: GLint, srcX1: GLint, srcY1: GLint, dstX0: GLint, dstY0: GLint, dstX1: GLint, dstY1: GLint, mask: GLbitfield, filter: GLenum): void;
+    drawArraysInstanced(mode: GLenum, first: GLint, count: GLsizei, instanceCount: GLsizei): void;
+    drawElementsInstanced(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr, instanceCount: GLsizei): void;
+    vertexAttribDivisor(index: GLuint, divisor: GLuint): void;
+    drawBuffers(buffers: Iterable<GLenum>): void;
+}
+export interface TextureFormatDetail {
+    internalFormat: GLint;
+    baseFormat?: GLenum;
+    dataType?: GLenum;
+    isCompressed: boolean;
+    attachment?: GLenum;
+    readFormat?: GLenum;
+    alignment?: number;
+}
+export declare enum GLCompressedTextureInternalFormat {
+    RGBA_ASTC_4X4_KHR = 37808,
+    RGBA_ASTC_5X4_KHR = 37809,
+    RGBA_ASTC_5X5_KHR = 37810,
+    RGBA_ASTC_6X5_KHR = 37811,
+    RGBA_ASTC_6X6_KHR = 37812,
+    RGBA_ASTC_8X5_KHR = 37813,
+    RGBA_ASTC_8X6_KHR = 37814,
+    RGBA_ASTC_8X8_KHR = 37815,
+    RGBA_ASTC_10X5_KHR = 37816,
+    RGBA_ASTC_10X6_KHR = 37817,
+    RGBA_ASTC_10X8_KHR = 37818,
+    RGBA_ASTC_10X10_KHR = 37819,
+    RGBA_ASTC_12X10_KHR = 37820,
+    RGBA_ASTC_12X12_KHR = 37821,
+    SRGB8_ALPHA8_ASTC_4X4_KHR = 37840,
+    SRGB8_ALPHA8_ASTC_5X4_KHR = 37841,
+    SRGB8_ALPHA8_ASTC_5X5_KHR = 37842,
+    SRGB8_ALPHA8_ASTC_6X5_KHR = 37843,
+    SRGB8_ALPHA8_ASTC_6X6_KHR = 37844,
+    SRGB8_ALPHA8_ASTC_8X5_KHR = 37845,
+    SRGB8_ALPHA8_ASTC_8X6_KHR = 37846,
+    SRGB8_ALPHA8_ASTC_8X8_KHR = 37847,
+    SRGB8_ALPHA8_ASTC_10X5_KHR = 37848,
+    SRGB8_ALPHA8_ASTC_10X6_KHR = 37849,
+    SRGB8_ALPHA8_ASTC_10X8_KHR = 37850,
+    SRGB8_ALPHA8_ASTC_10X10_KHR = 37851,
+    SRGB8_ALPHA8_ASTC_12X10_KHR = 37852,
+    SRGB8_ALPHA8_ASTC_12X12_KHR = 37853,
+    RGB_ETC1_WEBGL = 36196,
+    R11_EAC = 37488,
+    SIGNED_R11_EAC = 37489,
+    RG11_EAC = 37490,
+    SIGNED_RG11_EAC = 37491,
+    RGB8_ETC2 = 37492,
+    SRGB8_ETC2 = 37493,
+    RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 37494,
+    SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 37495,
+    RGBA8_ETC2_EAC = 37496,
+    SRGB8_ALPHA8_ETC2_EAC = 37497,
+    RGB_PVRTC_4BPPV1_IMG = 35840,
+    RGB_PVRTC_2BPPV1_IMG = 35841,
+    RGBA_PVRTC_4BPPV1_IMG = 35842,
+    RGBA_PVRTC_2BPPV1_IMG = 35843,
+    RGB_S3TC_DXT1_EXT = 33776,
+    RGBA_S3TC_DXT1_EXT = 33777,
+    RGBA_S3TC_DXT3_EXT = 33778,
+    RGBA_S3TC_DXT5_EXT = 33779,
+    SRGB_S3TC_DXT1_EXT = 35916,
+    SRGB_ALPHA_S3TC_DXT1_EXT = 35917,
+    SRGB_ALPHA_S3TC_DXT3_EXT = 35918,
+    SRGB_ALPHA_S3TC_DXT5_EXT = 35919,
+    RGBA_BPTC_UNORM_EXT = 36492,
+    SRGB_ALPHA_BPTC_UNORM_EXT = 36493,
+    RGB_BPTC_SIGNED_FLOAT_EXT = 36494,
+    RGB_BPTC_UNSIGNED_FLOAT_EXT = 36495
+}