@next2d/webgl 1.18.12 → 3.0.0

package/src/VertexArrayObject.d.ts

@@ -0,0 +1,71 @@
+import type { IVertexArrayObject } from "./interface/IVertexArrayObject";
+import type { IStrokeVertexArrayObject } from "./interface/IStrokeVertexArrayObject";
+/**
+ * @description VertexArrayObjectの再利用のための配列のオブジェクトプール
+ *              Object pool of array for reusing VertexArrayObject
+ *
+ * @type {IVertexArrayObject[]}
+ * @protected
+ */
+export declare const $objectPool: IVertexArrayObject[];
+/**
+ * @description Stroke用のVertexArrayObjectの再利用のための配列のオブジェクトプール
+ *             Object pool of array for reusing VertexArrayObject for Stroke
+ *
+ * @type {IStrokeVertexArrayObject[]}
+ * @protected
+ */
+export declare const $strokeObjectPool: IStrokeVertexArrayObject[];
+/**
+ * @description 頂点バッファのデータ、
+ *             Vertex buffer data
+ *
+ * @type {Float32Array}
+ * @protected
+ */
+export declare const $vertexBufferData: Float32Array;
+/**
+ * @description インスタンス用のWebGLBuffer
+ *              WebGLBuffer for instance
+ *
+ * @type {WebGLBuffer}
+ * @protected
+ */
+export declare let $attributeWebGLBuffer: WebGLBuffer;
+/**
+ * @description インスタンス用のWebGLBufferをセット
+ *              Set the WebGLBuffer for the instance
+ *
+ * @param  {WebGL2RenderingContext} gl
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const $setAttributeWebGLBuffer: (gl: WebGL2RenderingContext) => void;
+/**
+ * @description インスタンス用のVertexArrayObject
+ *              VertexArrayObject for instance
+ *
+ * @type {IVertexArrayObject}
+ * @protected
+ */
+export declare let $instancedVertexArrayObject: IVertexArrayObject;
+/**
+ * @description インスタンス用のVertexArrayObjectをセット
+ *              Set the VertexArrayObject for the instance
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const $setInstancedVertexArrayObject: (vertex_array_object: IVertexArrayObject) => void;
+/**
+ * @description 矩形描画用のVertexArrayObjectを返却
+ *              Returns the VertexArrayObject for rectangle drawing
+ *
+ * @return {IVertexArrayObject}
+ * @method
+ * @protected
+ */
+export declare const $getRectVertexArrayObject: () => IVertexArrayObject;

package/src/VertexArrayObject.js

@@ -0,0 +1,87 @@
+import { execute as vertexArrayObjectCreateRectVertexArrayObjectUseCase } from "./VertexArrayObject/usecase/VertexArrayObjectCreateRectVertexArrayObjectUseCase";
+/**
+ * @description VertexArrayObjectの再利用のための配列のオブジェクトプール
+ *              Object pool of array for reusing VertexArrayObject
+ *
+ * @type {IVertexArrayObject[]}
+ * @protected
+ */
+export const $objectPool = [];
+/**
+ * @description Stroke用のVertexArrayObjectの再利用のための配列のオブジェクトプール
+ *             Object pool of array for reusing VertexArrayObject for Stroke
+ *
+ * @type {IStrokeVertexArrayObject[]}
+ * @protected
+ */
+export const $strokeObjectPool = [];
+/**
+ * @description 頂点バッファのデータ、
+ *             Vertex buffer data
+ *
+ * @type {Float32Array}
+ * @protected
+ */
+export const $vertexBufferData = new Float32Array([0, 0, 0, 1, 1, 0, 1, 1]);
+/**
+ * @description インスタンス用のWebGLBuffer
+ *              WebGLBuffer for instance
+ *
+ * @type {WebGLBuffer}
+ * @protected
+ */
+export let $attributeWebGLBuffer;
+/**
+ * @description インスタンス用のWebGLBufferをセット
+ *              Set the WebGLBuffer for the instance
+ *
+ * @param  {WebGL2RenderingContext} gl
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const $setAttributeWebGLBuffer = (gl) => {
+    $attributeWebGLBuffer = gl.createBuffer();
+};
+/**
+ * @description インスタンス用のVertexArrayObject
+ *              VertexArrayObject for instance
+ *
+ * @type {IVertexArrayObject}
+ * @protected
+ */
+export let $instancedVertexArrayObject;
+/**
+ * @description インスタンス用のVertexArrayObjectをセット
+ *              Set the VertexArrayObject for the instance
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const $setInstancedVertexArrayObject = (vertex_array_object) => {
+    $instancedVertexArrayObject = vertex_array_object;
+};
+/**
+ * @description 矩形描画用のVertexArrayObject
+ *              VertexArrayObject for rectangle drawing
+ *
+ * @type {IVertexArrayObject}
+ * @protected
+ */
+let $rectVertexArrayObject;
+/**
+ * @description 矩形描画用のVertexArrayObjectを返却
+ *              Returns the VertexArrayObject for rectangle drawing
+ *
+ * @return {IVertexArrayObject}
+ * @method
+ * @protected
+ */
+export const $getRectVertexArrayObject = () => {
+    if (!$rectVertexArrayObject) {
+        $rectVertexArrayObject = vertexArrayObjectCreateRectVertexArrayObjectUseCase();
+    }
+    return $rectVertexArrayObject;
+};

