melonjs 17.3.0 → 18.0.0

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

@@ -1,234 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import VertexArrayBuffer from '../buffer/vertex.js';
-import GLShader from '../glshader.js';
-
-/**
- * @classdesc
- * A base Compositor object.
- */
-class Compositor {
-    /**
-     * @param {WebGLRenderer} renderer - the current WebGL renderer session
-     * @param {object} settings - additional settings to initialize this compositors
-     * @param {object[]} settings.attribute - an array of attributes definition
-     * @param {string} settings.attribute.name - name of the attribute in the vertex shader
-     * @param {number} settings.attribute.size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
-     * @param {GLenum} settings.attribute.type - data type of each component in the array
-     * @param {boolean} settings.attribute.normalized - whether integer data values should be normalized into a certain range when being cast to a float
-     * @param {number} settings.attribute.offset - offset in bytes of the first component in the vertex attribute array
-     * @param {object} settings.shader - an array of attributes definition
-     * @param {string} settings.shader.vertex - a string containing the GLSL source code to set
-     * @param {string} settings.shader.fragment - a string containing the GLSL source code to set
-     */
-    constructor (renderer, settings) {
-        this.init(renderer, settings);
-    }
-
-    /**
-     * Initialize the compositor
-     * @ignore
-     */
-    init (renderer, settings) {
-        // 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;
-
-        /**
-         * the default shader created by this compositor
-         * @type {GLShader}
-         */
-        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 = this.gl.TRIANGLES;
-
-        /**
-         * an array of vertex attribute properties
-         * @see WebGLCompositor.addAttribute
-         * @type {Array.<Object>}
-         */
-        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;
-
-        /**
-         * 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");
-        }
-    }
-
-    /**
-     * Reset compositor internal state
-     * @ignore
-     */
-    reset() {
-        // WebGL context
-        this.gl = this.renderer.gl;
-
-        // clear the vertex data buffer
-        this.vertexData.clear();
-    }
-
-    /**
-     * called by the WebGL renderer when a compositor become the current one
-     */
-    bind() {
-        if (this.renderer.currentProgram !== this.defaultShader.program) {
-            this.useShader(this.defaultShader);
-        }
-    }
-
-    /**
-     * 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;
-        }
-    }
-
-    /**
-     * 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;
-    }
-
-    /**
-     * set/change the current projection matrix
-     * @param {Matrix3d} matrix - the new projection matrix
-     */
-    setProjection(matrix) {
-        this.currentShader.setUniform("uProjectionMatrix", matrix);
-    }
-
-    /**
-     * Flush batched vertex data to the GPU
-     * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
-     */
-    flush(mode = this.mode) {
-        let vertex = this.vertexData;
-        let vertexCount = vertex.vertexCount;
-
-        if (vertexCount > 0) {
-            let gl = this.gl;
-            let 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();
-        }
-    }
-}
-
-export { Compositor as default };

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

@@ -1,77 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 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) {
-        let viewMatrix = this.viewMatrix;
-        let vertexData = this.vertexData;
-        let alpha = this.renderer.getGlobalAlpha();
-        let colorUint32 = this.renderer.currentColor.toUint32(alpha);
-
-        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, colorUint32);
-            });
-        } else {
-            verts.forEach((vert) => {
-                vertexData.push(vert.x, vert.y, undefined, undefined, colorUint32);
-            });
-        }
-
-        // 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

@@ -1,254 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 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
-let 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 (let i = 0; i < this.renderer.maxTextures; i++) {
-            let 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) {
-        let gl = this.gl;
-        let isPOT = isPowerOfTwo(w) && isPowerOfTwo(h);
-        let rs = (repeat.search(/^repeat(-x)?$/) === 0) && (isPOT || this.renderer.WebGLVersion > 1) ? gl.REPEAT : gl.CLAMP_TO_EDGE;
-        let rt = (repeat.search(/^repeat(-y)?$/) === 0) && (isPOT || this.renderer.WebGLVersion > 1) ? gl.REPEAT : gl.CLAMP_TO_EDGE;
-
-        let 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 if (typeof globalThis.OffscreenCanvas !== "undefined" && pixels instanceof globalThis.OffscreenCanvas) {
-            // convert to ImageBitmap first (else Safari 16.4 and higher will throw an TypeError exception)
-            const imageBitmap = pixels.transferToImageBitmap();
-            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, imageBitmap);
-            imageBitmap.close();
-        } 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
-     */
-    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) {
-        let 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) {
-        let unit = this.renderer.cache.getUnit(texture);
-        let 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
-     * @param {boolean} reupload - Force the texture to be reuploaded even if already bound
-     */
-    addQuad(texture, x, y, w, h, u0, v0, u1, v1, tint, reupload = false) {
-        let 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
-        let unit = this.uploadTexture(texture, w, h, reupload);
-
-        // set fragment sampler accordingly
-        this.currentShader.setUniform("uSampler", unit);
-
-        // Transform vertices
-        let 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 };