@lightningjs/renderer 0.6.0 → 0.6.1

package/dist/src/core/lib/WebGlContextWrapper.js

@@ -0,0 +1,779 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { assertTruthy } from '../../utils.js';
+import { isWebGl2 } from '../renderers/webgl/internal/WebGlUtils.js';
+/**
+ * Optimized WebGL Context Wrapper
+ *
+ * @remarks
+ * This class contains the subset of the WebGLRenderingContext & WebGL2RenderingContext
+ * API that is used by the renderer. Select high volume WebGL methods include
+ * caching optimizations to avoid making WebGL calls if the state is already set
+ * to the desired value.
+ *
+ * While most methods contained are direct passthroughs to the WebGL context,
+ * some methods combine multiple WebGL calls into one for convenience, modify
+ * arguments to be more convenient, or are replaced by more specific methods.
+ *
+ * Not all methods are optimized. Only methods that are called frequently
+ * and/or have a high cost are optimized.
+ *
+ * A subset of GLenum constants are also exposed as properties on this class
+ * for convenience.
+ */
+export class WebGlContextWrapper {
+    gl;
+    //#region Cached WebGL State
+    activeTextureUnit = 0;
+    texture2dUnits;
+    texture2dParams = new WeakMap();
+    scissorEnabled;
+    scissorX;
+    scissorY;
+    scissorWidth;
+    scissorHeight;
+    blendEnabled;
+    blendSrcRgb;
+    blendDstRgb;
+    blendSrcAlpha;
+    blendDstAlpha;
+    boundArrayBuffer;
+    boundElementArrayBuffer;
+    curProgram;
+    programUniforms = new WeakMap();
+    //#endregion Cached WebGL State
+    //#region Canvas
+    canvas;
+    //#endregion Canvas
+    //#region WebGL Enums
+    MAX_RENDERBUFFER_SIZE;
+    MAX_TEXTURE_SIZE;
+    MAX_VIEWPORT_DIMS;
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+    MAX_TEXTURE_IMAGE_UNITS;
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+    MAX_VERTEX_ATTRIBS;
+    MAX_VARYING_VECTORS;
+    MAX_VERTEX_UNIFORM_VECTORS;
+    MAX_FRAGMENT_UNIFORM_VECTORS;
+    TEXTURE_MAG_FILTER;
+    TEXTURE_MIN_FILTER;
+    TEXTURE_WRAP_S;
+    TEXTURE_WRAP_T;
+    LINEAR;
+    CLAMP_TO_EDGE;
+    RGBA;
+    UNSIGNED_BYTE;
+    UNPACK_PREMULTIPLY_ALPHA_WEBGL;
+    FLOAT;
+    TRIANGLES;
+    UNSIGNED_SHORT;
+    ONE;
+    ONE_MINUS_SRC_ALPHA;
+    VERTEX_SHADER;
+    FRAGMENT_SHADER;
+    STATIC_DRAW;
+    COMPILE_STATUS;
+    LINK_STATUS;
+    DYNAMIC_DRAW;
+    //#endregion WebGL Enums
+    constructor(gl) {
+        this.gl = gl;
+        // The following code extracts the current state of the WebGL context
+        // to our local JavaScript cached version of it. This is so we can
+        // avoid making WebGL calls if we don't need to.
+        // We could assume that the WebGL context is in a default state, but
+        // in the future we may want to support restoring a broken WebGL context
+        // and this will help with that.
+        this.activeTextureUnit =
+            gl.getParameter(gl.ACTIVE_TEXTURE) - gl.TEXTURE0;
+        const maxTextureUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
+        // save current texture units
+        this.texture2dUnits = new Array(maxTextureUnits)
+            .fill(undefined)
+            .map((_, i) => {
+            this.activeTexture(i);
+            return gl.getParameter(gl.TEXTURE_BINDING_2D);
+        });
+        // restore active texture unit
+        this.activeTexture(this.activeTextureUnit);
+        this.scissorEnabled = gl.isEnabled(gl.SCISSOR_TEST);
+        const scissorBox = gl.getParameter(gl.SCISSOR_BOX);
+        this.scissorX = scissorBox[0];
+        this.scissorY = scissorBox[1];
+        this.scissorWidth = scissorBox[2];
+        this.scissorHeight = scissorBox[3];
+        this.blendEnabled = gl.isEnabled(gl.BLEND);
+        this.blendSrcRgb = gl.getParameter(gl.BLEND_SRC_RGB);
+        this.blendDstRgb = gl.getParameter(gl.BLEND_DST_RGB);
+        this.blendSrcAlpha = gl.getParameter(gl.BLEND_SRC_ALPHA);
+        this.blendDstAlpha = gl.getParameter(gl.BLEND_DST_ALPHA);
+        this.boundArrayBuffer = gl.getParameter(gl.ARRAY_BUFFER_BINDING);
+        this.boundElementArrayBuffer = gl.getParameter(gl.ELEMENT_ARRAY_BUFFER_BINDING);
+        this.curProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        this.canvas = gl.canvas;
+        // Extract GLenums
+        this.MAX_RENDERBUFFER_SIZE = gl.MAX_RENDERBUFFER_SIZE;
+        this.MAX_TEXTURE_SIZE = gl.MAX_TEXTURE_SIZE;
+        this.MAX_VIEWPORT_DIMS = gl.MAX_VIEWPORT_DIMS;
+        this.MAX_VERTEX_TEXTURE_IMAGE_UNITS = gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+        this.MAX_TEXTURE_IMAGE_UNITS = gl.MAX_TEXTURE_IMAGE_UNITS;
+        this.MAX_COMBINED_TEXTURE_IMAGE_UNITS = gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS;
+        this.MAX_VERTEX_ATTRIBS = gl.MAX_VERTEX_ATTRIBS;
+        this.MAX_VARYING_VECTORS = gl.MAX_VARYING_VECTORS;
+        this.MAX_VERTEX_UNIFORM_VECTORS = gl.MAX_VERTEX_UNIFORM_VECTORS;
+        this.MAX_FRAGMENT_UNIFORM_VECTORS = gl.MAX_FRAGMENT_UNIFORM_VECTORS;
+        this.TEXTURE_MAG_FILTER = gl.TEXTURE_MAG_FILTER;
+        this.TEXTURE_MIN_FILTER = gl.TEXTURE_MIN_FILTER;
+        this.TEXTURE_WRAP_S = gl.TEXTURE_WRAP_S;
+        this.TEXTURE_WRAP_T = gl.TEXTURE_WRAP_T;
+        this.LINEAR = gl.LINEAR;
+        this.CLAMP_TO_EDGE = gl.CLAMP_TO_EDGE;
+        this.RGBA = gl.RGBA;
+        this.UNSIGNED_BYTE = gl.UNSIGNED_BYTE;
+        this.UNPACK_PREMULTIPLY_ALPHA_WEBGL = gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL;
+        this.FLOAT = gl.FLOAT;
+        this.TRIANGLES = gl.TRIANGLES;
+        this.UNSIGNED_SHORT = gl.UNSIGNED_SHORT;
+        this.ONE = gl.ONE;
+        this.ONE_MINUS_SRC_ALPHA = gl.ONE_MINUS_SRC_ALPHA;
+        this.MAX_VERTEX_TEXTURE_IMAGE_UNITS = gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS;
+        this.TRIANGLES = gl.TRIANGLES;
+        this.UNSIGNED_SHORT = gl.UNSIGNED_SHORT;
+        this.VERTEX_SHADER = gl.VERTEX_SHADER;
+        this.FRAGMENT_SHADER = gl.FRAGMENT_SHADER;
+        this.STATIC_DRAW = gl.STATIC_DRAW;
+        this.COMPILE_STATUS = gl.COMPILE_STATUS;
+        this.LINK_STATUS = gl.LINK_STATUS;
+        this.DYNAMIC_DRAW = gl.DYNAMIC_DRAW;
+    }
+    /**
+     * Returns true if the WebGL context is WebGL2
+     *
+     * @returns
+     */
+    isWebGl2() {
+        return isWebGl2(this.gl);
+    }
+    /**
+     * ```
+     * gl.activeTexture(textureUnit + gl.TEXTURE0);
+     * ```
+     *
+     * @remarks
+     * **WebGL Difference**: `textureUnit` is based from 0, not `gl.TEXTURE0`.
+     *
+     * @param textureUnit
+     */
+    activeTexture(textureUnit) {
+        const { gl } = this;
+        if (this.activeTextureUnit !== textureUnit) {
+            gl.activeTexture(textureUnit + gl.TEXTURE0);
+            this.activeTextureUnit = textureUnit;
+        }
+    }
+    /**
+     * ```
+     * gl.bindTexture(gl.TEXTURE_2D, texture);
+     * ```
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     *
+     * @param texture
+     */
+    bindTexture(texture) {
+        const { gl, activeTextureUnit, texture2dUnits } = this;
+        if (texture2dUnits[activeTextureUnit] === texture) {
+            return;
+        }
+        texture2dUnits[activeTextureUnit] = texture;
+        gl.bindTexture(this.gl.TEXTURE_2D, texture);
+    }
+    _getActiveTexture() {
+        const { activeTextureUnit, texture2dUnits } = this;
+        return texture2dUnits[activeTextureUnit];
+    }
+    /**
+     * ```
+     * gl.texParameteri(gl.TEXTURE_2D, pname, param);
+     * ```
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     *
+     * @param pname
+     * @param param
+     * @returns
+     */
+    texParameteri(pname, param) {
+        const { gl, texture2dParams } = this;
+        const activeTexture = this._getActiveTexture();
+        if (!activeTexture) {
+            throw new Error('No active texture');
+        }
+        let textureParams = texture2dParams.get(activeTexture);
+        if (!textureParams) {
+            textureParams = {};
+            texture2dParams.set(activeTexture, textureParams);
+        }
+        if (textureParams[pname] === param) {
+            return;
+        }
+        textureParams[pname] = param;
+        gl.texParameteri(gl.TEXTURE_2D, pname, param);
+    }
+    texImage2D(level, internalFormat, widthOrFormat, heightOrType, borderOrSource, format, type, pixels) {
+        const { gl } = this;
+        if (format) {
+            gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, widthOrFormat, heightOrType, borderOrSource, format, type, pixels);
+        }
+        else {
+            gl.texImage2D(gl.TEXTURE_2D, level, internalFormat, widthOrFormat, heightOrType, borderOrSource);
+        }
+    }
+    /**
+     * ```
+     * gl.pixelStorei(pname, param);
+     * ```
+     *
+     * @param pname
+     * @param param
+     */
+    pixelStorei(pname, param) {
+        const { gl } = this;
+        gl.pixelStorei(pname, param);
+    }
+    /**
+     * ```
+     * gl.generateMipmap(gl.TEXTURE_2D);
+     * ```
+     *
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     */
+    generateMipmap() {
+        const { gl } = this;
+        gl.generateMipmap(gl.TEXTURE_2D);
+    }
+    /**
+     * ```
+     * gl.createTexture();
+     * ```
+     *
+     * @returns
+     */
+    createTexture() {
+        const { gl } = this;
+        return gl.createTexture();
+    }
+    /**
+     * ```
+     * gl.deleteTexture(texture);
+     * ```
+     *
+     * @param texture
+     */
+    deleteTexture(texture) {
+        const { gl } = this;
+        if (texture) {
+            this.texture2dParams.delete(texture);
+        }
+        gl.deleteTexture(texture);
+    }
+    /**
+     * ```
+     * gl.viewport(x, y, width, height);
+     * ```
+     */
+    viewport(x, y, width, height) {
+        const { gl } = this;
+        gl.viewport(x, y, width, height);
+    }
+    /**
+     * ```
+     * gl.clearColor(red, green, blue, alpha);
+     * ```
+     *
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     */
+    clearColor(red, green, blue, alpha) {
+        const { gl } = this;
+        gl.clearColor(red, green, blue, alpha);
+    }
+    /**
+     * ```
+     * gl["enable"|"disable"](gl.SCISSOR_TEST);
+     * ```
+     * @param enable
+     */
+    setScissorTest(enable) {
+        const { gl, scissorEnabled } = this;
+        if (enable === scissorEnabled) {
+            return;
+        }
+        if (enable) {
+            gl.enable(gl.SCISSOR_TEST);
+        }
+        else {
+            gl.disable(gl.SCISSOR_TEST);
+        }
+        this.scissorEnabled = enable;
+    }
+    /**
+     * ```
+     * gl.scissor(x, y, width, height);
+     * ```
+     *
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     */
+    scissor(x, y, width, height) {
+        const { gl, scissorX, scissorY, scissorWidth, scissorHeight } = this;
+        if (x !== scissorX ||
+            y !== scissorY ||
+            width !== scissorWidth ||
+            height !== scissorHeight) {
+            gl.scissor(x, y, width, height);
+            this.scissorX = x;
+            this.scissorY = y;
+            this.scissorWidth = width;
+            this.scissorHeight = height;
+        }
+    }
+    /**
+     * ```
+     * gl["enable"|"disable"](gl.BLEND);
+     * ```
+     *
+     * @param blend
+     * @returns
+     */
+    setBlend(blend) {
+        const { gl, blendEnabled } = this;
+        if (blend === blendEnabled) {
+            return;
+        }
+        if (blend) {
+            gl.enable(gl.BLEND);
+        }
+        else {
+            gl.disable(gl.BLEND);
+        }
+        this.blendEnabled = blend;
+    }
+    /**
+     * ```
+     * gl.blendFunc(src, dst);
+     * ```
+     *
+     * @param src
+     * @param dst
+     */
+    blendFunc(src, dst) {
+        const { gl, blendSrcRgb, blendDstRgb, blendSrcAlpha, blendDstAlpha } = this;
+        if (src !== blendSrcRgb ||
+            dst !== blendDstRgb ||
+            src !== blendSrcAlpha ||
+            dst !== blendDstAlpha) {
+            gl.blendFunc(src, dst);
+            this.blendSrcRgb = src;
+            this.blendDstRgb = dst;
+            this.blendSrcAlpha = src;
+            this.blendDstAlpha = dst;
+        }
+    }
+    /**
+     * ```
+     * createBuffer();
+     * ```
+     *
+     * @returns
+     */
+    createBuffer() {
+        const { gl } = this;
+        return gl.createBuffer();
+    }
+    /**
+     * ```
+     * gl.clear(gl.COLOR_BUFFER_BIT);
+     * ```
+     *
+     * @remarks
+     * **WebGL Difference**: Clear mask is always `gl.COLOR_BUFFER_BIT`
+     */
+    clear() {
+        const { gl } = this;
+        gl.clear(gl.COLOR_BUFFER_BIT);
+    }
+    /**
+     * ```
+     * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+     * gl.bufferData(gl.ARRAY_BUFFER, data, usage);
+     * ```
+     *
+     * @remarks
+     * **WebGL Combo**: `gl.bindBuffer` and `gl.bufferData` are combined into one function.
+     *
+     * @param buffer
+     * @param data
+     * @param usage
+     */
+    arrayBufferData(buffer, data, usage) {
+        const { gl, boundArrayBuffer } = this;
+        if (boundArrayBuffer !== buffer) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            this.boundArrayBuffer = buffer;
+        }
+        gl.bufferData(gl.ARRAY_BUFFER, data, usage);
+    }
+    /**
+     * ```
+     * gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+     * gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, usage);
+     * ```
+     * @remarks
+     * **WebGL Combo**: `gl.bindBuffer` and `gl.bufferData` are combined into one function.
+     *
+     * @param buffer
+     * @param data
+     * @param usage
+     */
+    elementArrayBufferData(buffer, data, usage) {
+        const { gl, boundElementArrayBuffer } = this;
+        if (boundElementArrayBuffer !== buffer) {
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+            this.boundElementArrayBuffer = buffer;
+        }
+        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, usage);
+    }
+    /**
+     * ```
+     * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+     * gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
+     * ```
+     *
+     * @remarks
+     * **WebGL Combo**: `gl.bindBuffer` and `gl.vertexAttribPointer` are combined into one function.
+     *
+     * @param buffer
+     * @param index
+     * @param size
+     * @param type
+     * @param normalized
+     * @param stride
+     * @param offset
+     */
+    vertexAttribPointer(buffer, index, size, type, normalized, stride, offset) {
+        const { gl, boundArrayBuffer } = this;
+        if (boundArrayBuffer !== buffer) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            this.boundArrayBuffer = buffer;
+        }
+        gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
+    }
+    /**
+     * ```
+     * gl.useProgram(program);
+     * ```
+     *
+     * @param program
+     * @returns
+     */
+    useProgram(program) {
+        const { gl, curProgram } = this;
+        if (curProgram === program) {
+            return;
+        }
+        gl.useProgram(program);
+        this.curProgram = program;
+    }
+    setUniform(type, location, ...args) {
+        const { gl, programUniforms } = this;
+        let uniforms = programUniforms.get(this.curProgram);
+        if (!uniforms) {
+            uniforms = new Map();
+            programUniforms.set(this.curProgram, uniforms);
+        }
+        const uniformArgs = uniforms.get(location);
+        if (!uniformArgs || !compareArrays(uniformArgs, args)) {
+            uniforms.set(location, args);
+            gl[type](location, ...args);
+        }
+    }
+    /**
+     * ```
+     * gl.getParameter(pname);
+     * ```
+     *
+     * @param pname
+     * @returns
+     */
+    getParameter(pname) {
+        const { gl } = this;
+        return gl.getParameter(pname);
+    }
+    /**
+     * ```
+     * gl.drawElements(mode, count, type, offset);
+     * ```
+     *
+     * @param mode
+     * @param count
+     * @param type
+     * @param offset
+     */
+    drawElements(mode, count, type, offset) {
+        const { gl } = this;
+        gl.drawElements(mode, count, type, offset);
+    }
+    /**
+     * ```
+     * gl.drawArrays(mode, first, count);
+     * ```
+     *
+     * @param name
+     * @returns
+     */
+    getExtension(name) {
+        const { gl } = this;
+        return gl.getExtension(name);
+    }
+    /**
+     * ```
+     * gl.createVertexArray();
+     * ```
+     *
+     * @returns
+     */
+    createVertexArray() {
+        const { gl } = this;
+        assertTruthy(gl instanceof WebGL2RenderingContext);
+        return gl.createVertexArray();
+    }
+    /**
+     * ```
+     * gl.bindVertexArray(vertexArray);
+     * ```
+     *
+     * @param vertexArray
+     */
+    bindVertexArray(vertexArray) {
+        const { gl } = this;
+        assertTruthy(gl instanceof WebGL2RenderingContext);
+        gl.bindVertexArray(vertexArray);
+    }
+    /**
+     * ```
+     * gl.getAttribLocation(program, name);
+     * ```
+     *
+     * @param program
+     * @param name
+     * @returns
+     */
+    getAttribLocation(program, name) {
+        const { gl } = this;
+        return gl.getAttribLocation(program, name);
+    }
+    /**
+     * ```
+     * gl.getUniformLocation(program, name);
+     * ```
+     *
+     * @param program
+     * @param name
+     * @returns
+     */
+    getUniformLocation(program, name) {
+        const { gl } = this;
+        return gl.getUniformLocation(program, name);
+    }
+    /**
+     * ```
+     * gl.enableVertexAttribArray(index);
+     * ```
+     *
+     * @param index
+     */
+    enableVertexAttribArray(index) {
+        const { gl } = this;
+        gl.enableVertexAttribArray(index);
+    }
+    /**
+     * ```
+     * gl.disableVertexAttribArray(index);
+     * ```
+     *
+     * @param index
+     */
+    disableVertexAttribArray(index) {
+        const { gl } = this;
+        gl.disableVertexAttribArray(index);
+    }
+    /**
+     * ```
+     * gl.createShader(type);
+     * ```
+     *
+     * @param type
+     * @returns
+     */
+    createShader(type) {
+        const { gl } = this;
+        return gl.createShader(type);
+    }
+    /**
+     * ```
+     * gl.compileShader(shader);
+     * ```
+     *
+     * @param shader
+     * @returns
+     */
+    compileShader(shader) {
+        const { gl } = this;
+        gl.compileShader(shader);
+    }
+    /**
+     * ```
+     * gl.attachShader(program, shader);
+     * ```
+     *
+     * @param program
+     * @param shader
+     */
+    attachShader(program, shader) {
+        const { gl } = this;
+        gl.attachShader(program, shader);
+    }
+    /**
+     * ```
+     * gl.linkProgram(program);
+     * ```
+     *
+     * @param program
+     */
+    linkProgram(program) {
+        const { gl } = this;
+        gl.linkProgram(program);
+    }
+    /**
+     * ```
+     * gl.deleteProgram(shader);
+     * ```
+     *
+     * @param shader
+     */
+    deleteProgram(shader) {
+        const { gl } = this;
+        gl.deleteProgram(shader);
+    }
+    /**
+     * ```
+     * gl.getShaderParameter(shader, pname);
+     * ```
+     *
+     * @param shader
+     * @param pname
+     */
+    getShaderParameter(shader, pname) {
+        const { gl } = this;
+        return gl.getShaderParameter(shader, pname);
+    }
+    /**
+     * ```
+     * gl.getShaderInfoLog(shader);
+     * ```
+     *
+     * @param shader
+     */
+    getShaderInfoLog(shader) {
+        const { gl } = this;
+        return gl.getShaderInfoLog(shader);
+    }
+    /**
+     * ```
+     * gl.createProgram();
+     * ```
+     *
+     * @returns
+     */
+    createProgram() {
+        const { gl } = this;
+        return gl.createProgram();
+    }
+    /**
+     * ```
+     * gl.getProgramParameter(program, pname);
+     * ```
+     *
+     * @param program
+     * @param pname
+     * @returns
+     */
+    getProgramParameter(program, pname) {
+        const { gl } = this;
+        return gl.getProgramParameter(program, pname);
+    }
+    /**
+     * ```
+     * gl.getProgramInfoLog(program);
+     * ```
+     *
+     * @param program
+     * @returns
+     */
+    getProgramInfoLog(program) {
+        const { gl } = this;
+        return gl.getProgramInfoLog(program);
+    }
+    /**
+     * ```
+     * gl.shaderSource(shader, source);
+     * ```
+     *
+     * @param shader
+     * @param source
+     */
+    shaderSource(shader, source) {
+        const { gl } = this;
+        gl.shaderSource(shader, source);
+    }
+    /**
+     * ```
+     * gl.deleteShader(shader);
+     * ```
+     *
+     * @param shader
+     */
+    deleteShader(shader) {
+        const { gl } = this;
+        gl.deleteShader(shader);
+    }
+}
+/**
+ *
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export function compareArrays(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return a.every((v, i) => {
+        if (Array.isArray(v)) {
+            return compareArrays(v, b[i]);
+        }
+        else {
+            return v === b[i];
+        }
+    });
+}
+//# sourceMappingURL=WebGlContextWrapper.js.map