@next2d/webgl 1.14.20

package/dist/shader/CanvasToWebGLShader.d.ts

@@ -0,0 +1,85 @@
+import { WebGLShaderUniform } from "./WebGLShaderUniform";
+import type { CanvasToWebGLContext } from "../CanvasToWebGLContext";
+/**
+ * @class
+ */
+export declare class CanvasToWebGLShader {
+    private readonly _$gl;
+    private readonly _$context;
+    private readonly _$program;
+    private readonly _$uniform;
+    /**
+     * @param   {WebGL2RenderingContext} gl
+     * @param   {CanvasToWebGLContext}  context
+     * @param   {string} vertex_source
+     * @param   {string} fragment_source
+     * @constructor
+     * @public
+     */
+    constructor(gl: WebGL2RenderingContext, context: CanvasToWebGLContext, vertex_source: string, fragment_source: string);
+    /**
+     * @return {WebGLShaderUniform}
+     * @readonly
+     * @public
+     */
+    get uniform(): WebGLShaderUniform;
+    /**
+     * @param  {string} vertex_source
+     * @param  {string} fragment_source
+     * @return {WebGLProgram}
+     * @method
+     * @private
+     */
+    _$createProgram(vertex_source: string, fragment_source: string): WebGLProgram;
+    /**
+     * @return {void}
+     * @private
+     */
+    _$attachProgram(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$drawImage(): void;
+    /**
+     * @param  {number} begin
+     * @param  {number} end
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$drawGradient(begin: number, end: number): void;
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array_object
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$stroke(vertex_array_object: WebGLVertexArrayObject): void;
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array_object
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$fill(vertex_array_object: WebGLVertexArrayObject): void;
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array
+     * @param  {number} first
+     * @param  {number} count
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$containerClip(vertex_array: WebGLVertexArrayObject, first: number, count: number): void;
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array
+     * @param  {number} first
+     * @param  {number} count
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$drawPoints(vertex_array: WebGLVertexArrayObject, first: number, count: number): void;
+}

package/dist/shader/CanvasToWebGLShader.js

@@ -0,0 +1,192 @@
+import { WebGLShaderUniform } from "./WebGLShaderUniform";
+import { $getProgramId } from "@next2d/share";
+/**
+ * @class
+ */
+export class CanvasToWebGLShader {
+    /**
+     * @param   {WebGL2RenderingContext} gl
+     * @param   {CanvasToWebGLContext}  context
+     * @param   {string} vertex_source
+     * @param   {string} fragment_source
+     * @constructor
+     * @public
+     */
+    constructor(gl, context, vertex_source, fragment_source) {
+        /**
+         * @type {WebGL2RenderingContext}
+         * @private
+         */
+        this._$gl = gl;
+        /**
+         * @type {WebGL2RenderingContext}
+         * @private
+         */
+        this._$context = context;
+        /**
+         * @type {WebGLProgram}
+         * @private
+         */
+        this._$program = this._$createProgram(vertex_source, fragment_source);
+        /**
+         * @type {WebGLShaderUniform}
+         * @private
+         */
+        this._$uniform = new WebGLShaderUniform(gl, this._$program);
+    }
+    /**
+     * @return {WebGLShaderUniform}
+     * @readonly
+     * @public
+     */
+    get uniform() {
+        return this._$uniform;
+    }
+    /**
+     * @param  {string} vertex_source
+     * @param  {string} fragment_source
+     * @return {WebGLProgram}
+     * @method
+     * @private
+     */
+    _$createProgram(vertex_source, fragment_source) {
+        const program = this._$gl.createProgram();
+        if (!program) {
+            throw new Error("WebGL program error");
+        }
+        // control number
+        program.id = $getProgramId();
+        const vertexShader = this._$gl.createShader(this._$gl.VERTEX_SHADER);
+        if (!vertexShader) {
+            throw new Error("WebGL vertex shader error");
+        }
+        this._$gl.shaderSource(vertexShader, vertex_source);
+        this._$gl.compileShader(vertexShader);
+        const fragmentShader = this._$gl.createShader(this._$gl.FRAGMENT_SHADER);
+        if (!fragmentShader) {
+            throw new Error("WebGL fragment shader error");
+        }
+        this._$gl.shaderSource(fragmentShader, fragment_source);
+        this._$gl.compileShader(fragmentShader);
+        this._$gl.attachShader(program, vertexShader);
+        this._$gl.attachShader(program, fragmentShader);
+        this._$gl.linkProgram(program);
+        this._$gl.detachShader(program, vertexShader);
+        this._$gl.detachShader(program, fragmentShader);
+        this._$gl.deleteShader(vertexShader);
+        this._$gl.deleteShader(fragmentShader);
+        return program;
+    }
+    /**
+     * @return {void}
+     * @private
+     */
+    _$attachProgram() {
+        const shaderList = this._$context.shaderList;
+        if (shaderList.currentProgramId !== this._$program.id) {
+            shaderList.currentProgramId = this._$program.id;
+            this._$gl.useProgram(this._$program);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$drawImage() {
+        this._$attachProgram();
+        this._$uniform.bindUniforms();
+        this._$context.vao.bindCommonVertexArray();
+        this._$gl.drawArrays(this._$gl.TRIANGLE_STRIP, 0, 4);
+    }
+    /**
+     * @param  {number} begin
+     * @param  {number} end
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$drawGradient(begin, end) {
+        this._$attachProgram();
+        this._$uniform.bindUniforms();
+        this._$context.vao.bindGradientVertexArray(begin, end);
+        this._$gl.drawArrays(this._$gl.TRIANGLE_STRIP, 0, 4);
+    }
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array_object
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$stroke(vertex_array_object) {
+        // setup
+        this._$attachProgram();
+        // set alpha
+        this._$context.blend.reset();
+        // update data
+        this._$uniform.bindUniforms();
+        // bind vertex array
+        this._$context.vao.bind(vertex_array_object);
+        // draw
+        this._$gl.drawElements(this._$gl.TRIANGLES, vertex_array_object.indexCount, this._$gl.UNSIGNED_SHORT, 0);
+    }
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array_object
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$fill(vertex_array_object) {
+        // setup
+        this._$attachProgram();
+        // set alpha
+        this._$context.blend.reset();
+        // update data
+        this._$uniform.bindUniforms();
+        // bind vertex array
+        this._$context.vao.bind(vertex_array_object);
+        // draw fill
+        const indexRanges = vertex_array_object.indexRanges;
+        const range = indexRanges[indexRanges.length - 1];
+        const count = range.first + range.count;
+        this._$gl.drawArrays(this._$gl.TRIANGLES, 0, count);
+    }
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array
+     * @param  {number} first
+     * @param  {number} count
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$containerClip(vertex_array, first, count) {
+        // setup
+        this._$attachProgram();
+        // set alpha
+        this._$context.blend.reset();
+        // update data
+        this._$uniform.bindUniforms();
+        // bind vertex array
+        this._$context.vao.bind(vertex_array);
+        // draw fill
+        this._$gl.drawArrays(this._$gl.TRIANGLES, first, count);
+    }
+    /**
+     * @param  {WebGLVertexArrayObject} vertex_array
+     * @param  {number} first
+     * @param  {number} count
+     * @return {void}
+     * @method
+     * @public
+     */
+    _$drawPoints(vertex_array, first, count) {
+        // setup
+        this._$attachProgram();
+        // update data
+        this._$uniform.bindUniforms();
+        // bind vertex array
+        this._$context.vao.bind(vertex_array);
+        // draw fill
+        this._$gl.drawArrays(this._$gl.POINTS, first, count);
+    }
+}

package/dist/shader/CanvasToWebGLShaderList.d.ts

@@ -0,0 +1,70 @@
+import { ShapeShaderVariantCollection } from "./variants/ShapeShaderVariantCollection";
+import { GradientShapeShaderVariantCollection } from "./variants/GradientShapeShaderVariantCollection";
+import { GradientLUTShaderVariantCollection } from "./variants/GradientLUTShaderVariantCollection";
+import { FilterShaderVariantCollection } from "./variants/FilterShaderVariantCollection";
+import { BlendShaderVariantCollection } from "./variants/BlendShaderVariantCollection";
+import type { CanvasToWebGLContext } from "../CanvasToWebGLContext";
+/**
+ * @class
+ */
+export declare class CanvasToWebGLShaderList {
+    private _$currentProgramId;
+    private readonly _$shapeShaderVariants;
+    private readonly _$gradientShapeShaderVariants;
+    private readonly _$gradientLUTShaderVariants;
+    private readonly _$filterShaderVariants;
+    private readonly _$blendShaderVariants;
+    /**
+     * @param {CanvasToWebGLContext}  context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context: CanvasToWebGLContext, gl: WebGL2RenderingContext);
+    /**
+     * @member {number}
+     * @public
+     */
+    get currentProgramId(): number;
+    set currentProgramId(current_program_id: number);
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {ShapeShaderVariantCollection} shapeShaderVariants
+     * @return {ShapeShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get shapeShaderVariants(): ShapeShaderVariantCollection;
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {GradientShapeShaderVariantCollection} gradientShapeShaderVariants
+     * @return {GradientShapeShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get gradientShapeShaderVariants(): GradientShapeShaderVariantCollection;
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {GradientLUTShaderVariantCollection} gradientLUTShaderVariants
+     * @return {GradientLUTShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get gradientLUTShaderVariants(): GradientLUTShaderVariantCollection;
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {FilterShaderVariantCollection} filterShaderVariants
+     * @return {FilterShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get filterShaderVariants(): FilterShaderVariantCollection;
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {BlendShaderVariantCollection} blendShaderVariants
+     * @return {BlendShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get blendShaderVariants(): BlendShaderVariantCollection;
+}

package/dist/shader/CanvasToWebGLShaderList.js

@@ -0,0 +1,109 @@
+import { ShapeShaderVariantCollection } from "./variants/ShapeShaderVariantCollection";
+import { GradientShapeShaderVariantCollection } from "./variants/GradientShapeShaderVariantCollection";
+import { GradientLUTShaderVariantCollection } from "./variants/GradientLUTShaderVariantCollection";
+import { FilterShaderVariantCollection } from "./variants/FilterShaderVariantCollection";
+import { BlendShaderVariantCollection } from "./variants/BlendShaderVariantCollection";
+/**
+ * @class
+ */
+export class CanvasToWebGLShaderList {
+    /**
+     * @param {CanvasToWebGLContext}  context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context, gl) {
+        /**
+         * @type {number}
+         * @default -1
+         * @public
+         */
+        this._$currentProgramId = -1;
+        /**
+         * @type {ShapeShaderVariantCollection}
+         * @private
+         */
+        this._$shapeShaderVariants = new ShapeShaderVariantCollection(context, gl);
+        /**
+         * @type {GradientShapeShaderVariantCollection}
+         * @private
+         */
+        this._$gradientShapeShaderVariants = new GradientShapeShaderVariantCollection(context, gl);
+        /**
+         * @type {GradientLUTShaderVariantCollection}
+         * @private
+         */
+        this._$gradientLUTShaderVariants = new GradientLUTShaderVariantCollection(context, gl);
+        /**
+         * @type {FilterShaderVariantCollection}
+         * @private
+         */
+        this._$filterShaderVariants = new FilterShaderVariantCollection(context, gl);
+        /**
+         * @type {BlendShaderVariantCollection}
+         * @private
+         */
+        this._$blendShaderVariants = new BlendShaderVariantCollection(context, gl);
+    }
+    /**
+     * @member {number}
+     * @public
+     */
+    get currentProgramId() {
+        return this._$currentProgramId;
+    }
+    set currentProgramId(current_program_id) {
+        this._$currentProgramId = current_program_id;
+    }
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {ShapeShaderVariantCollection} shapeShaderVariants
+     * @return {ShapeShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get shapeShaderVariants() {
+        return this._$shapeShaderVariants;
+    }
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {GradientShapeShaderVariantCollection} gradientShapeShaderVariants
+     * @return {GradientShapeShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get gradientShapeShaderVariants() {
+        return this._$gradientShapeShaderVariants;
+    }
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {GradientLUTShaderVariantCollection} gradientLUTShaderVariants
+     * @return {GradientLUTShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get gradientLUTShaderVariants() {
+        return this._$gradientLUTShaderVariants;
+    }
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {FilterShaderVariantCollection} filterShaderVariants
+     * @return {FilterShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get filterShaderVariants() {
+        return this._$filterShaderVariants;
+    }
+    /**
+     * @memberof CanvasToWebGLShaderList#
+     * @property {BlendShaderVariantCollection} blendShaderVariants
+     * @return {BlendShaderVariantCollection}
+     * @readonly
+     * @public
+     */
+    get blendShaderVariants() {
+        return this._$blendShaderVariants;
+    }
+}

package/dist/shader/GradientLUTGenerator.d.ts

@@ -0,0 +1,36 @@
+import type { CanvasToWebGLContext } from "../CanvasToWebGLContext";
+/**
+ * @class
+ */
+export declare class GradientLUTGenerator {
+    private readonly _$context;
+    private readonly _$gl;
+    private readonly _$attachment;
+    private readonly _$maxLength;
+    private readonly _$rgbToLinearTable;
+    private readonly _$rgbIdentityTable;
+    /**
+     * @param {CanvasToWebGLContext}  context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context: CanvasToWebGLContext, gl: WebGL2RenderingContext);
+    /**
+     * @param  {array}   stops
+     * @param  {boolean} is_linear_space
+     * @return {WebGLTexture|null}
+     * @method
+     * @public
+     */
+    generateForShape(stops: any[], is_linear_space: boolean): WebGLTexture;
+    /**
+     * @param  {array} ratios
+     * @param  {array} colors
+     * @param  {array} alphas
+     * @return {WebGLTexture}
+     * @method
+     * @public
+     */
+    generateForFilter(ratios: number[], colors: number[], alphas: number[]): WebGLTexture;
+}

package/dist/shader/GradientLUTGenerator.js

@@ -0,0 +1,123 @@
+import { $Math } from "@next2d/share";
+/**
+ * @class
+ */
+export class GradientLUTGenerator {
+    /**
+     * @param {CanvasToWebGLContext}  context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context, gl) {
+        /**
+         * @type {CanvasToWebGLContext}
+         * @private
+         */
+        this._$context = context;
+        /**
+         * @type {WebGL2RenderingContext}
+         * @private
+         */
+        this._$gl = gl;
+        /**
+         * @type {AttachmentImpl}
+         * @private
+         */
+        this._$attachment = context
+            .frameBuffer
+            .createTextureAttachment(512, 1);
+        /**
+         * @type {number}
+         * @private
+         */
+        this._$maxLength = $Math.floor(gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS) * 0.75);
+        /**
+         * @type {Float32Array}
+         * @private
+         */
+        this._$rgbToLinearTable = new Float32Array(256);
+        /**
+         * @type {Float32Array}
+         * @private
+         */
+        this._$rgbIdentityTable = new Float32Array(256);
+        for (let i = 0; i < 256; i++) {
+            const t = i / 255;
+            this._$rgbToLinearTable[i] = $Math.pow(t, 2.23333333);
+            this._$rgbIdentityTable[i] = t;
+        }
+    }
+    /**
+     * @param  {array}   stops
+     * @param  {boolean} is_linear_space
+     * @return {WebGLTexture|null}
+     * @method
+     * @public
+     */
+    generateForShape(stops, is_linear_space) {
+        const currentAttachment = this
+            ._$context
+            .frameBuffer
+            .currentAttachment;
+        this._$context._$bind(this._$attachment);
+        const stopsLength = stops.length;
+        const variants = this
+            ._$context
+            .shaderList
+            .gradientLUTShaderVariants;
+        const table = is_linear_space
+            ? this._$rgbToLinearTable
+            : this._$rgbIdentityTable;
+        this._$context.blend.toOneZero();
+        for (let begin = 0; begin < stopsLength; begin += this._$maxLength - 1) {
+            const end = $Math.min(begin + this._$maxLength, stopsLength);
+            const shader = variants
+                .getGradientLUTShader(end - begin, is_linear_space);
+            const uniform = shader.uniform;
+            variants
+                .setGradientLUTUniformForShape(uniform, stops, begin, end, table);
+            shader._$drawGradient(begin === 0 ? 0 : stops[begin][0], end === stopsLength ? 1 : stops[end - 1][0]);
+        }
+        this._$context._$bind(currentAttachment);
+        if (!this._$attachment.texture) {
+            throw new Error("the texture is null.");
+        }
+        return this._$attachment.texture;
+    }
+    /**
+     * @param  {array} ratios
+     * @param  {array} colors
+     * @param  {array} alphas
+     * @return {WebGLTexture}
+     * @method
+     * @public
+     */
+    generateForFilter(ratios, colors, alphas) {
+        const currentAttachment = this
+            ._$context
+            .frameBuffer
+            .currentAttachment;
+        this._$context._$bind(this._$attachment);
+        const stopsLength = ratios.length;
+        const variants = this
+            ._$context
+            .shaderList
+            .gradientLUTShaderVariants;
+        this._$context.blend.toOneZero();
+        for (let begin = 0; begin < stopsLength; begin += this._$maxLength - 1) {
+            const end = $Math.min(begin + this._$maxLength, stopsLength);
+            const shader = variants
+                .getGradientLUTShader(end - begin, false);
+            const uniform = shader.uniform;
+            variants
+                .setGradientLUTUniformForFilter(uniform, ratios, colors, alphas, begin, end);
+            shader._$drawGradient(begin === 0 ? 0 : ratios[begin], end === stopsLength ? 1 : ratios[end - 1]);
+        }
+        this._$context._$bind(currentAttachment);
+        if (!this._$attachment.texture) {
+            throw new Error("the texture is null.");
+        }
+        return this._$attachment.texture;
+    }
+}

package/dist/shader/WebGLShaderUniform.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @class
+ */
+export declare class WebGLShaderUniform {
+    private readonly _$gl;
+    private readonly _$array;
+    private readonly _$map;
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param {WebGLProgram} program
+     * @constructor
+     * @public
+     */
+    constructor(gl: WebGL2RenderingContext, program: WebGLProgram);
+    /**
+     * @param  {string} name
+     * @return {Int32Array|Float32Array}
+     * @method
+     * @public
+     */
+    getArray(name: string): Int32Array | Float32Array;
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get textures(): Int32Array | Float32Array;
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get highp(): Int32Array | Float32Array;
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get mediump(): Int32Array | Float32Array;
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get integer(): Int32Array | Float32Array;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    bindUniforms(): void;
+}