figureone 0.15.10 → 1.0.1

package/types/js/figure/DrawingObjects/GLObject/GLObject.d.ts

@@ -0,0 +1,146 @@
+import Scene from '../../../tools/geometry/scene';
+import type { Type3DMatrix } from '../../../tools/m3';
+import WebGLInstance from '../../webgl/webgl';
+import type { TypeFragmentShader, TypeVertexShader } from '../../webgl/shaders';
+import { Rect } from '../../../tools/g2';
+import DrawingObject from '../DrawingObject';
+import type { TypeColor } from '../../../tools/types';
+/**
+ * `'BYTE' | 'UNSIGNED_BYTE' | 'SHORT' | 'UNSIGNED_SHORT' | 'FLOAT'`
+ * @group Shaders
+ */
+export type TypeGLBufferType = 'BYTE' | 'UNSIGNED_BYTE' | 'SHORT' | 'UNSIGNED_SHORT' | 'FLOAT';
+/**
+ * `'STATIC' | 'DYNAMIC'`
+ * @group Shaders
+ */
+export type TypeGLBufferUsage = 'STATIC' | 'DYNAMIC';
+/**
+ * `'FLOAT' | 'FLOAT_VECTOR' | 'INT' | 'INT_VECTOR'`
+ * @group Shaders
+ */
+export type TypeGLUniform = 'FLOAT' | 'FLOAT_VECTOR' | 'INT' | 'INT_VECTOR';
+/**
+ * FigureElementPrimitive that can be used to utilize custom shaders for WebGL.
+ *
+ * @group Misc Figure Element
+ */
+declare class GLObject extends DrawingObject {
+    gl: WebGLRenderingContext;
+    webgl: WebGLInstance;
+    glPrimitive: number;
+    z: number;
+    texture: {
+        id: string;
+        src?: string;
+        points: Array<number>;
+        buffer?: WebGLBuffer | null;
+        repeat?: boolean;
+        mapTo: Rect;
+        mapFrom: Rect;
+        data?: HTMLImageElement | null;
+        loadColor: TypeColor;
+        [key: string]: any;
+    } | null;
+    attributes: {
+        [attributeName: string]: {
+            buffer: WebGLBuffer | null;
+            size: number;
+            type: number;
+            normalize: boolean;
+            stride: number;
+            offset: number;
+            usage: number;
+            data: Array<number>;
+        };
+    };
+    points: Array<number>;
+    uniforms: {
+        [uniformName: string]: {
+            value: Array<number>;
+            method: (location: WebGLUniformLocation, name: string) => void;
+        };
+    };
+    numVertices: number;
+    state: 'loading' | 'loaded';
+    programIndex: number;
+    selectorProgramIndex: number;
+    onLoad: ((result: boolean, id: string) => void) | null | undefined;
+    vertexShader: TypeVertexShader;
+    fragmentShader: TypeFragmentShader;
+    selectorVertexShader: TypeVertexShader;
+    selectorFragmentShader: TypeFragmentShader;
+    constructor(webgl: WebGLInstance, vertexShader?: TypeVertexShader, fragmentShader?: TypeFragmentShader, selectorVertexShader?: TypeVertexShader, selectorFragShader?: TypeFragmentShader);
+    init(webgl: WebGLInstance): void;
+    initProgram(): void;
+    showShaders(): void;
+    showSelectorShaders(): void;
+    getCanvas(): HTMLCanvasElement | OffscreenCanvas;
+    setPrimitive(primitiveType: 'TRIANGLES' | 'POINTS' | 'TRIANGLE_FAN' | 'TRIANGLE_STRIP' | 'LINES' | 'LINE_LOOP' | 'LINE_STRIP' | 'FAN' | 'STRIP'): void;
+    initAttributes(): void;
+    setZ(z: number): void;
+    contextLost(): void;
+    updateTextureMap(points?: Array<number>): void;
+    /**
+     * Buffer a texture for the shape to be painted with.
+     */
+    addTexture(location: string, mapFrom?: Rect, mapTo?: Rect, mapToBuffer?: string, points?: Array<number>, repeat?: boolean, onLoad?: null | (() => void), loadColor?: TypeColor): void;
+    updateTexture(data: HTMLImageElement): void;
+    initTexture(force?: boolean): void;
+    createTextureMap(xMinGL?: number, xMaxGL?: number, yMinGL?: number, yMaxGL?: number, xMinTex?: number, xMaxTex?: number, yMinTex?: number, yMaxTex?: number): void;
+    addVertices(vertices: Array<number>, dimension?: 2 | 3, usage?: TypeGLBufferUsage): void;
+    addVertices3(vertices: Array<number>, usage?: TypeGLBufferUsage): void;
+    addNormals(normals: Array<number>, usage?: TypeGLBufferUsage): void;
+    addColors(colors: Array<number>, normalized?: boolean, usage?: TypeGLBufferUsage): void;
+    addAttribute(name: string, size: number, data: Array<number>, typeIn?: TypeGLBufferType, normalize?: boolean, stride?: number, offset?: number, usageIn?: TypeGLBufferUsage): void;
+    fillBuffer(name: string, data: Array<number>): void;
+    executeOnLoad(result: boolean, id: string): void;
+    resetTextureBuffer(deleteTexture?: boolean): void;
+    cleanup(deleteTexture?: boolean): void;
+    resetBuffers(deleteTexture?: boolean): void;
+    updateVertices(vertices: Array<number>): void;
+    updateVertices3(vertices: Array<number>): void;
+    updateAttribute(name: string, data: Array<number>): void;
+    _getStateProperties(): never[];
+    /**
+     * Get the current value of a uniform
+     */
+    getUniform(uniformName: string): number[];
+    /**
+     * Add a uniform.
+     *
+     * Length 16 corresponds to a 4x4 matrix and can only be
+     * `'FLOAT_VECTOR'` type.
+     *
+     * @param {string} uniformName The variable name used in the shader
+     * @param {1 | 2 | 3 | 4 | 16} length (`1`) number of values in uniform
+     * @param {'FLOAT' | 'FLOAT_VECTOR' | 'INT' | 'INT_VECTOR'} type type of
+     * value. Use '_VECTOR' suffix if using vector methods on the uniform in the
+     * shader (`'FLOAT'`).
+     * @param {number | Array<number> | null} initialValue initial value to use
+     * for uniform - if null then uniform will be all 0 (`null`)
+     */
+    addUniform(uniformName: string, length?: 1 | 2 | 3 | 4 | 16, type?: TypeGLUniform, initialValue?: number | Array<number> | null): void;
+    uploadUniform1f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4f(location: WebGLUniformLocation, name: string): void;
+    uploadUniform1fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform1iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4iv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform16fv(location: WebGLUniformLocation, name: string): void;
+    uploadUniform1i(location: WebGLUniformLocation, name: string): void;
+    uploadUniform2i(location: WebGLUniformLocation, name: string): void;
+    uploadUniform3i(location: WebGLUniformLocation, name: string): void;
+    uploadUniform4i(location: WebGLUniformLocation, name: string): void;
+    updateUniform(uniformName: string, value: number | Array<number>): void;
+    drawWithTransformMatrix(scene: Scene, worldMatrix: Type3DMatrix, color: TypeColor, numDrawVertices?: number, targetTexture?: boolean): void;
+    getPointCountForAngle(drawAngle?: number): number;
+    getPointCountForLength(drawLength: number): number;
+}
+export default GLObject;

