melonjs 17.3.0 → 18.0.0

package/src/video/texture/parser/spritesheet.js

@@ -1,68 +0,0 @@
-import pool from "./../../../system/pooling.js";
-import Vector2d from "./../../../math/vector2.js";
-
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseSpriteSheet(data, textureAtlas) {
-    let atlas = {};
-    let image = data.image;
-    let spacing = data.spacing || 0;
-    let margin = data.margin || 0;
-
-    let width = image.width;
-    let height = image.height;
-
-    // calculate the sprite count (line, col)
-    let spritecount = pool.pull("Vector2d",
-        ~~((width - margin + spacing) / (data.framewidth + spacing)),
-        ~~((height - margin + spacing) / (data.frameheight + spacing))
-    );
-
-    // verifying the texture size
-    if ((width % (data.framewidth + spacing)) !== 0 ||
-        (height % (data.frameheight + spacing)) !== 0) {
-        let computed_width = spritecount.x * (data.framewidth + spacing);
-        let computed_height = spritecount.y * (data.frameheight + spacing);
-        if (computed_width - width !== spacing && computed_height - height !== spacing) {
-            // "truncate size" if delta is different from the spacing size
-            width = computed_width;
-            height = computed_height;
-            // warning message
-            console.warn(
-                "Spritesheet Texture for image: " + image.src +
-                " is not divisible by " + (data.framewidth + spacing) +
-                "x" + (data.frameheight + spacing) +
-                ", truncating effective size to " + width + "x" + height
-            );
-        }
-    }
-
-    // build the local atlas
-    for (let frame = 0, count = spritecount.x * spritecount.y; frame < count; frame++) {
-        let name = "" + frame;
-        atlas[name] = {
-            name            : name,
-            texture         : "default", // the source texture
-            offset          : new Vector2d(
-                margin + (spacing + data.framewidth) * (frame % spritecount.x),
-                margin + (spacing + data.frameheight) * ~~(frame / spritecount.x)
-            ),
-            anchorPoint     : (data.anchorPoint || null),
-            trimmed         : false,
-            trim            : undefined,
-            width           : data.framewidth,
-            height          : data.frameheight,
-            angle           : 0
-        };
-        textureAtlas.addUVs(atlas, name, width, height);
-    }
-
-    pool.push(spritecount);
-
-    return atlas;
-}

package/src/video/texture/parser/texturepacker.js

@@ -1,55 +0,0 @@
-import { ETA } from "./../../../math/math.js";
-import Vector2d from "./../../../math/vector2.js";
-
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseTexturePacker(data, textureAtlas) {
-    let atlas = {};
-
-    data.frames.forEach((frame) => {
-        // fix wrongly formatted JSON (e.g. last dummy object in ShoeBox)
-        if (frame.hasOwnProperty("filename")) {
-            // Source coordinates
-            let s = frame.frame;
-            let trimmed = !!frame.trimmed;
-
-            let trim;
-
-            if (trimmed) {
-                trim = {
-                    x : frame.spriteSourceSize.x,
-                    y : frame.spriteSourceSize.y,
-                    w : frame.spriteSourceSize.w,
-                    h : frame.spriteSourceSize.h
-                };
-            }
-
-            let originX, originY;
-            // Pixel-based offset origin from the top-left of the source frame
-            let hasTextureAnchorPoint = (frame.sourceSize && frame.pivot);
-            if (hasTextureAnchorPoint) {
-                originX = (frame.sourceSize.w * frame.pivot.x) - ((trimmed) ? trim.x : 0);
-                originY = (frame.sourceSize.h * frame.pivot.y) - ((trimmed) ? trim.y : 0);
-            }
-
-            atlas[frame.filename] = {
-                name         : frame.filename, // frame name
-                texture      : data.meta.image || "default", // the source texture
-                offset       : new Vector2d(s.x, s.y),
-                anchorPoint  : (hasTextureAnchorPoint) ? new Vector2d(originX / s.w, originY / s.h) : null,
-                trimmed      : trimmed,
-                trim         : trim,
-                width        : s.w,
-                height       : s.h,
-                angle        : (frame.rotated === true) ? -ETA : 0
-            };
-            textureAtlas.addUVs(atlas, frame.filename, data.meta.size.w, data.meta.size.h);
-        }
-    });
-    return atlas;
-}

