melonjs 14.5.0 → 15.0.0

package/dist/melonjs.mjs/video/webgl/compositors/compositor.js

@@ -1,11 +1,12 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
  * @copyright (C) 2011 - 2023 Olivier Biot (AltByte Pte Ltd)
  */
-import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
+import VertexArrayBuffer from '../buffer/vertex.js';
+import GLShader from '../glshader.js';
 
 /**
  * @classdesc
@@ -14,19 +15,26 @@ import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
  class Compositor {
     /**
      * @param {WebGLRenderer} renderer - the current WebGL renderer session
+     * @param {Object} settings - additional settings to initialize this compositors
+     * @param {object[]} attribute - an array of attributes definition
+     * @param {string} attribute.name - name of the attribute in the vertex shader
+     * @param {number} attribute.size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
+     * @param {GLenum} attribute.type - data type of each component in the array
+     * @param {boolean} attribute.normalized - whether integer data values should be normalized into a certain range when being cast to a float
+     * @param {number} attribute.offset - offset in bytes of the first component in the vertex attribute array
+     * @param {object} shader - an array of attributes definition
+     * @param {string} shader.vertex - a string containing the GLSL source code to set
+     * @param {string} shader.fragment - a string containing the GLSL source code to set
      */
-    constructor (renderer) {
-        this.init(renderer);
+    constructor (renderer, settings) {
+        this.init(renderer, settings);
     }
 
     /**
      * Initialize the compositor
      * @ignore
      */
-    init (renderer) {
-        // local reference
-        var gl = renderer.gl;
-
+    init (renderer, settings) {
         // the associated renderer
         this.renderer = renderer;
 
@@ -40,17 +48,23 @@ import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
         this.viewMatrix = renderer.currentTransform;
 
         /**
-         * a reference to the active WebGL shader
+         * the default shader created by this compositor
          * @type {GLShader}
          */
-        this.activeShader = null;
+        this.defaultShader = undefined;
+
+        /**
+         * the shader currently used by this compositor
+         * @type {GLShader}
+         */
+        this.currentShader = undefined;
 
         /**
          * 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;
+        this.mode = this.gl.TRIANGLES;
 
         /**
          * an array of vertex attribute properties
@@ -75,11 +89,28 @@ import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
          */
         this.vertexSize = 0;
 
-        // register to the CANVAS resize channel
-        on(CANVAS_ONRESIZE, (width, height) => {
-            this.flush();
-            this.setViewport(0, 0, width, height);
-        });
+        /**
+         * the vertex data buffer used by this compositor
+         * @type {VertexArrayBuffer}
+         */
+        this.vertexData = null;
+
+        // parse given attibrutes
+        if (typeof settings !== "undefined" && Array.isArray(settings.attributes)) {
+            settings.attributes.forEach((attr) => {
+                this.addAttribute(attr.name, attr.size, attr.type, attr.normalized, attr.offset);
+                this.vertexData = new VertexArrayBuffer(this.vertexSize, 6);
+            });
+        } else {
+            throw new Error("attributes definition missing");
+        }
+
+        // parse and instantiate the default shader
+        if (typeof settings !== "undefined" && typeof settings.shader !== "undefined") {
+            this.defaultShader = new GLShader(this.gl, settings.shader.vertex, settings.shader.fragment);
+        } else {
+            throw new Error("shader definition missing");
+        }
     }
 
     /**
@@ -90,17 +121,35 @@ import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
         // WebGL context
         this.gl = this.renderer.gl;
 
-        this.flush();
+        // clear the vertex data buffer
+        this.vertexData.clear();
+    }
 
-        // initial viewport size
-        this.setViewport(
-            0, 0,
-            this.renderer.getCanvas().width,
-            this.renderer.getCanvas().height
-        );
+    /**
+     * @ignore
+     * called by the WebGL renderer when a compositor become the current one
+     */
+    bind() {
+        if (this.renderer.currentProgram !== this.defaultShader.program) {
+            this.useShader(this.defaultShader);
+        }
+    }
 
-        // Initialize clear color
-        this.clearColor(0.0, 0.0, 0.0, 0.0);
+    /**
+     * Select the shader to use for compositing
+     * @see GLShader
+     * @param {GLShader} shader - a reference to a GLShader instance
+     */
+    useShader(shader) {
+        if (this.renderer.currentProgram !== shader.program) {
+            this.flush();
+            shader.bind();
+            shader.setUniform("uProjectionMatrix", this.renderer.projectionMatrix);
+            shader.setVertexAttributes(this.gl, this.attributes, this.vertexByteSize);
+
+            this.currentShader = shader;
+            this.renderer.currentProgram = this.currentShader.program;
+        }
     }
 
     /**
@@ -148,46 +197,20 @@ import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
         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);
-    }
-
     /**
      * 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);
-        }
+        this.currentShader.setUniform("uProjectionMatrix", matrix);
     }
 
     /**
-     * Flush batched texture operations to the GPU
+     * Flush batched vertex data to the GPU
      * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
      */
     flush(mode = this.mode) {
-        var vertex = this.vertexBuffer;
+        var vertex = this.vertexData;
         var vertexCount = vertex.vertexCount;
 
         if (vertexCount > 0) {
@@ -207,29 +230,6 @@ import { on, CANVAS_ONRESIZE } from '../../../system/event.js';
             vertex.clear();
         }
     }
-
-    /**
-     * 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);
-    }
 }
 
 export { Compositor as default };

package/dist/melonjs.mjs/video/webgl/compositors/primitive_compositor.js

@@ -0,0 +1,77 @@
+/*!
+ * melonJS Game Engine - v15.0.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2023 Olivier Biot (AltByte Pte Ltd)
+ */
+import primitiveVertex from '../shaders/primitive.vert.js';
+import primitiveFragment from '../shaders/primitive.frag.js';
+import Compositor from './compositor.js';
+
+/**
+ * @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
+ * @augments Compositor
+ */
+ class PrimitiveCompositor extends Compositor {
+
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init(renderer) {
+        super.init(renderer, {
+            attributes: [
+                {name: "aVertex", size: 2, type: renderer.gl.FLOAT, normalized: false, offset: 0 * Float32Array.BYTES_PER_ELEMENT},
+                {name: "aColor",  size: 4, type: renderer.gl.UNSIGNED_BYTE, normalized: true, offset: 2 * Float32Array.BYTES_PER_ELEMENT}
+            ],
+            shader: {
+                vertex: primitiveVertex, fragment: primitiveFragment
+            }
+        });
+    }
+
+    /**
+     * 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 {Point[]} verts - an array of vertices
+     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
+     */
+    drawVertices(mode, verts, vertexCount = verts.length) {
+        var viewMatrix = this.viewMatrix;
+        var vertexData = this.vertexData;
+        var color = this.renderer.currentColor;
+        var alpha = this.renderer.getGlobalAlpha();
+
+        if (vertexData.isFull(vertexCount)) {
+            // is the vertex buffer full if we add more vertices
+            this.flush();
+        }
+
+        // flush if drawing vertices with a different drawing mode
+        if (mode !== this.mode) {
+            this.flush(this.mode);
+            this.mode = mode;
+        }
+
+        if (!viewMatrix.isIdentity()) {
+            verts.forEach((vert) => {
+                viewMatrix.apply(vert);
+                vertexData.push(vert.x, vert.y, undefined, undefined, color.toUint32(alpha));
+            });
+        } else {
+            verts.forEach((vert) => {
+                vertexData.push(vert.x, vert.y, undefined, undefined, color.toUint32(alpha));
+            });
+        }
+
+        // force flush for primitive using LINE_STRIP or LINE_LOOP
+        if (this.mode === this.gl.LINE_STRIP || this.mode === this.gl.LINE_LOOP) {
+            this.flush(this.mode);
+        }
+    }
+}
+
+export { PrimitiveCompositor as default };

package/dist/melonjs.mjs/video/webgl/compositors/quad_compositor.js

@@ -0,0 +1,249 @@
+/*!
+ * melonJS Game Engine - v15.0.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2023 Olivier Biot (AltByte Pte Ltd)
+ */
+import Vector2d from '../../../math/vector2.js';
+import { isPowerOfTwo } from '../../../math/math.js';
+import quadVertex from '../shaders/quad.vert.js';
+import quadFragment from '../shaders/quad.frag.js';
+import Compositor from './compositor.js';
+
+// 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
+ * @augments Compositor
+ */
+ class QuadCompositor extends Compositor {
+
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init (renderer) {
+        super.init(renderer, {
+            attributes: [
+                {name: "aVertex", size: 2, type: renderer.gl.FLOAT, normalized: false, offset: 0 * Float32Array.BYTES_PER_ELEMENT},
+                {name: "aRegion", size: 2, type: renderer.gl.FLOAT, normalized: false, offset: 2 * Float32Array.BYTES_PER_ELEMENT},
+                {name: "aColor",  size: 4, type: renderer.gl.UNSIGNED_BYTE, normalized: true, offset: 4 * Float32Array.BYTES_PER_ELEMENT}
+            ],
+            shader: {
+                vertex: quadVertex, fragment: quadFragment
+            }
+        });
+
+        // list of active texture units
+        this.currentTextureUnit = -1;
+        this.boundTextures = [];
+    }
+
+    /**
+     * Reset compositor internal state
+     * @ignore
+     */
+    reset() {
+        super.reset();
+
+        // 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;
+    }
+
+    /**
+     * Create a WebGL texture from an image
+     * @param {number} unit - Destination texture unit
+     * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} [pixels=null] - 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=pixels.width] - Source image width (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [h=pixels.height] - Source image height (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, pixels = null, filter, repeat = "no-repeat", w = pixels.width, h = pixels.height, premultipliedAlpha = true, mipmap = true) {
+        var gl = this.gl;
+        var isPOT = isPowerOfTwo(w) && isPowerOfTwo(h);
+        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;
+
+        var texture = gl.createTexture();
+
+        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 (pixels === null || typeof pixels.byteLength !== "undefined") {
+            // if pixels is undefined, or if it's Uint8Array/Float32Array TypedArray
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, w, h, 0, gl.RGBA, gl.UNSIGNED_BYTE, pixels, 0);
+        } else {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+        }
+
+        // generate the sprite mimap (used when scaling) if a PowerOfTwo texture
+        if (isPOT && mipmap === true) {
+            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, 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,
+                texture.premultipliedAlpha
+            );
+        } else {
+            this.bindTexture2D(texture2D, unit);
+        }
+
+        return this.currentTextureUnit;
+    }
+
+    /**
+     * 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) {
+        var vertexData = this.vertexData;
+
+        if (vertexData.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 fragment sampler accordingly
+        this.currentShader.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);
+        }
+
+        vertexData.push(vec0.x, vec0.y, u0, v0, tint);
+        vertexData.push(vec1.x, vec1.y, u1, v0, tint);
+        vertexData.push(vec2.x, vec2.y, u0, v1, tint);
+        vertexData.push(vec2.x, vec2.y, u0, v1, tint);
+        vertexData.push(vec1.x, vec1.y, u1, v0, tint);
+        vertexData.push(vec3.x, vec3.y, u1, v1, tint);
+    }
+}
+
+export { QuadCompositor as default };

package/dist/melonjs.mjs/video/webgl/compositors/webgl_compositor.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/glshader.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/shaders/primitive.frag.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/shaders/primitive.vert.js

@@ -1,10 +1,10 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
  * @copyright (C) 2011 - 2023 Olivier Biot (AltByte Pte Ltd)
  */
-var primitiveVertex = "// Current vertex point\nattribute vec2 aVertex;\n\n// Projection matrix\nuniform mat4 uProjectionMatrix;\n\n// Vertex color\nuniform vec4 uColor;\n\n// Fragment color\nvarying vec4 vColor;\n\nvoid main(void) {\n    // Transform the vertex position by the projection matrix\n    gl_Position = uProjectionMatrix * vec4(aVertex, 0.0, 1.0);\n    // Pass the remaining attributes to the fragment shader\n    vColor = vec4(uColor.rgb * uColor.a, uColor.a);\n}\n";
+var primitiveVertex = "// Current vertex point\nattribute vec2 aVertex;\nattribute vec4 aColor;\n\n// Projection matrix\nuniform mat4 uProjectionMatrix;\n\nvarying vec4 vColor;\n\nvoid main(void) {\n    // Transform the vertex position by the projection matrix\n    gl_Position = uProjectionMatrix * vec4(aVertex, 0.0, 1.0);\n    // Pass the remaining attributes to the fragment shader\n    vColor = vec4(aColor.bgr * aColor.a, aColor.a);\n}\n";
 
 export { primitiveVertex as default };

package/dist/melonjs.mjs/video/webgl/shaders/quad.frag.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/shaders/quad.vert.js

@@ -1,10 +1,10 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
  * @copyright (C) 2011 - 2023 Olivier Biot (AltByte Pte Ltd)
  */
-var quadVertex = "attribute vec2 aVertex;\nattribute vec2 aRegion;\nattribute vec4 aColor;\n\nuniform mat4 uProjectionMatrix;\n\nvarying vec2 vRegion;\nvarying vec4 vColor;\n\nvoid main(void) {\n    // Transform the vertex position by the projection matrix\n     gl_Position = uProjectionMatrix * vec4(aVertex, 0.0, 1.0);\n    // Pass the remaining attributes to the fragment shader\n    vColor = vec4(aColor.bgr * aColor.a, aColor.a);\n    vRegion = aRegion;\n}\n";
+var quadVertex = "// Current vertex point\nattribute vec2 aVertex;\nattribute vec2 aRegion;\nattribute vec4 aColor;\n\n// Projection matrix\nuniform mat4 uProjectionMatrix;\n\nvarying vec2 vRegion;\nvarying vec4 vColor;\n\nvoid main(void) {\n    // Transform the vertex position by the projection matrix\n    gl_Position = uProjectionMatrix * vec4(aVertex, 0.0, 1.0);\n    // Pass the remaining attributes to the fragment shader\n    vColor = vec4(aColor.bgr * aColor.a, aColor.a);\n    vRegion = aRegion;\n}\n";
 
 export { quadVertex as default };

package/dist/melonjs.mjs/video/webgl/utils/attributes.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/utils/precision.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/utils/program.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/utils/string.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license

package/dist/melonjs.mjs/video/webgl/utils/uniforms.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v14.5.0
+ * melonJS Game Engine - v15.0.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license