package/types/js/figure/DrawingObjects/HTMLObject/HTMLObject.d.ts

@@ -0,0 +1,29 @@
+import { Point } from '../../../tools/g2';
+import DrawingObject from '../DrawingObject';
+import type { TypeColor } from '../../../tools/types';
+import type { Type3DMatrix } from '../../../tools/m3';
+import type Scene from '../../../tools/geometry/scene';
+declare class HTMLObject extends DrawingObject {
+    border: Array<Array<Point>>;
+    id: string;
+    location: Point;
+    element: HTMLElement;
+    parentDiv: HTMLElement;
+    xAlign: 'left' | 'right' | 'center';
+    yAlign: 'top' | 'bottom' | 'middle';
+    show: boolean;
+    lastMatrix: Array<number>;
+    lastColor: Array<number>;
+    forceDraw: boolean;
+    originalElement: HTMLElement;
+    copy: () => HTMLObject;
+    constructor(parentDiv: HTMLElement, id: string, location: Point, yAlign: "top" | "bottom" | "middle" | undefined, xAlign: "left" | "right" | "center" | undefined, originalElement: HTMLElement | Array<HTMLElement>);
+    _dup(): any;
+    setBorder(): void;
+    getBoundaries(): Array<Array<Point>>;
+    glToPixelSpace(p: Point): Point;
+    change(newHtml: any, lastDrawTransformMatrix?: any): void;
+    transformHtml(transformMatrix: Type3DMatrix, opacity?: number): void;
+    drawWithTransformMatrix(scene: Scene, worldMatrix: Type3DMatrix, color: TypeColor): void;
+}
+export default HTMLObject;