package/src/WebGLUtil.d.ts

@@ -0,0 +1,34 @@
+import type { Context } from "./Context";
+export declare let $RENDER_MAX_SIZE: number;
+export declare const $setRenderMaxSize: (size: number) => void;
+export declare let $samples: number;
+export declare const $setSamples: (samples: number) => void;
+export declare let $gl: WebGL2RenderingContext;
+export declare const $setWebGL2RenderingContext: (gl: WebGL2RenderingContext) => void;
+export declare let $context: Context;
+export declare const $setContext: (context: Context) => void;
+export declare const $enableScissorTest: () => void;
+export declare const $disableScissorTest: () => void;
+export declare const $resetScissorState: () => void;
+export declare const $enableStencilTest: () => void;
+export declare const $disableStencilTest: () => void;
+export declare const $resetStencilTestState: () => void;
+export declare const $clamp: (value: number, min: number, max: number, default_value?: number | null) => number;
+export declare const $getArray: (...args: any[]) => any[];
+export declare const $poolArray: (array?: any[] | null) => void;
+export declare const $upperPowerOfTwo: (v: number) => number;
+export declare const $getFloat32Array4: (f0?: number, f1?: number, f2?: number, f3?: number) => Float32Array;
+export declare const $poolFloat32Array4: (array: Float32Array) => void;
+export declare const $getFloat32Array9: (f0?: number, f1?: number, f2?: number, f3?: number, f4?: number, f5?: number, f6?: number, f7?: number, f8?: number) => Float32Array;
+export declare const $poolFloat32Array9: (array: Float32Array) => void;
+export declare const $getFloat32Array6: (f0?: number, f1?: number, f2?: number, f3?: number, f4?: number, f5?: number) => Float32Array;
+export declare const $poolFloat32Array6: (array: Float32Array) => void;
+export declare const $inverseMatrix: (m: Float32Array) => Float32Array;
+export declare let $viewportWidth: number;
+export declare let $viewportHeight: number;
+export declare const $setViewportSize: (viewport_width: number, viewport_height: number) => void;
+export declare const $linearGradientXY: (matrix: Float32Array) => Float32Array;
+export declare let $devicePixelRatio: number;
+export declare const $setDevicePixelRatio: (device_pixel_ratio: number) => void;
+export declare const $multiplyMatrices: (a: Float32Array, b: Float32Array) => Float32Array;
+export declare const $getUUID: () => string;

package/src/WebGLUtil.js

