@lightningjs/renderer 0.6.0 → 0.7.0

package/dist/src/core/lib/ContextSpy.js

@@ -0,0 +1,38 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class that keeps track of the invocations of Context methods when
+ * the `enableContextSpy` renderer option is enabled.
+ */
+export class ContextSpy {
+    data = {};
+    reset() {
+        this.data = {};
+    }
+    increment(name) {
+        if (!this.data[name]) {
+            this.data[name] = 0;
+        }
+        this.data[name]++;
+    }
+    getData() {
+        return { ...this.data };
+    }
+}
+//# sourceMappingURL=ContextSpy.js.map

package/dist/src/core/lib/ContextSpy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextSpy.js","sourceRoot":"","sources":["../../../../src/core/lib/ContextSpy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;GAGG;AACH,MAAM,OAAO,UAAU;IACb,IAAI,GAA2B,EAAE,CAAC;IAE1C,KAAK;QACH,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACrB;QACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IACpB,CAAC;IAED,OAAO;QACL,OAAO,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;CACF"}

package/dist/src/core/lib/ImageWorker.d.ts

@@ -0,0 +1,16 @@
+import { type TextureData } from '../textures/Texture.js';
+type MessageCallback = [(value: any) => void, (reason: any) => void];
+export declare class ImageWorkerManager {
+    isWorkerSupported: boolean;
+    imageWorkersEnabled: boolean;
+    messageManager: Record<string, MessageCallback>;
+    workers: Worker[];
+    workerIndex: number;
+    constructor(numImageWorkers: number);
+    private handleMessage;
+    private createWorkers;
+    private getNextWorker;
+    private convertUrlToAbsolute;
+    getImage(src: string, premultiplyAlpha: boolean): Promise<TextureData>;
+}
+export {};

package/dist/src/core/lib/ImageWorker.js