package/types/js/figure/DrawingObjects/TextObject/TextObject.d.ts

@@ -0,0 +1,94 @@
+import type { OBJ_Font, TypeColor, OBJ_GlyphModifiers } from '../../../tools/types';
+import type { OBJ_AtlasMap } from '../../webgl/Atlas';
+declare class FigureFont {
+    family: string;
+    weight: 'normal' | 'bold' | 'lighter' | 'bolder' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
+    style: 'normal' | 'italic';
+    src: HTMLImageElement | string;
+    id: string;
+    map: OBJ_AtlasMap;
+    glyphs: string | 'greek' | 'math' | 'mathExt' | 'common' | 'latin' | 'all' | 'numbers' | 'mathlatin' | Array<string>;
+    atlasSize: null | number;
+    loadColor: TypeColor;
+    size: number;
+    underline: false | {
+        width: number;
+        descent: number;
+        color?: TypeColor;
+    };
+    color: TypeColor;
+    outline: false | {
+        width: number;
+        fill: boolean;
+        color?: TypeColor;
+    };
+    opacity: number;
+    descent: number;
+    midDescent: number;
+    maxDescent: number;
+    midAscent: number;
+    maxAscent: number;
+    modifiers: OBJ_GlyphModifiers;
+    mods: Record<string, any>;
+    testString: string;
+    timeout: number;
+    maxCount: number;
+    atlasColor: boolean;
+    letterSpacing: number;
+    render: 'gl' | '2d' | 'html';
+    constructor(optionsIn?: OBJ_Font | FigureFont);
+    _state(): Record<string, any>;
+    getFamily(): string;
+    getFontID(isAtlas?: boolean): string;
+    getTextureID(): string;
+    getGlyphs(): string;
+    getGlyphsID(): any;
+    getTestStringID(): string;
+    getTestStringGlyphs(): string;
+    draw2D(ctx: CanvasRenderingContext2D, colorIn: TypeColor | null | number, text: string, locationX: number, locationY: number, scalingFactor?: number): void;
+    definition(): {
+        family: string;
+        style: "normal" | "italic";
+        size: number;
+        outline: false | {
+            width: number;
+            fill: boolean;
+            color?: TypeColor;
+        };
+        weight: "bold" | "normal" | "100" | "lighter" | "bolder" | "200" | "300" | "400" | "500" | "600" | "700" | "800" | "900";
+        color: number[];
+        opacity: number;
+        descent: number;
+        midDescent: number;
+        maxDescent: number;
+        midAscent: number;
+        maxAscent: number;
+        src: string | HTMLImageElement;
+        map: OBJ_AtlasMap;
+        loadColor: TypeColor;
+        glyphs: string | string[];
+        testString: string;
+        timeout: number;
+        maxCount: number;
+        modifiers: OBJ_GlyphModifiers;
+        underline: false | {
+            width: number;
+            descent: number;
+            color?: TypeColor;
+        };
+        atlasColor: boolean;
+        atlasSize: number | null;
+        render: "html" | "gl" | "2d";
+        letterSpacing: number;
+    };
+    measureText(text: string, aWidth?: number): {
+        ascent: number;
+        descent: number;
+    };
+    setFontInContext(ctx: CanvasRenderingContext2D, scalingFactor?: number): void;
+    setColorInContext(ctx: CanvasRenderingContext2D, color: TypeColor | null): void;
+    setStrokeColorInContext(ctx: CanvasRenderingContext2D, color: TypeColor | null): void;
+    _dup(): FigureFont;
+}
+export { // eslint-disable-next-line import/prefer-default-export
+FigureFont, };