package/src/video/utils/autodetect.js

@@ -1,18 +0,0 @@
-import { isWebGLSupported } from "../../system/device";
-import WebGLRenderer from "../webgl/webgl_renderer";
-import CanvasRenderer from "../canvas/canvas_renderer";
-
-/**
- * Auto-detect the best renderer to use
- * @ignore
- */
-export function autoDetectRenderer(options) {
-    try {
-        if (isWebGLSupported(options)) {
-            return new WebGLRenderer(options);
-        }
-    } catch (e) {
-        console.log("Error creating WebGL renderer :" + e.message);
-    }
-    return new CanvasRenderer(options);
-}

package/src/video/video.js

@@ -1,160 +0,0 @@
-import * as event from "./../system/event.js";
-import { initialized, game } from "./../index.js";
-import * as device from "./../system/device.js";
-import { throttle } from "../utils/function.js";
-import { ApplicationSettings } from "../application/settings.js";
-
-/**
- * @namespace video
- */
-
-/**
- * Select the HTML5 Canvas renderer
- * @memberof video
- * @name CANVAS
- * @static
- */
-export { CANVAS } from "../const";
-
-/**
- * Select the WebGL renderer
- * @memberof video
- * @name WEBGL
- * @static
- */
-export { WEBGL } from "../const";
-
-/**
- * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
- * @memberof video
- * @name AUTO
- * @static
- */
-export { AUTO } from "../const";
-
-/**
- * A reference to the active Canvas or WebGL active renderer renderer
- * @memberof video
- * @type {CanvasRenderer|WebGLRenderer}
- */
-export let renderer = null;
-
-/**
- * Initialize the "video" system (create a canvas based on the given arguments, and the related renderer). <br>
- * @memberof video
- * @param {number} width - The width of the canvas viewport
- * @param {number} height - The height of the canvas viewport
- * @param {ApplicationSettings} [options] - optional parameters for the renderer
- * @returns {boolean} false if initialization failed (canvas not supported)
- * @example
- * // init the video with a 640x480 canvas
- * me.video.init(640, 480, {
- *     parent : "screen",
- *     renderer : me.video.AUTO,
- *     scale : "auto",
- *     scaleMethod : "fit"
- * });
- */
-export function init(width, height, options) {
-    // ensure melonjs has been properly initialized
-    if (!initialized) {
-        throw new Error("me.video.init() called before engine initialization.");
-    }
-
-    try {
-        // initialize the default game Application with the given options
-        game.init(width, height, Object.assign(ApplicationSettings, options || {}));
-    } catch (e) {
-        console.log(e.message);
-        // me.video.init() historically returns false if failing at creating/using a HTML5 canvas
-        return false;
-    }
-
-    // assign the default renderer
-    renderer = game.renderer;
-
-    //add a channel for the onresize/onorientationchange event
-    globalThis.addEventListener(
-        "resize",
-        throttle(
-            (e) => {
-                event.emit(event.WINDOW_ONRESIZE, e);
-            }, 100
-        ), false
-    );
-
-    // Screen Orientation API
-    globalThis.addEventListener(
-        "orientationchange",
-        (e) => {
-            event.emit(event.WINDOW_ONORIENTATION_CHANGE, e);
-        },
-        false
-    );
-
-    // pre-fixed implementation on mozzila
-    globalThis.addEventListener(
-        "onmozorientationchange",
-        (e) => {
-            event.emit(event.WINDOW_ONORIENTATION_CHANGE, e);
-        },
-        false
-    );
-
-    if (device.screenOrientation === true) {
-        globalThis.screen.orientation.onchange = function (e) {
-            event.emit(event.WINDOW_ONORIENTATION_CHANGE, e);
-        };
-    }
-
-    // Automatically update relative canvas position on scroll
-    globalThis.addEventListener("scroll", throttle((e) => {
-        event.emit(event.WINDOW_ONSCROLL, e);
-    }, 100), false);
-
-    // notify the video has been initialized
-    event.emit(event.VIDEO_INIT, game.renderer);
-
-    return true;
-}
-
-/**
- * Create and return a new Canvas element
- * @memberof video
- * @param {number} width - width
- * @param {number} height - height
- * @param {boolean} [returnOffscreenCanvas=false] - will return an OffscreenCanvas if supported
- * @returns {HTMLCanvasElement|OffscreenCanvas} a new Canvas element of the given size
- */
-export function createCanvas(width, height, returnOffscreenCanvas = false) {
-    let _canvas;
-
-    if (width === 0 || height === 0) {
-        throw new Error("width or height was zero, Canvas could not be initialized !");
-    }
-
-    if (device.offscreenCanvas === true && returnOffscreenCanvas === true) {
-        _canvas = new globalThis.OffscreenCanvas(0, 0);
-        // stubbing style for compatibility,
-        // as OffscreenCanvas is detached from the DOM
-        if (typeof _canvas.style === "undefined") {
-            _canvas.style = {};
-        }
-    } else {
-        // "else" create a "standard" canvas
-        _canvas = globalThis.document.createElement("canvas");
-    }
-    _canvas.width = width;
-    _canvas.height = height;
-
-    return _canvas;
-}
-
-/**
- * return a reference to the parent DOM element holding the main canvas
- * @memberof video
- * @returns {HTMLElement} the HTML parent element
- */
-export function getParent() {
-    return game.getParentElement();
-}

