melonjs 14.0.2 → 14.1.0

package/dist/melonjs.mjs/video/webgl/buffer/vertex.js

@@ -0,0 +1,143 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+/**
+ * @classdesc
+ * a Vertex Buffer object
+ * @class VertexArrayBuffer
+ * @ignore
+ */
+
+class VertexArrayBuffer {
+
+    constructor(vertex_size, vertex_per_quad) {
+        // the size of one vertex in float
+        this.vertexSize = vertex_size;
+        // size of a quad in vertex
+        this.quadSize = vertex_per_quad;
+        // the maximum number of vertices the vertex array buffer can hold
+        this.maxVertex = 256;
+        // the current number of vertices added to the vertex array buffer
+        this.vertexCount = 0;
+
+        // the actual vertex data buffer
+        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.quadSize);
+        // Float32 and Uint32 view of the vertex data array buffer
+        this.bufferF32 = new Float32Array(this.buffer);
+        this.bufferU32 = new Uint32Array(this.buffer);
+    }
+
+    /**
+     * clear the vertex array buffer
+     * @ignore
+     */
+    clear() {
+        this.vertexCount = 0;
+    }
+
+
+    /**
+     * return true if full
+     * @ignore
+     */
+    isFull(vertex = this.quadSize) {
+         return (this.vertexCount + vertex >= this.maxVertex);
+    }
+
+    /**
+     * resize the vertex buffer, retaining its original contents
+     * @ignore
+     */
+    resize() {
+        // double the vertex size
+        this.maxVertex <<= 1;
+        // save a reference to the previous data
+        var data = this.bufferF32;
+
+        // recreate ArrayBuffer and views
+        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.quadSize);
+        this.bufferF32 = new Float32Array(this.buffer);
+        this.bufferU32 = new Uint32Array(this.buffer);
+
+        // copy previous data
+        this.bufferF32.set(data);
+
+        return this;
+    }
+
+    /**
+     * push a new vertex to the buffer
+     * @ignore
+     */
+    push(x, y, u, v, tint) {
+        var offset = this.vertexCount * this.vertexSize;
+
+        if (this.vertexCount >= this.maxVertex) {
+            this.resize();
+        }
+
+        this.bufferF32[offset + 0] = x;
+        this.bufferF32[offset + 1] = y;
+
+        if (typeof u !== "undefined") {
+            this.bufferF32[offset + 2] = u;
+            this.bufferF32[offset + 3] = v;
+        }
+
+        if (typeof tint !== "undefined") {
+            this.bufferU32[offset + 4] = tint;
+        }
+
+        this.vertexCount++;
+
+        return this;
+    }
+
+    /**
+     * return a reference to the data in Float32 format
+     * @ignore
+     */
+    toFloat32(begin, end) {
+        if (typeof end !== "undefined") {
+            return this.bufferF32.subarray(begin, end);
+        } else {
+            return this.bufferF32;
+        }
+    }
+
+    /**
+     * return a reference to the data in Uint32 format
+     * @ignore
+     */
+    toUint32(begin, end) {
+        if (typeof end !== "undefined") {
+            return this.bufferU32.subarray(begin, end);
+        } else {
+            return this.bufferU32;
+        }
+    }
+
+    /**
+     * return the size of the vertex in vertex
+     * @ignore
+     */
+    length() {
+        return this.vertexCount;
+    }
+
+    /**
+     * return true if empty
+     * @ignore
+     */
+    isEmpty() {
+        return this.vertexCount === 0;
+    }
+
+}
+var VertexArrayBuffer$1 = VertexArrayBuffer;
+
+export { VertexArrayBuffer$1 as default };

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