@@ -0,0 +1,175 @@
+export let $RENDER_MAX_SIZE = 2048;
+export const $setRenderMaxSize = (size) => {
+    $RENDER_MAX_SIZE = Math.max(2048, size / 2);
+};
+export let $samples = 4;
+export const $setSamples = (samples) => {
+    $samples = samples;
+};
+export let $gl;
+export const $setWebGL2RenderingContext = (gl) => {
+    $gl = gl;
+};
+export let $context;
+export const $setContext = (context) => {
+    $context = context;
+};
+let $scissorEnabled = false;
+export const $enableScissorTest = () => {
+    if (!$scissorEnabled) {
+        $scissorEnabled = true;
+        $gl.enable($gl.SCISSOR_TEST);
+    }
+};
+export const $disableScissorTest = () => {
+    if ($scissorEnabled) {
+        $scissorEnabled = false;
+        $gl.disable($gl.SCISSOR_TEST);
+    }
+};
+export const $resetScissorState = () => {
+    $scissorEnabled = false;
+};
+let $stencilTestEnabled = false;
+export const $enableStencilTest = () => {
+    if (!$stencilTestEnabled) {
+        $stencilTestEnabled = true;
+        $gl.enable($gl.STENCIL_TEST);
+    }
+};
+export const $disableStencilTest = () => {
+    if ($stencilTestEnabled) {
+        $stencilTestEnabled = false;
+        $gl.disable($gl.STENCIL_TEST);
+    }
+};
+export const $resetStencilTestState = () => {
+    $stencilTestEnabled = false;
+};
+export const $clamp = (value, min, max, default_value = null) => {
+    const number = +value;
+    return isNaN(number) && default_value !== null
+        ? default_value
+        : Math.min(Math.max(min, isNaN(number) ? 0 : number), max);
+};
+const $arrays = [];
+export const $getArray = (...args) => {
+    const array = $arrays.pop() || [];
+    if (args.length) {
+        array.push(...args);
+    }
+    return array;
+};
+export const $poolArray = (array = null) => {
+    if (!array) {
+        return;
+    }
+    if (array.length) {
+        array.length = 0;
+    }
+    $arrays.push(array);
+};
+export const $upperPowerOfTwo = (v) => {
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v++;
+    return v;
+};
+const $float32Array4 = [];
+export const $getFloat32Array4 = (f0 = 0, f1 = 0, f2 = 0, f3 = 0) => {
+    const array = $float32Array4.pop() || new Float32Array(4);
+    array[0] = f0;
+    array[1] = f1;
+    array[2] = f2;
+    array[3] = f3;
+    return array;
+};
+export const $poolFloat32Array4 = (array) => {
+    $float32Array4.push(array);
+};
+const $float32Array9 = [];
+export const $getFloat32Array9 = (f0 = 0, f1 = 0, f2 = 0, f3 = 0, f4 = 0, f5 = 0, f6 = 0, f7 = 0, f8 = 0) => {
+    const array = $float32Array9.pop() || new Float32Array(9);
+    array[0] = f0;
+    array[1] = f1;
+    array[2] = f2;
+    array[3] = f3;
+    array[4] = f4;
+    array[5] = f5;
+    array[6] = f6;
+    array[7] = f7;
+    array[8] = f8;
+    return array;
+};
+export const $poolFloat32Array9 = (array) => {
+    $float32Array9.push(array);
+};
+const $float32Array6 = [];
+export const $getFloat32Array6 = (f0 = 0, f1 = 0, f2 = 0, f3 = 0, f4 = 0, f5 = 0) => {
+    const array = $float32Array6.pop() || new Float32Array(6);
+    array[0] = f0;
+    array[1] = f1;
+    array[2] = f2;
+    array[3] = f3;
+    array[4] = f4;
+    array[5] = f5;
+    return array;
+};
+export const $poolFloat32Array6 = (array) => {
+    $float32Array6.push(array);
+};
+export const $inverseMatrix = (m) => {
+    const rdet = 1 / (m[0] * m[4] - m[3] * m[1]);
+    const tx = m[3] * m[7] - m[4] * m[6];
+    const ty = m[1] * m[6] - m[0] * m[7];
+    return $getFloat32Array9(m[4] * rdet, 0 - m[1] * rdet, 0, 0 - m[3] * rdet, m[0] * rdet, 0, tx * rdet, ty * rdet, 1);
+};
+export let $viewportWidth = 0;
+export let $viewportHeight = 0;
+export const $setViewportSize = (viewport_width, viewport_height) => {
+    $viewportWidth = viewport_width;
+    $viewportHeight = viewport_height;
+};
+export const $linearGradientXY = (matrix) => {
+    const x0 = -819.2 * matrix[0] - 819.2 * matrix[2] + matrix[4];
+    const x1 = 819.2 * matrix[0] - 819.2 * matrix[2] + matrix[4];
+    const x2 = -819.2 * matrix[0] + 819.2 * matrix[2] + matrix[4];
+    const y0 = -819.2 * matrix[1] - 819.2 * matrix[3] + matrix[5];
+    const y1 = 819.2 * matrix[1] - 819.2 * matrix[3] + matrix[5];
+    const y2 = -819.2 * matrix[1] + 819.2 * matrix[3] + matrix[5];
+    let vx2 = x2 - x0;
+    let vy2 = y2 - y0;
+    const r1 = Math.sqrt(vx2 * vx2 + vy2 * vy2);
+    if (r1) {
+        vx2 = vx2 / r1;
+        vy2 = vy2 / r1;
+    }
+    else {
+        vx2 = 0;
+        vy2 = 0;
+    }
+    const r2 = (x1 - x0) * vx2 + (y1 - y0) * vy2;
+    return $getFloat32Array4(x0 + r2 * vx2, y0 + r2 * vy2, x1, y1);
+};
+export let $devicePixelRatio = 1;
+export const $setDevicePixelRatio = (device_pixel_ratio) => {
+    $devicePixelRatio = device_pixel_ratio;
+};
+export const $multiplyMatrices = (a, b) => {
+    const a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5];
+    const b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5];
+    return $getFloat32Array6(a0 * b0 + a2 * b1, a1 * b0 + a3 * b1, a0 * b2 + a2 * b3, a1 * b2 + a3 * b3, a0 * b4 + a2 * b5 + a4, a1 * b4 + a3 * b5 + a5);
+};
+export const $getUUID = () => {
+    return typeof crypto?.randomUUID === "function"
+        ? crypto.randomUUID()
+        : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = Math.random() * 16 | 0;
+            const v = c === "x" ? r : r & 0x3 | 0x8;
+            return v.toString(16);
+        });
+};

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from "./Context";

