melonjs 14.4.0 → 15.0.0

package/dist/melonjs.mjs/video/utils/resize.js

@@ -1,116 +0,0 @@
-/*!
- * melonJS Game Engine - v14.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
- */
-import { getParentBounds, devicePixelRatio } from '../../system/device.js';
-import game from '../../game.js';
-
-/**
- * scale the "displayed" canvas by the given scalar.
- * this will modify the size of canvas element directly.
- * Only use this if you are not using the automatic scaling feature.
- * @param {number} x - x scaling multiplier
- * @param {number} y - y scaling multiplier
- */
-function scale(renderer, x, y) {
-    var canvas = renderer.getCanvas();
-    var context = renderer.getContext();
-    var settings = renderer.settings;
-    var pixelRatio = devicePixelRatio;
-
-    var w = settings.zoomX = canvas.width * x * pixelRatio;
-    var h = settings.zoomY = canvas.height * y * pixelRatio;
-
-    // update the global scale variable
-    renderer.scaleRatio.set(x * pixelRatio, y * pixelRatio);
-
-    // adjust CSS style based on device pixel ratio
-    canvas.style.width = (w / pixelRatio) + "px";
-    canvas.style.height = (h / pixelRatio) + "px";
-
-    // if anti-alias and blend mode were resetted (e.g. Canvas mode)
-    renderer.setAntiAlias(context, settings.antiAlias);
-    renderer.setBlendMode(settings.blendMode, context);
-
-    // force repaint
-    game.repaint();
-}
-
-/**
- * callback for window resize event
- */
-function onresize(renderer) {
-    var settings = renderer.settings;
-    var scaleX = 1, scaleY = 1;
-
-    if (settings.autoScale) {
-
-        // set max the canvas max size if CSS values are defined
-        var canvasMaxWidth = Infinity;
-        var canvasMaxHeight = Infinity;
-
-        if (globalThis.getComputedStyle) {
-            var style = globalThis.getComputedStyle(renderer.getCanvas(), null);
-            canvasMaxWidth = parseInt(style.maxWidth, 10) || Infinity;
-            canvasMaxHeight = parseInt(style.maxHeight, 10) || Infinity;
-        }
-
-        // get the maximum canvas size within the parent div containing the canvas container
-        var nodeBounds = getParentBounds(game.getParentElement());
-
-        var _max_width = Math.min(canvasMaxWidth, nodeBounds.width);
-        var _max_height = Math.min(canvasMaxHeight, nodeBounds.height);
-
-        // calculate final canvas width & height
-        var screenRatio = _max_width / _max_height;
-
-        if ((settings.scaleMethod === "fill-min" && screenRatio > renderer.designRatio) ||
-            (settings.scaleMethod === "fill-max" && screenRatio < renderer.designRatio) ||
-            (settings.scaleMethod === "flex-width")
-        ) {
-            // resize the display canvas to fill the parent container
-            var sWidth = Math.min(canvasMaxWidth, settings.height * screenRatio);
-            scaleX = scaleY = _max_width / sWidth;
-            renderer.resize(Math.floor(sWidth), settings.height);
-        }
-        else if ((settings.scaleMethod === "fill-min" && screenRatio < renderer.designRatio) ||
-                 (settings.scaleMethod === "fill-max" && screenRatio > renderer.designRatio) ||
-                 (settings.scaleMethod === "flex-height")
-        ) {
-            // resize the display canvas to fill the parent container
-            var sHeight = Math.min(canvasMaxHeight, settings.width * (_max_height / _max_width));
-            scaleX = scaleY = _max_height / sHeight;
-            renderer.resize(settings.width, Math.floor(sHeight));
-        }
-        else if (settings.scaleMethod === "flex") {
-            // resize the display canvas to fill the parent container
-            renderer.resize(Math.floor(_max_width), Math.floor(_max_height));
-        }
-        else if (settings.scaleMethod === "stretch") {
-            // scale the display canvas to fit with the parent container
-            scaleX = _max_width / settings.width;
-            scaleY = _max_height / settings.height;
-        }
-        else {
-            // scale the display canvas to fit the parent container
-            // make sure we maintain the original aspect ratio
-            if (screenRatio < renderer.designRatio) {
-                scaleX = scaleY = _max_width / settings.width;
-            }
-            else {
-                scaleX = scaleY = _max_height / settings.height;
-            }
-        }
-
-        // adjust scaling ratio based on the new scaling ratio
-        scale(renderer, scaleX, scaleY);
-    } else {
-        // adjust scaling ratio based on the given settings
-        scale(renderer, settings.scale, settings.scale);
-    }
-}
-
-export { onresize };