@@ -0,0 +1,168 @@
+/*!
+ * melonJS Game Engine - v14.1.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 { on, ONCONTEXT_LOST } from '../../system/event.js';
+import { getMaxShaderPrecision } from '../../system/device.js';
+import { extractUniforms } from './utils/uniforms.js';
+import { extractAttributes } from './utils/attributes.js';
+import { compileProgram } from './utils/program.js';
+import { setPrecision } from './utils/precision.js';
+import { minify } from './utils/string.js';
+
+/**
+ * @classdesc
+ * a base GL Shader object
+ */
+class GLShader {
+    /**
+     * @param {WebGLRenderingContext} gl - the current WebGL rendering context
+     * @param {string} vertex - a string containing the GLSL source code to set
+     * @param {string} fragment - a string containing the GLSL source code to set
+     * @param {string} [precision=auto detected] - float precision ('lowp', 'mediump' or 'highp').
+     * @see https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_on_the_web/GLSL_Shaders
+     * @example
+     * // create a basic shader
+     * var myShader = new me.GLShader(
+     *    // WebGL rendering context
+     *    gl,
+     *    // vertex shader
+     *    [
+     *        "void main() {",
+     *        "    gl_Position = doMathToMakeClipspaceCoordinates;",
+     *        "}"
+     *    ].join("\n"),
+     *    // fragment shader
+     *    [
+     *        "void main() {",
+     *        "    gl_FragColor = doMathToMakeAColor;",
+     *        "}"
+     *    ].join("\n")
+     *  )
+     * // use the shader
+     * myShader.bind();
+     */
+    constructor(gl, vertex, fragment, precision) {
+
+        /**
+         * the active gl rendering context
+         * @type {WebGLRenderingContext}
+         */
+        this.gl = gl;
+
+        /**
+         * the vertex shader source code
+         * @type {string}
+         */
+        this.vertex = setPrecision(minify(vertex), precision || getMaxShaderPrecision(this.gl));
+
+        /**
+         * the fragment shader source code
+         * @type {string}
+         */
+        this.fragment = setPrecision(minify(fragment), precision || getMaxShaderPrecision(this.gl));
+
+        /**
+         * the location attributes of the shader
+         * @type {GLint[]}
+         */
+        this.attributes = extractAttributes(this.gl, this);
+
+
+        /**
+         * a reference to the shader program (once compiled)
+         * @type {WebGLProgram}
+         */
+        this.program = compileProgram(this.gl, this.vertex, this.fragment, this.attributes);
+
+        /**
+         * the uniforms of the shader
+         * @type {object}
+         */
+        this.uniforms = extractUniforms(this.gl, this);
+
+        // destroy the shader on context lost (will be recreated on context restore)
+        on(ONCONTEXT_LOST, this.destroy, this);
+    }
+
+    /**
+     * Installs this shader program as part of current rendering state
+     */
+    bind() {
+        this.gl.useProgram(this.program);
+    }
+
+    /**
+     * returns the location of an attribute variable in this shader program
+     * @param {string} name - the name of the attribute variable whose location to get.
+     * @returns {GLint} number indicating the location of the variable name if found. Returns -1 otherwise
+     */
+    getAttribLocation(name) {
+        var attr = this.attributes[name];
+        if (typeof attr !== "undefined") {
+            return attr;
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Set the uniform to the given value
+     * @param {string} name - the uniform name
+     * @param {object|Float32Array} value - the value to assign to that uniform
+     * @example
+     * myShader.setUniform("uProjectionMatrix", this.projectionMatrix);
+     */
+    setUniform(name, value) {
+        var uniforms = this.uniforms;
+        if (typeof uniforms[name] !== "undefined") {
+            if (typeof value === "object" && typeof value.toArray === "function") {
+                uniforms[name] = value.toArray();
+            } else {
+                uniforms[name] = value;
+            }
+        } else {
+            throw new Error("undefined (" + name + ") uniform for shader " + this);
+        }
+    }
+
+    /**
+     * activate the given vertex attribute for this shader
+     * @param {WebGLRenderingContext} gl - the current WebGL rendering context
+     * @param {object[]} attributes - an array of vertex attributes
+     * @param {number} vertexByteSize - the size of a single vertex in bytes
+     */
+    setVertexAttributes(gl, attributes, vertexByteSize) {
+        // set the vertex attributes
+        for (var index = 0; index < attributes.length; ++index) {
+            var element = attributes[index];
+            var location = this.getAttribLocation(element.name);
+
+            if (location !== -1) {
+                gl.enableVertexAttribArray(location);
+                gl.vertexAttribPointer(location, element.size, element.type, element.normalized, vertexByteSize, element.offset);
+            } else {
+                gl.disableVertexAttribArray(index);
+            }
+        }
+    }
+
+    /**
+     * destroy this shader objects resources (program, attributes, uniforms)
+     */
+    destroy() {
+        this.uniforms = null;
+        this.attributes = null;
+
+        this.gl.deleteProgram(this.program);
+
+        this.vertex = null;
+        this.fragment = null;
+    }
+}
+var GLShader$1 = GLShader;
+
+export { GLShader$1 as default };

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

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+var primitiveFragment = "varying vec4 vColor;\n\nvoid main(void) {\n    gl_FragColor = vColor;\n}\n";
+
+export { primitiveFragment as default };

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

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+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";
+
+export { primitiveVertex as default };

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

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+var quadFragment = "uniform sampler2D uSampler;\nvarying vec4 vColor;\nvarying vec2 vRegion;\n\nvoid main(void) {\n    gl_FragColor = texture2D(uSampler, vRegion) * vColor;\n}\n";
+
+export { quadFragment as default };

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

@@ -0,0 +1,10 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+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";
+
+export { quadVertex as default };

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

@@ -0,0 +1,25 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+/**
+ * @ignore
+ */
+function extractAttributes(gl, shader) {
+    var attributes = {},
+        attrRx = /attribute\s+\w+\s+(\w+)/g,
+        match,
+        i = 0;
+
+    // Detect all attribute names
+    while ((match = attrRx.exec(shader.vertex))) {
+        attributes[match[1]] = i++;
+    }
+
+    return attributes;
+}
+
+export { extractAttributes };

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

@@ -0,0 +1,20 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+/**
+ * set precision for the fiven shader source
+ * won't do anything if the precision is already specified
+ * @ignore
+ */
+function setPrecision(src, precision) {
+    if (src.substring(0, 9) !== "precision") {
+        return "precision " + precision + " float;" + src;
+    }
+    return src;
+}
+
+export { setPrecision };

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

@@ -0,0 +1,67 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+/**
+ * @ignore
+ */
+function compileShader(gl, type, source) {
+    var shader = gl.createShader(type);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        throw new Error(gl.getShaderInfoLog(shader));
+    }
+
+    return shader;
+}
+
+/**
+ * Compile GLSL into a shader object
+ * @ignore
+ */
+function compileProgram(gl, vertex, fragment, attributes) {
+    var vertShader = compileShader(gl, gl.VERTEX_SHADER, vertex);
+    var fragShader = compileShader(gl, gl.FRAGMENT_SHADER, fragment);
+
+    var program = gl.createProgram();
+
+    gl.attachShader(program, vertShader);
+    gl.attachShader(program, fragShader);
+
+
+    // force vertex attributes to use location 0 as starting location to prevent
+    // browser to do complicated emulation when running on desktop OpenGL (e.g. on macOS)
+    for (var location in attributes) {
+        gl.bindAttribLocation(program, attributes[location], location);
+    }
+
+    gl.linkProgram(program);
+
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        var error_msg =
+            "Error initializing Shader " + this + "\n" +
+            "gl.VALIDATE_STATUS: " + gl.getProgramParameter(program, gl.VALIDATE_STATUS) + "\n" +
+            "gl.getError()" + gl.getError() + "\n" +
+            "gl.getProgramInfoLog()" + gl.getProgramInfoLog(program);
+        // house cleaning
+        gl.deleteProgram(program);
+        program = null;
+        // throw the exception
+        throw new Error(error_msg);
+    }
+
+    gl.useProgram(program);
+
+    // clean-up
+    gl.deleteShader(vertShader);
+    gl.deleteShader(fragShader);
+
+    return program;
+}
+
+export { compileProgram };

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