package/src/index.js

@@ -0,0 +1 @@
+export * from "./Context";

package/src/interface/IAttachmentObject.d.ts

@@ -0,0 +1,14 @@
+import type { IColorBufferObject } from "./IColorBufferObject";
+import type { ITextureObject } from "./ITextureObject";
+import type { IStencilBufferObject } from "./IStencilBufferObject";
+export interface IAttachmentObject {
+    id: number;
+    width: number;
+    height: number;
+    clipLevel: number;
+    msaa: boolean;
+    mask: boolean;
+    color: IColorBufferObject | null;
+    texture: ITextureObject | null;
+    stencil: IStencilBufferObject | null;
+}

package/src/interface/IBlendMode.d.ts

@@ -0,0 +1 @@
+export type IBlendMode = "copy" | "add" | "alpha" | "darken" | "difference" | "erase" | "hardlight" | "invert" | "layer" | "lighten" | "multiply" | "normal" | "overlay" | "screen" | "subtract";

package/{dist/interface/BoundsImpl.d.ts → src/interface/IBounds.d.ts}

@@ -1,4 +1,4 @@
-export interface BoundsImpl {
+export interface IBounds {
     xMin: number;
     xMax: number;
     yMin: number;

package/{dist/interface/ClipObjectImpl.d.ts → src/interface/IClipObject.d.ts}

@@ -1,4 +1,4 @@
-export interface ClipObjectImpl {
+export interface IClipObject {
     vertexArrayObject: WebGLVertexArrayObject;
     matrixA: number;
     matrixB: number;

package/src/interface/IColorBufferObject.d.ts

@@ -0,0 +1,9 @@
+import type { IStencilBufferObject } from "./IStencilBufferObject";
+export interface IColorBufferObject {
+    resource: WebGLRenderbuffer;
+    stencil: IStencilBufferObject;
+    width: number;
+    height: number;
+    area: number;
+    dirty: boolean;
+}

package/src/interface/ICubicConverterReturnObject.d.ts

@@ -0,0 +1,4 @@
+export interface ICubicConverterReturnObject {
+    buffer: Float32Array;
+    count: number;
+}

package/src/interface/IFillMesh.d.ts

@@ -0,0 +1,4 @@
+export interface IFillMesh {
+    buffer: Float32Array;
+    indexCount: number;
+}

package/src/interface/IFillType.d.ts

@@ -0,0 +1 @@
+export type IFillType = "fill" | "linear" | "radial" | "bitmap" | "stroke";

package/src/interface/IGradientType.d.ts

@@ -0,0 +1 @@
+export type IGradientType = "linear" | "radial";

package/{dist/interface/GridImpl.d.ts → src/interface/IGrid.d.ts}

@@ -1,4 +1,4 @@
-export interface GridImpl {
+export interface IGrid {
     x: number;
     y: number;
     w: number;

package/src/interface/IInterpolationMethod.d.ts

@@ -0,0 +1 @@
+export type IInterpolationMethod = "rgb" | "linearRGB";

package/src/interface/IJointStyle.d.ts

@@ -0,0 +1 @@
+export type IJointStyle = "bevel" | "miter" | "round";

package/src/interface/IPath.d.ts

@@ -0,0 +1 @@
+export type IPath = Array<number | boolean>;

package/{dist/interface/PointImpl.d.ts → src/interface/IPoint.d.ts}

@@ -1,4 +1,4 @@
-export interface PointImpl {
+export interface IPoint {
     x: number;
     y: number;
 }

package/src/interface/IProgramObject.d.ts

@@ -0,0 +1,4 @@
+export interface IProgramObject {
+    id: number;
+    resource: WebGLProgram;
+}

package/src/interface/ISpreadMethod.d.ts

@@ -0,0 +1 @@
+export type ISpreadMethod = "pad" | "reflect" | "repeat";

package/src/interface/IStencilBufferObject.d.ts

@@ -0,0 +1,8 @@
+export interface IStencilBufferObject {
+    id: number;
+    resource: WebGLRenderbuffer;
+    width: number;
+    height: number;
+    area: number;
+    dirty: boolean;
+}

package/src/interface/IStrokeVertexArrayObject.d.ts

@@ -0,0 +1,6 @@
+import type { IVertexArrayObject } from "./IVertexArrayObject";
+export interface IStrokeVertexArrayObject extends IVertexArrayObject {
+    indexBuffer: WebGLBuffer;
+    indexLength: number;
+    indexCount: number;
+}

package/src/interface/IStrokeVertexArrayObject.js

@@ -0,0 +1 @@
+export {};

package/src/interface/ITextureObject.d.ts

@@ -0,0 +1,8 @@
+export interface ITextureObject {
+    id: number;
+    resource: WebGLTexture;
+    width: number;
+    height: number;
+    area: number;
+    smooth: boolean;
+}

package/src/interface/ITextureObject.js

@@ -0,0 +1 @@
+export {};

package/{dist/interface/UniformDataImpl.d.ts → src/interface/IUniformData.d.ts}

@@ -1,4 +1,4 @@
-export interface UniformDataImpl {
+export interface IUniformData {
     method?: Function;
     array?: Int32Array | Float32Array;
     assign?: number;

package/src/interface/IUniformData.js

@@ -0,0 +1 @@
+export {};

package/src/interface/IVertexArrayObject.d.ts

@@ -0,0 +1,6 @@
+export interface IVertexArrayObject {
+    id: string;
+    resource: WebGLVertexArrayObject;
+    vertexBuffer: WebGLBuffer;
+    vertexLength: number;
+}

package/src/interface/IVertexArrayObject.js

@@ -0,0 +1 @@
+export {};

package/dist/BezierConverter.d.ts

@@ -1,59 +0,0 @@
-/**
- * @class
- */
-export declare class BezierConverter {
-    readonly _$bezierConverterBuffer: Float32Array;
-    /**
-     * @constructor
-     * @public
-     */
-    constructor();
-    /**
-     * @param  {number} from_x
-     * @param  {number} from_y
-     * @param  {number} cx1
-     * @param  {number} cy1
-     * @param  {number} cx2
-     * @param  {number} cy2
-     * @param  {number} x
-     * @param  {number} y
-     * @return {void}
-     * @method
-     * @public
-     */
-    cubicToQuad(from_x: number, from_y: number, cx1: number, cy1: number, cx2: number, cy2: number, x: number, y: number): void;
-    /**
-     * @description 3次ベジェを、2つの3次ベジェに分割する
-     * @param  {number} p0
-     * @param  {number} p1
-     * @param  {number} p2
-     * @param  {number} p3
-     * @param  {number} p4
-     * @param  {number} p5
-     * @param  {number} p6
-     * @param  {number} p7
-     * @param  {number} offset1
-     * @param  {number} offset2
-     * @return void
-     * @method
-     * @private
-     */
-    _$split2Cubic(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, offset1: number, offset2: number): void;
-    /**
-     * @description 3次ベジェを、2つの2次ベジェに変換する
-     *
-     * @param  {number} p0
-     * @param  {number} p1
-     * @param  {number} p2
-     * @param  {number} p3
-     * @param  {number} p4
-     * @param  {number} p5
-     * @param  {number} p6
-     * @param  {number} p7
-     * @param  {number} offset
-     * @return {void}
-     * @method
-     * @private
-     */
-    _$split2Quad(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, offset: number): void;
-}