package/src/polyfill/performance.js

@@ -1,20 +0,0 @@
-if ("performance" in globalThis === false) {
-    globalThis.performance = {};
-}
-
-Date.now = (Date.now || function () {  // thanks IE8
-    return new Date().getTime();
-});
-
-if ("now" in globalThis.performance === false) {
-
-    let nowOffset = Date.now();
-
-    if (performance.timing && performance.timing.navigationStart) {
-      nowOffset = performance.timing.navigationStart;
-    }
-
-    globalThis.performance.now = function now() {
-      return Date.now() - nowOffset;
-  };
-}

package/src/polyfill/requestAnimationFrame.js

@@ -1,39 +0,0 @@
-import timer from "./../system/timer.js";
-
-var lastTime = 0;
-var vendors = ["ms", "moz", "webkit", "o"];
-var x;
-
-// standardized functions
-// https://developer.mozilla.org/fr/docs/Web/API/Window/requestAnimationFrame
-var requestAnimationFrame = globalThis.requestAnimationFrame;
-var cancelAnimationFrame = globalThis.cancelAnimationFrame;
-
-// get prefixed rAF and cAF is standard one not supported
-for (x = 0; x < vendors.length && !requestAnimationFrame; ++x) {
-    requestAnimationFrame = globalThis[vendors[x] + "RequestAnimationFrame"];
-}
-for (x = 0; x < vendors.length && !cancelAnimationFrame; ++x) {
-    cancelAnimationFrame = globalThis[vendors[x] + "CancelAnimationFrame"] ||
-                           globalThis[vendors[x] + "CancelRequestAnimationFrame"];
-}
-
-if (!requestAnimationFrame || !cancelAnimationFrame) {
-    requestAnimationFrame = function (callback) {
-        var currTime = globalThis.performance.now();
-        var timeToCall = Math.max(0, (1000 / timer.maxfps) - (currTime - lastTime));
-        var id = globalThis.setTimeout(() => {
-            callback(currTime + timeToCall);
-        }, timeToCall);
-        lastTime = currTime + timeToCall;
-        return id;
-    };
-
-    cancelAnimationFrame = function (id) {
-        globalThis.clearTimeout(id);
-    };
-
-    // put back in global namespace
-    globalThis.requestAnimationFrame = requestAnimationFrame;
-    globalThis.cancelAnimationFrame = cancelAnimationFrame;
-}

package/src/video/webgl/webgl_compositor.js