@@ -0,0 +1,111 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2023 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {} from '../textures/Texture.js';
+export class ImageWorkerManager {
+    isWorkerSupported = !!self.Worker;
+    imageWorkersEnabled = true;
+    messageManager = {};
+    workers = [];
+    workerIndex = 0;
+    constructor(numImageWorkers) {
+        if (this.isWorkerSupported && numImageWorkers > 0) {
+            this.workers = this.createWorkers(numImageWorkers);
+            this.workers.forEach((worker) => {
+                worker.onmessage = this.handleMessage.bind(this);
+            });
+        }
+        else {
+            this.imageWorkersEnabled = false;
+        }
+    }
+    handleMessage(event) {
+        const { src, data, error } = event.data;
+        const msg = this.messageManager[src];
+        if (msg) {
+            const [resolve, reject] = msg;
+            delete this.messageManager[src];
+            if (error) {
+                reject(new Error(error));
+            }
+            else {
+                resolve({ data: data });
+            }
+        }
+    }
+    createWorkers(numWorkers = 1) {
+        const workerCode = `
+      async function getImage(src, premultiplyAlpha) {
+        const response = await fetch(src);
+        const blob = await response.blob();
+        return await createImageBitmap(blob, {
+          premultiplyAlpha: premultiplyAlpha ? 'premultiply' : 'none',
+          colorSpaceConversion: 'none',
+          imageOrientation: 'none',
+        });
+      }
+
+      self.onmessage = async (event) => {
+        const { src, premultiplyAlpha } = event.data;
+
+        try {
+          const data = await getImage(src, premultiplyAlpha);
+          self.postMessage({ src, data }, [data]);
+        } catch (error) {
+          self.postMessage({ src, error: error.message });
+        }
+      };
+    `;
+        const blob = new Blob([workerCode.replace('"use strict";', '')], {
+            type: 'application/javascript',
+        });
+        const blobURL = (window.URL ? URL : webkitURL).createObjectURL(blob);
+        const workers = [];
+        for (let i = 0; i < numWorkers; i++) {
+            workers.push(new Worker(blobURL));
+        }
+        return workers;
+    }
+    getNextWorker() {
+        const worker = this.workers[this.workerIndex];
+        this.workerIndex = (this.workerIndex + 1) % this.workers.length;
+        return worker;
+    }
+    convertUrlToAbsolute(url) {
+        const absoluteUrl = new URL(url, self.location.href);
+        return absoluteUrl.href;
+    }
+    getImage(src, premultiplyAlpha) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (this.workers) {
+                    const absoluteSrcUrl = this.convertUrlToAbsolute(src);
+                    this.messageManager[absoluteSrcUrl] = [resolve, reject];
+                    this.getNextWorker().postMessage({
+                        src: absoluteSrcUrl,
+                        premultiplyAlpha,
+                    });
+                }
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+//# sourceMappingURL=ImageWorker.js.map

package/dist/src/core/lib/ImageWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageWorker.js","sourceRoot":"","sources":["../../../../src/core/lib/ImageWorker.ts"],"names":[],"mappings":"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"}

package/dist/src/core/lib/WebGlContext.d.ts

@@ -0,0 +1,414 @@
+export declare class WebGlContext {
+    private gl;
+    private activeTextureUnit;
+    private texture2dUnits;
+    private texture2dParams;
+    private scissorEnabled;
+    private scissorX;
+    private scissorY;
+    private scissorWidth;
+    private scissorHeight;
+    private blendEnabled;
+    private blendSrcRgb;
+    private blendDstRgb;
+    private blendSrcAlpha;
+    private blendDstAlpha;
+    private boundArrayBuffer;
+    private boundElementArrayBuffer;
+    private curProgram;
+    private programUniforms;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+    /**
+     * ```
+     * gl.activeTexture(textureUnit + gl.TEXTURE0);
+     * ```
+     *
+     * @remarks
+     * **WebGL Difference**: `textureUnit` is based from 0, not `gl.TEXTURE0`.
+     *
+     * @param textureUnit
+     */
+    activeTexture(textureUnit: number): void;
+    /**
+     * ```
+     * gl.bindTexture(gl.TEXTURE_2D, texture);
+     * ```
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     *
+     * @param texture
+     */
+    bindTexture(texture: WebGLTexture | null): void;
+    private _getActiveTexture;
+    /**
+     * ```
+     * gl.texParameteri(gl.TEXTURE_2D, pname, param)
+     * ```
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     *
+     * @param pname
+     * @param param
+     * @returns
+     */
+    texParameteri(pname: number, param: number): void;
+    /**
+     * ```
+     * gl.texImage2D(
+     *   gl.TEXTURE_2D,
+     *   level,
+     *   internalFormat,
+     *   width,
+     *   height,
+     *   border,
+     *   format,
+     *   type,
+     *   pixels,
+     * );
+     * ```
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     *
+     * @param level
+     * @param internalFormat
+     * @param width
+     * @param height
+     * @param border
+     * @param format
+     * @param type
+     * @param pixels
+     */
+    texImage2D(level: GLint, internalformat: GLint, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: ArrayBufferView | null): void;
+    texImage2D(level: GLint, internalformat: GLint, format: GLenum, type: GLenum, source: TexImageSource): void;
+    /**
+     * ```
+     * gl.pixelStorei(pname, param);
+     * ```
+     *
+     * @param pname
+     * @param param
+     */
+    pixelStorei(pname: GLenum, param: GLint | GLboolean): void;
+    /**
+     * ```
+     * gl.generateMipmap(gl.TEXTURE_2D);
+     * ```
+     *
+     * @remarks
+     * **WebGL Difference**: Bind target is always `gl.TEXTURE_2D`
+     */
+    generateMipmap(): void;
+    /**
+     * ```
+     * gl.createTexture();
+     * ```
+     *
+     * @returns
+     */
+    createTexture(): WebGLTexture | null;
+    /**
+     * ```
+     * gl.deleteTexture(texture);
+     * ```
+     *
+     * @param texture
+     */
+    deleteTexture(texture: WebGLTexture | null): void;
+    /**
+     * ```
+     * gl.viewport(x, y, width, height);
+     * ```
+     */
+    viewport(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
+    /**
+     * ```
+     * gl.clearColor(red, green, blue, alpha);
+     * ```
+     *
+     * @param red
+     * @param green
+     * @param blue
+     * @param alpha
+     */
+    clearColor(red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf): void;
+    /**
+     * ```
+     * gl["enable"|"disable"](gl.SCISSOR_TEST);
+     * ```
+     * @param enable
+     */
+    scissorTest(enable: boolean): void;
+    /**
+     * ```
+     * gl.scissor(x, y, width, height);
+     * ```
+     *
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     */
+    scissor(x: GLint, y: GLint, width: GLsizei, height: GLsizei): void;
+    /**
+     * ```
+     * gl["enable"|"disable"](gl.BLEND);
+     * ```
+     *
+     * @param blend
+     * @returns
+     */
+    setBlend(blend: boolean): void;
+    /**
+     * ```
+     * gl.blendFunc(src, dst);
+     * ```
+     *
+     * @param src
+     * @param dst
+     */
+    blendFunc(src: GLenum, dst: GLenum): void;
+    /**
+     * ```
+     * createBuffer();
+     * ```
+     *
+     * @returns
+     */
+    createBuffer(): WebGLBuffer | null;
+    /**
+     * ```
+     * gl.clear(gl.COLOR_BUFFER_BIT);
+     * ```
+     *
+     * @remarks
+     * **WebGL Difference**: Clear mask is always `gl.COLOR_BUFFER_BIT`
+     */
+    clear(): void;
+    /**
+     * ```
+     * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+     * gl.bufferData(gl.ARRAY_BUFFER, data, usage);
+     * ```
+     *
+     * @remarks
+     * **WebGL Combo**: `gl.bindBuffer` and `gl.bufferData` are combined into one function.
+     *
+     * @param buffer
+     * @param data
+     * @param usage
+     */
+    arrayBufferData(buffer: WebGLBuffer | null, data: ArrayBufferView, usage: GLenum): void;
+    /**
+     * ```
+     * gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+     * gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, usage);
+     * ```
+     * @remarks
+     * **WebGL Combo**: `gl.bindBuffer` and `gl.bufferData` are combined into one function.
+     *
+     * @param buffer
+     * @param data
+     * @param usage
+     */
+    elementArrayBufferData(buffer: WebGLBuffer | null, data: ArrayBufferView, usage: GLenum): void;
+    /**
+     * ```
+     * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+     * gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
+     * ```
+     *
+     * @remarks
+     * **WebGL Combo**: `gl.bindBuffer` and `gl.vertexAttribPointer` are combined into one function.
+     *
+     * @param buffer
+     * @param index
+     * @param size
+     * @param type
+     * @param normalized
+     * @param stride
+     * @param offset
+     */
+    vertexAttribPointer(buffer: WebGLBuffer, index: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
+    /**
+     * ```
+     * gl.useProgram(program);
+     * ```
+     *
+     * @param program
+     * @returns
+     */
+    useProgram(program: WebGLProgram | null): void;
+    setUniform<T extends keyof UniformMethodMap>(type: T, location: WebGLUniformLocation, ...args: UniformMethodMap[T]): void;
+    /**
+     * ```
+     * gl.getParameter(pname);
+     * ```
+     *
+     * @param pname
+     * @returns
+     */
+    getParameter(pname: GLenum): any;
+    /**
+     * ```
+     * gl.drawElements(mode, count, type, offset);
+     * ```
+     *
+     * @param mode
+     * @param count
+     * @param type
+     * @param offset
+     */
+    drawElements(mode: GLenum, count: GLsizei, type: GLenum, offset: GLintptr): void;
+    /**
+     * ```
+     * gl.drawArrays(mode, first, count);
+     * ```
+     *
+     * @param name
+     * @returns
+     */
+    getExtension(name: string): any;
+    /**
+     * ```
+     * gl.createVertexArray();
+     * ```
+     *
+     * @returns
+     */
+    createVertexArray(): WebGLVertexArrayObject | null;
+    /**
+     * ```
+     * gl.bindVertexArray(vertexArray);
+     * ```
+     *
+     * @param vertexArray
+     */
+    bindVertexArray(vertexArray: WebGLVertexArrayObject | null): void;
+    /**
+     * ```
+     * gl.getAttribLocation(program, name);
+     * ```
+     *
+     * @param program
+     * @param name
+     * @returns
+     */
+    getAttribLocation(program: WebGLProgram, name: string): number;
+    /**
+     * ```
+     * gl.getUniformLocation(program, name);
+     * ```
+     *
+     * @param program
+     * @param name
+     * @returns
+     */
+    getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation | null;
+    /**
+     * ```
+     * gl.enableVertexAttribArray(index);
+     * ```
+     *
+     * @param index
+     */
+    enableVertexAttribArray(index: number): void;
+    /**
+     * ```
+     * gl.disableVertexAttribArray(index);
+     * ```
+     *
+     * @param index
+     */
+    disableVertexAttribArray(index: number): void;
+    /**
+     * ```
+     * gl.createShader(type);
+     * ```
+     *
+     * @param type
+     * @returns
+     */
+    createShader(type: number): WebGLShader | null;
+    /**
+     * ```
+     * gl.compileShader(shader);
+     * ```
+     *
+     * @param shader
+     * @returns
+     */
+    compileShader(shader: WebGLShader): void;
+    /**
+     * ```
+     * gl.attachShader(program, shader);
+     * ```
+     *
+     * @param program
+     * @param shader
+     */
+    attachShader(program: WebGLProgram, shader: WebGLShader): void;
+    /**
+     * ```
+     * gl.linkProgram(program);
+     * ```
+     *
+     * @param program
+     */
+    linkProgram(program: WebGLProgram): void;
+    /**
+     * ```
+     * gl.deleteProgram(shader);
+     * ```
+     *
+     * @param shader
+     */
+    deleteProgram(shader: WebGLProgram): void;
+    /**
+     * ```
+     * gl.getShaderParameter(shader, pname);
+     * ```
+     *
+     * @param shader
+     * @param pname
+     */
+    getShaderParameter(shader: WebGLShader, pname: GLenum): any;
+    /**
+     * ```
+     * gl.getShaderInfoLog(shader);
+     * ```
+     *
+     * @param shader
+     */
+    getShaderInfoLog(shader: WebGLShader): string | null;
+    /**
+     * ```
+     * gl.createProgram();
+     * ```
+     *
+     * @returns
+     */
+    createProgram(): WebGLProgram | null;
+    /**
+     * ```
+     * gl.getProgramParameter(program, pname);
+     * ```
+     *
+     * @param program
+     * @param pname
+     * @returns
+     */
+    getProgramParameter(program: WebGLProgram, pname: GLenum): any;
+}
+type IsUniformMethod<MethodName, MethodType> = MethodName extends `uniform${string}` ? MethodType extends (location: WebGLUniformLocation | null, ...args: any[]) => void ? true : false : false;
+export type UniformMethodMap = {
+    [Key in keyof WebGLRenderingContext as IsUniformMethod<Key, WebGLRenderingContext[Key]> extends true ? Key : never]: WebGLRenderingContext[Key] extends (location: WebGLUniformLocation | null, ...args: infer T) => void ? T : never;
+};
+/**
+ *
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function compareArrays<T>(a: T[], b: T[]): boolean;
+export {};