package/src/video/webgl/buffer/vertex.js

@@ -1,137 +0,0 @@
-/**
- * @classdesc
- * a Vertex Buffer object
- * @class VertexArrayBuffer
- * @ignore
- */
-
-export default class VertexArrayBuffer {
-
-    constructor(vertex_size, vertex_per_obj) {
-        // the size of one vertex in float
-        this.vertexSize = vertex_size;
-        // size of an object in vertex
-        this.objSize = vertex_per_obj;
-        // the maximum number of vertices the vertex array buffer can hold
-        this.maxVertex = 256; // (note: this seems to be the sweet spot performance-wise when using batching)
-        // 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.objSize);
-        // 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.objSize) {
-        return (this.vertexCount + vertex >= this.maxVertex);
-    }
-
-    /**
-     * resize the vertex buffer, retaining its original contents
-     * @ignore
-     */
-    resize(vertexCount) {
-
-        while (vertexCount > this.maxVertex) {
-            // double the vertex size
-            this.maxVertex <<= 1;
-        }
-
-        // save a reference to the previous data
-        let data = this.bufferF32;
-
-        // recreate ArrayBuffer and views
-        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.objSize);
-        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) {
-        let offset = this.vertexCount * this.vertexSize;
-
-        if (this.vertexCount >= this.maxVertex) {
-            this.resize(this.vertexCount);
-        }
-
-        this.bufferF32[offset] = x;
-        this.bufferF32[++offset] = y;
-
-        if (typeof u !== "undefined") {
-            this.bufferF32[++offset] = u;
-            this.bufferF32[++offset] = v;
-        }
-
-        if (typeof tint !== "undefined") {
-            this.bufferU32[++offset] = 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;
-    }
-
-}

package/src/video/webgl/compositors/compositor.js

@@ -1,225 +0,0 @@
-import VertexArrayBuffer from "../buffer/vertex.js";
-import GLShader from "../glshader.js";
-
-/**
- * @classdesc
- * A base Compositor object.
- */
-export default 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();
-        }
-    }
-}