@@ -1,486 +0,0 @@
-import Vector2d from "./../../math/vector2.js";
-import GLShader from "./glshader.js";
-import VertexArrayBuffer from "./buffer/vertex.js";
-import * as event from "./../../system/event.js";
-import { isPowerOfTwo } from "./../../math/math.js";
-
-import primitiveVertex from "./shaders/primitive.vert";
-import primitiveFragment from "./shaders/primitive.frag";
-import quadVertex from "./shaders/quad.vert";
-import quadFragment from "./shaders/quad.frag";
-
-// a pool of resuable vectors
-var V_ARRAY = [
-    new Vector2d(),
-    new Vector2d(),
-    new Vector2d(),
-    new Vector2d()
-];
-
-/**
- * @classdesc
- * A WebGL Compositor object. This class handles all of the WebGL state<br>
- * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
- */
- export default class WebGLCompositor {
-    /**
-     * @param {WebGLRenderer} renderer - the current WebGL renderer session
-     */
-    constructor (renderer) {
-        this.init(renderer);
-    }
-
-    /**
-     * Initialize the compositor
-     * @ignore
-     */
-    init (renderer) {
-        // local reference
-        var gl = renderer.gl;
-
-        // list of active texture units
-        this.currentTextureUnit = -1;
-        this.boundTextures = [];
-
-        // the associated renderer
-        this.renderer = renderer;
-
-        // WebGL context
-        this.gl = renderer.gl;
-
-        // Global fill color
-        this.color = renderer.currentColor;
-
-        // Global transformation matrix
-        this.viewMatrix = renderer.currentTransform;
-
-        /**
-         * a reference to the active WebGL shader
-         * @type {GLShader}
-         */
-        this.activeShader = null;
-
-        /**
-         * primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
-         * @type {number}
-         * @default gl.TRIANGLES
-         */
-        this.mode = gl.TRIANGLES;
-
-        /**
-         * an array of vertex attribute properties
-         * @see WebGLCompositor.addAttribute
-         * @type {Array}
-         */
-        this.attributes = [];
-
-        /**
-         * the size of a single vertex in bytes
-         * (will automatically be calculated as attributes definitions are added)
-         * @see WebGLCompositor.addAttribute
-         * @type {number}
-         */
-        this.vertexByteSize = 0;
-
-        /**
-         * the size of a single vertex in floats
-         * (will automatically be calculated as attributes definitions are added)
-         * @see WebGLCompositor.addAttribute
-         * @type {number}
-         */
-        this.vertexSize = 0;
-
-        // Load and create shader programs
-        this.primitiveShader = new GLShader(this.gl, primitiveVertex, primitiveFragment);
-        this.quadShader = new GLShader(this.gl, quadVertex, quadFragment);
-
-        /// define all vertex attributes
-        this.addAttribute("aVertex", 2, gl.FLOAT, false, 0 * Float32Array.BYTES_PER_ELEMENT); // 0
-        this.addAttribute("aRegion", 2, gl.FLOAT, false, 2 * Float32Array.BYTES_PER_ELEMENT); // 1
-        this.addAttribute("aColor",  4, gl.UNSIGNED_BYTE, true, 4 * Float32Array.BYTES_PER_ELEMENT); // 2
-
-        this.vertexBuffer = new VertexArrayBuffer(this.vertexSize, 6); // 6 vertices per quad
-
-        // vertex buffer
-        gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
-        gl.bufferData(gl.ARRAY_BUFFER, this.vertexBuffer.buffer, gl.STREAM_DRAW);
-
-        // register to the CANVAS resize channel
-        event.on(event.CANVAS_ONRESIZE, (width, height) => {
-            this.flush();
-            this.setViewport(0, 0, width, height);
-        });
-    }
-
-    /**
-     * Reset compositor internal state
-     * @ignore
-     */
-    reset() {
-        // WebGL context
-        this.gl = this.renderer.gl;
-
-        this.flush();
-
-        // initial viewport size
-        this.setViewport(
-            0, 0,
-            this.renderer.getCanvas().width,
-            this.renderer.getCanvas().height
-        );
-
-        // Initialize clear color
-        this.clearColor(0.0, 0.0, 0.0, 0.0);
-
-        // delete all related bound texture
-        for (var i = 0; i < this.renderer.maxTextures; i++) {
-            var texture2D = this.getTexture2D(i);
-            if (typeof texture2D !== "undefined") {
-                this.deleteTexture2D(texture2D);
-            }
-        }
-        this.currentTextureUnit = -1;
-
-        // set the quad shader as the default program
-        this.useShader(this.quadShader);
-    }
-
-    /**
-     * add vertex attribute property definition to the compositor
-     * @param {string} name - name of the attribute in the vertex shader
-     * @param {number} size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
-     * @param {GLenum} type - data type of each component in the array
-     * @param {boolean} normalized - whether integer data values should be normalized into a certain range when being cast to a float
-     * @param {number} offset - offset in bytes of the first component in the vertex attribute array
-     */
-    addAttribute(name, size, type, normalized, offset) {
-        this.attributes.push({
-            name: name,
-            size: size,
-            type: type,
-            normalized: normalized,
-            offset: offset
-        });
-
-        switch (type) {
-            case this.gl.BYTE:
-                this.vertexByteSize += size * Int8Array.BYTES_PER_ELEMENT;
-                break;
-            case this.gl.UNSIGNED_BYTE:
-                this.vertexByteSize += size * Uint8Array.BYTES_PER_ELEMENT;
-                break;
-            case this.gl.SHORT:
-                this.vertexByteSize += size * Int16Array.BYTES_PER_ELEMENT;
-                break;
-            case this.gl.UNSIGNED_SHORT:
-                this.vertexByteSize += size * Uint16Array.BYTES_PER_ELEMENT;
-                break;
-            case this.gl.INT:
-                this.vertexByteSize += size * Int32Array.BYTES_PER_ELEMENT;
-                break;
-            case this.gl.UNSIGNED_INT:
-                this.vertexByteSize += size * Uint32Array.BYTES_PER_ELEMENT;
-                break;
-            case this.gl.FLOAT:
-                this.vertexByteSize += size * Float32Array.BYTES_PER_ELEMENT;
-                break;
-            default:
-                throw new Error("Invalid GL Attribute type");
-        }
-        this.vertexSize = this.vertexByteSize / Float32Array.BYTES_PER_ELEMENT;
-    }
-
-    /**
-     * Sets the viewport
-     * @param {number} x - x position of viewport
-     * @param {number} y - y position of viewport
-     * @param {number} w - width of viewport
-     * @param {number} h - height of viewport
-     */
-    setViewport(x, y, w, h) {
-        this.gl.viewport(x, y, w, h);
-    }
-
-    /**
-     * Create a WebGL texture from an image
-     * @param {number} unit - Destination texture unit
-     * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} image - Source image
-     * @param {number} filter - gl.LINEAR or gl.NEAREST
-     * @param {string} [repeat="no-repeat"] - Image repeat behavior (see {@link ImageLayer#repeat})
-     * @param {number} [w] - Source image width (Only use with UInt8Array[] or Float32Array[] source image)
-     * @param {number} [h] - Source image height (Only use with UInt8Array[] or Float32Array[] source image)
-     * @param {number} [b] - Source image border (Only use with UInt8Array[] or Float32Array[] source image)
-     * @param {boolean} [premultipliedAlpha=true] - Multiplies the alpha channel into the other color channels
-     * @param {boolean} [mipmap=true] - Whether mipmap levels should be generated for this texture
-     * @returns {WebGLTexture} a WebGL texture
-     */
-    createTexture2D(unit, image, filter, repeat = "no-repeat", w, h, b, premultipliedAlpha = true, mipmap = true) {
-        var gl = this.gl;
-        var isPOT = isPowerOfTwo(w || image.width) && isPowerOfTwo(h || image.height);
-        var texture = gl.createTexture();
-        var rs = (repeat.search(/^repeat(-x)?$/) === 0) && (isPOT || this.renderer.WebGLVersion > 1) ? gl.REPEAT : gl.CLAMP_TO_EDGE;
-        var rt = (repeat.search(/^repeat(-y)?$/) === 0) && (isPOT || this.renderer.WebGLVersion > 1) ? gl.REPEAT : gl.CLAMP_TO_EDGE;
-
-        this.bindTexture2D(texture, unit);
-
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, rs);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, rt);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultipliedAlpha);
-        if (w || h || b) {
-            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, w, h, b, gl.RGBA, gl.UNSIGNED_BYTE, image);
-        }
-        else {
-            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
-        }
-
-        // generate the sprite mimap (used when scaling) if a PowerOfTwo texture
-        if (isPOT && mipmap !== false) {
-            gl.generateMipmap(gl.TEXTURE_2D);
-        }
-
-        return texture;
-    }
-
-    /**
-     * delete the given WebGL texture
-     * @param {WebGLTexture} [texture] - a WebGL texture to delete
-     * @param {number} [unit] - Texture unit to delete
-     */
-    deleteTexture2D(texture) {
-        this.gl.deleteTexture(texture);
-        this.unbindTexture2D(texture);
-    }
-
-    /**
-     * returns the WebGL texture associated to the given texture unit
-     * @param {number} unit - Texture unit to which a texture is bound
-     * @returns {WebGLTexture} texture a WebGL texture
-     */
-    getTexture2D(unit) {
-        return this.boundTextures[unit];
-    }
-
-    /**
-     * assign the given WebGL texture to the current batch
-     * @param {WebGLTexture} texture - a WebGL texture
-     * @param {number} unit - Texture unit to which the given texture is bound
-     */
-    bindTexture2D(texture, unit) {
-        var gl = this.gl;
-
-        if (texture !== this.boundTextures[unit]) {
-            this.flush();
-            if (this.currentTextureUnit !== unit) {
-                this.currentTextureUnit = unit;
-                gl.activeTexture(gl.TEXTURE0 + unit);
-            }
-
-            gl.bindTexture(gl.TEXTURE_2D, texture);
-            this.boundTextures[unit] = texture;
-
-        } else if (this.currentTextureUnit !== unit) {
-            this.flush();
-            this.currentTextureUnit = unit;
-            gl.activeTexture(gl.TEXTURE0 + unit);
-        }
-    }
-
-    /**
-     * unbind the given WebGL texture, forcing it to be reuploaded
-     * @param {WebGLTexture} [texture] - a WebGL texture
-     * @param {number} [unit] - a WebGL texture
-     * @returns {number} unit the unit number that was associated with the given texture
-     */
-    unbindTexture2D(texture, unit) {
-        if (typeof unit === "undefined") {
-            unit = this.boundTextures.indexOf(texture);
-        }
-        if (unit !== -1) {
-            delete this.boundTextures[unit];
-            if (unit === this.currentTextureUnit) {
-                this.currentTextureUnit = -1;
-            }
-        }
-        return unit;
-    }
-
-    /**
-     * @ignore
-     */
-    uploadTexture(texture, w, h, b, force = false) {
-        var unit = this.renderer.cache.getUnit(texture);
-        var texture2D = this.boundTextures[unit];
-
-        if (typeof texture2D === "undefined" || force) {
-            this.createTexture2D(
-                unit,
-                texture.getTexture(),
-                this.renderer.settings.antiAlias ? this.gl.LINEAR : this.gl.NEAREST,
-                texture.repeat,
-                w,
-                h,
-                b,
-                texture.premultipliedAlpha
-            );
-        } else {
-            this.bindTexture2D(texture2D, unit);
-        }
-
-        return this.currentTextureUnit;
-    }
-
-    /**
-     * set/change the current projection matrix
-     * @param {Matrix3d} matrix
-     */
-    setProjection(matrix) {
-        this.activeShader.setUniform("uProjectionMatrix", matrix);
-    }
-
-    /**
-     * Select the shader to use for compositing
-     * @see GLShader
-     * @param {GLShader} shader - a reference to a GLShader instance
-     */
-    useShader(shader) {
-        if (this.activeShader !== shader) {
-            this.flush();
-            this.activeShader = shader;
-            this.activeShader.bind();
-            this.activeShader.setUniform("uProjectionMatrix", this.renderer.projectionMatrix);
-            this.activeShader.setVertexAttributes(this.gl, this.attributes, this.vertexByteSize);
-        }
-    }
-
-    /**
-     * Add a textured quad
-     * @param {TextureAtlas} texture - Source texture atlas
-     * @param {number} x - Destination x-coordinate
-     * @param {number} y - Destination y-coordinate
-     * @param {number} w - Destination width
-     * @param {number} h - Destination height
-     * @param {number} u0 - Texture UV (u0) value.
-     * @param {number} v0 - Texture UV (v0) value.
-     * @param {number} u1 - Texture UV (u1) value.
-     * @param {number} v1 - Texture UV (v1) value.
-     * @param {number} tint - tint color to be applied to the texture in UINT32 (argb) format
-     */
-    addQuad(texture, x, y, w, h, u0, v0, u1, v1, tint) {
-
-        if (this.color.alpha < 1 / 255) {
-            // Fast path: don't send fully transparent quads
-            return;
-        }
-
-        this.useShader(this.quadShader);
-
-        if (this.vertexBuffer.isFull(6)) {
-            // is the vertex buffer full if we add 6 more vertices
-            this.flush();
-        }
-
-        // upload and activate the texture if necessary
-        var unit = this.uploadTexture(texture);
-        // set fragement sampler accordingly
-        this.quadShader.setUniform("uSampler", unit);
-
-        // Transform vertices
-        var m = this.viewMatrix,
-            vec0 = V_ARRAY[0].set(x, y),
-            vec1 = V_ARRAY[1].set(x + w, y),
-            vec2 = V_ARRAY[2].set(x, y + h),
-            vec3 = V_ARRAY[3].set(x + w, y + h);
-
-        if (!m.isIdentity()) {
-            m.apply(vec0);
-            m.apply(vec1);
-            m.apply(vec2);
-            m.apply(vec3);
-        }
-
-        this.vertexBuffer.push(vec0.x, vec0.y, u0, v0, tint);
-        this.vertexBuffer.push(vec1.x, vec1.y, u1, v0, tint);
-        this.vertexBuffer.push(vec2.x, vec2.y, u0, v1, tint);
-        this.vertexBuffer.push(vec2.x, vec2.y, u0, v1, tint);
-        this.vertexBuffer.push(vec1.x, vec1.y, u1, v0, tint);
-        this.vertexBuffer.push(vec3.x, vec3.y, u1, v1, tint);
-    }
-
-    /**
-     * Flush batched texture operations to the GPU
-     * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
-     */
-    flush(mode = this.mode) {
-        var vertex = this.vertexBuffer;
-        var vertexCount = vertex.vertexCount;
-
-        if (vertexCount > 0) {
-            var gl = this.gl;
-            var vertexSize = vertex.vertexSize;
-
-            // Copy data into stream buffer
-            if (this.renderer.WebGLVersion > 1) {
-                gl.bufferData(gl.ARRAY_BUFFER, vertex.toFloat32(), gl.STREAM_DRAW, 0, vertexCount * vertexSize);
-            } else {
-                gl.bufferData(gl.ARRAY_BUFFER, vertex.toFloat32(0, vertexCount * vertexSize), gl.STREAM_DRAW);
-            }
-
-            gl.drawArrays(mode, 0, vertexCount);
-
-            // clear the vertex buffer
-            vertex.clear();
-        }
-    }
-
-    /**
-     * Draw an array of vertices
-     * @param {GLenum} mode - primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
-     * @param {Vector2d[]} verts - vertices
-     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
-     */
-    drawVertices(mode, verts, vertexCount = verts.length) {
-        // use the primitive shader
-        this.useShader(this.primitiveShader);
-        // Set the line color
-        this.primitiveShader.setUniform("uColor", this.color);
-
-        var m = this.viewMatrix;
-        var vertex = this.vertexBuffer;
-        var m_isIdentity = m.isIdentity();
-
-        for (var i = 0; i < vertexCount; i++) {
-            if (!m_isIdentity) {
-                m.apply(verts[i]);
-            }
-            vertex.push(verts[i].x, verts[i].y);
-        }
-
-        // flush
-        this.flush(mode);
-    }
-
-    /**
-     * Clear the frame buffer
-     * @param {number} [alpha = 0.0] - the alpha value used when clearing the framebuffer
-     */
-    clear(alpha = 0) {
-        var gl = this.gl;
-        gl.clearColor(0, 0, 0, alpha);
-        gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
-    }
-
-    /**
-     * Specify the color values used when clearing color buffers. The values are clamped between 0 and 1.
-     * @param {number} [r = 0] - the red color value used when the color buffers are cleared
-     * @param {number} [g = 0] - the green color value used when the color buffers are cleared
-     * @param {number} [b = 0] - the blue color value used when the color buffers are cleared
-     * @param {number} [a = 0] - the alpha color value used when the color buffers are cleared
-     */
-    clearColor(r = 0, g = 0, b = 0, a = 0) {
-        var gl = this.gl;
-        gl.clearColor(r, g, b, a);
-        gl.clear(gl.COLOR_BUFFER_BIT);
-    }
-}