package/types/js/figure/DrawingObjects/TextObject/glyphMeasures.d.ts

@@ -0,0 +1,7 @@
+declare function glyphMeasures(family: string, style: string, a: number, // max ascent
+ma: number, // mid ascent
+d: number, // max descent
+md: number, // mid descent
+d0: number, // min descent
+modifiers: Record<string, any>): any;
+export default glyphMeasures;

package/types/js/figure/DrawingObjects/VertexObject/VertexGeneric.d.ts

@@ -0,0 +1,21 @@
+import { Point, Rect } from '../../../tools/g2';
+import WebGLInstance from '../../webgl/webgl';
+import GLObject from '../GLObject/GLObject';
+import type { CPY_Step } from '../../geometries/copy/copy';
+declare class VertexGeneric extends GLObject {
+    width: number;
+    close: boolean;
+    copy: Array<CPY_Step>;
+    vertices: Array<Point>;
+    texOptions: {
+        location: string;
+        mapFrom: Rect;
+        mapTo: Rect;
+        repeat: boolean;
+    };
+    constructor(webgl: WebGLInstance, textureLocation?: string, textureVertexSpace?: Rect, textureCoords?: Rect, textureRepeat?: boolean);
+    getPointCountForAngle(drawAngle?: number): number;
+    getPointCountForLength(drawLength: number): number;
+    change(options: any): void;
+}
+export default VertexGeneric;

package/types/js/figure/DrawingObjects/VertexObject/VertexText.d.ts

@@ -0,0 +1,34 @@
+import { Point } from '../../../tools/g2';
+import WebGLInstance from '../../webgl/webgl';
+import VertexGeneric from './VertexGeneric';
+type TypeVertexInputTextOptions = {
+    text: string | null | undefined;
+    size: number | string | null | undefined;
+    family: string | null | undefined;
+    weight: number | null | undefined;
+    style: 'normal' | 'italic' | null | undefined;
+    xAlign: 'left' | 'center' | 'right' | null | undefined;
+    yAlign: 'top' | 'bottom' | 'middle' | 'baseline' | null | undefined;
+};
+declare class VertexText extends VertexGeneric {
+    ctx: any;
+    figureToPixelSpaceScale: Point;
+    figureToGLSpaceTransformMatrix: Array<number>;
+    text: string;
+    size: number | string;
+    family: string;
+    weight: number;
+    style: 'normal' | 'italic';
+    xAlign: 'left' | 'center' | 'right';
+    yAlign: 'top' | 'bottom' | 'middle' | 'baseline';
+    canvas: HTMLCanvasElement;
+    ascent: number;
+    descent: number;
+    height: number;
+    width: number;
+    constructor(webgl: WebGLInstance, textOptions: TypeVertexInputTextOptions);
+    resizeText(pixelToVertexSpaceScale?: Point): void;
+    calcAscentDescent(): void;
+    drawTextIntoBuffer(pixelToVertexSpaceScale?: Point): void;
+}
+export default VertexText;