@@ -0,0 +1,25 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+/**
+ * clean the given source from space, comments, etc...
+ * @ignore
+ */
+function minify(src) {
+    // remove comments
+    src = src.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
+    // Remove leading and trailing whitespace from lines
+    src = src.replace(/(\\n\s+)|(\s+\\n)/g, "");
+    // Remove line breaks
+    src = src.replace(/(\\r|\\n)+/g, "");
+    // Remove unnecessary whitespace
+    src = src.replace(/\s*([;,[\](){}\\\/\-+*|^&!=<>?~%])\s*/g, "$1");
+
+    return src;
+}
+
+export { minify };

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

@@ -0,0 +1,92 @@
+/*!
+ * melonJS Game Engine - v14.1.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)
+ */
+/**
+ * Hash map of GLSL data types to WebGL Uniform methods
+ * @ignore
+ */
+const fnHash = {
+    "bool"      : "1i",
+    "int"       : "1i",
+    "float"     : "1f",
+    "vec2"      : "2fv",
+    "vec3"      : "3fv",
+    "vec4"      : "4fv",
+    "bvec2"     : "2iv",
+    "bvec3"     : "3iv",
+    "bvec4"     : "4iv",
+    "ivec2"     : "2iv",
+    "ivec3"     : "3iv",
+    "ivec4"     : "4iv",
+    "mat2"      : "Matrix2fv",
+    "mat3"      : "Matrix3fv",
+    "mat4"      : "Matrix4fv",
+    "sampler2D" : "1i"
+};
+
+/**
+ * @ignore
+ */
+function extractUniforms(gl, shader) {
+    var uniforms = {},
+        uniRx = /uniform\s+(\w+)\s+(\w+)/g,
+        uniformsData = {},
+        descriptor = {},
+        locations = {},
+        match;
+
+    // Detect all uniform names and types
+    [ shader.vertex, shader.fragment ].forEach((shader) => {
+        while ((match = uniRx.exec(shader))) {
+            uniformsData[match[2]] = match[1];
+        }
+    });
+
+    // Get uniform references
+    Object.keys(uniformsData).forEach((name) => {
+        var type = uniformsData[name];
+        locations[name] = gl.getUniformLocation(shader.program, name);
+
+        descriptor[name] = {
+            "get" : (function (name) {
+                /*
+                 * A getter for the uniform location
+                 */
+                return function () {
+                    return locations[name];
+                };
+            })(name),
+            "set" : (function (name, type, fn) {
+                if (type.indexOf("mat") === 0) {
+                    /*
+                     * A generic setter for uniform matrices
+                     */
+                    return function (val) {
+                        gl[fn](locations[name], false, val);
+                    };
+                }
+                else {
+                    /*
+                     * A generic setter for uniform vectors
+                     */
+                    return function (val) {
+                        var fnv = fn;
+                        if (val.length && fn.slice(-1) !== "v") {
+                            fnv += "v";
+                        }
+                        gl[fnv](locations[name], val);
+                    };
+                }
+            })(name, type, "uniform" + fnHash[type])
+        };
+    });
+    Object.defineProperties(uniforms, descriptor);
+
+    return uniforms;
+}
+
+export { extractUniforms };