gl-draw 0.6.2 → 0.6.3

package/dist/objects/line/coords2Vector.d.ts

@@ -0,0 +1,7 @@
+import { GeoProjection } from 'd3-geo';
+import * as THREE from 'three';
+export declare const getProjection: (options: {
+    center: [number, number];
+    scale: number;
+}) => GeoProjection;
+export declare const coords2Vector: (projection: GeoProjection, coords: [number, number][]) => THREE.Vector3[];

package/dist/objects/line/createGeometry.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from 'three';
+import { MeshLine } from './meshLine';
+interface Options {
+    nodes: THREE.Vector3[];
+    setPointWidth?: (p: number) => number;
+}
+declare const _default: (options: Options) => MeshLine;
+export default _default;

package/dist/objects/line/getWorkerGeometry.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+import type WorkerController from '../../plugins/Worker';
+declare type Coordinate = [number, number];
+declare const _default: (options: {
+    worker: WorkerController;
+    workerKey?: string | undefined;
+    coordinatesArr: Coordinate[][];
+    lineWidth: number[];
+    projection: {
+        center: [number, number];
+        scale: number;
+    };
+    cacheVersion?: string | undefined;
+}) => Promise<THREE.BufferGeometry>;
+export default _default;

package/dist/objects/line/index.d.ts

@@ -0,0 +1,44 @@
+import * as THREE from 'three';
+import { PlaybackControls } from 'popmotion';
+import BaseObject from '../../core/BaseObject';
+import { MeshLineMaterial } from './meshLine';
+interface Options {
+    nodes?: THREE.Vector3[];
+    nodesArr?: THREE.Vector3[][];
+    geometry?: THREE.BufferGeometry;
+    geometryArr?: THREE.BufferGeometry[];
+    key?: string;
+    useGroups?: boolean;
+    duration?: number;
+    delay?: number;
+    onComplete?: (...args: any[]) => void;
+    color?: string | THREE.Color | number;
+    lineWidth?: number;
+    sizeAttenuation?: number;
+    map?: THREE.Texture;
+    useMap?: number;
+    alphaMap?: THREE.Texture;
+    useAlphaMap?: number;
+    opacity?: number;
+    dashArray?: number;
+    dashOffset?: number;
+    dashRatio?: number;
+    useDash?: number;
+    visibility?: number;
+    alphaTest?: number;
+    repeat?: THREE.Vector2;
+    transparent?: boolean;
+    depthTest?: boolean;
+    setPointWidth?: (p: number) => number;
+}
+export default class Line extends BaseObject {
+    options: Options;
+    tween: PlaybackControls;
+    constructor(options?: Partial<Options>);
+    material: MeshLineMaterial;
+    create(): void;
+    resize(w: number, h: number): void;
+    animate(): void;
+    dispose(): void;
+}
+export {};

package/dist/objects/line/meshLine/index.d.ts

@@ -0,0 +1,89 @@
+import * as THREE from 'three';
+
+export class MeshLine extends THREE.BufferGeometry {
+  constructor();
+
+  geometry: MeshLine;
+
+  points: Float32Array | Array<number>;
+
+  isMeshLine: boolean;
+
+  setPoints(
+    points: Float32Array | Array<number>,
+    wcb?: (p: number) => any
+  ): void;
+
+  setMatrixWorld(matrixWorld: THREE.Matrix4): void;
+
+  setGeometry(g: THREE.BufferGeometry, c?: (p: number) => any): void;
+
+  raycast: (
+    raycaster: THREE.Raycaster,
+    intersects: THREE.Intersection[]
+  ) => void;
+
+  compareV3(a: number, b: number): number;
+
+  copyV3(a: number): [number, number, number];
+}
+
+export class MeshLineMaterial extends THREE.ShaderMaterial {
+  constructor(parameters?: {
+    resolution: THREE.Vector2; // required
+    lineWidth?: number;
+    map?: THREE.Texture;
+    useMap?: number;
+    alphaMap?: THREE.Texture;
+    useAlphaMap?: number;
+    color?: string | THREE.Color | number;
+    opacity?: number;
+    sizeAttenuation?: number;
+    dashArray?: number;
+    dashOffset?: number;
+    dashRatio?: number;
+    useDash?: number;
+    visibility?: number;
+    alphaTest?: number;
+    repeat?: THREE.Vector2;
+    transparent?: boolean;
+    depthTest?: boolean;
+  });
+
+  lineWidth: number;
+
+  map: THREE.Texture;
+
+  useMap: number;
+
+  alphaMap: THREE.Texture;
+
+  useAlphaMap: number;
+
+  color: THREE.Color | string | number;
+
+  opacity: number;
+
+  resolution: THREE.Vector2;
+
+  sizeAttenuation: number;
+
+  dashArray: number;
+
+  dashOffset: number;
+
+  dashRatio: number;
+
+  useDesh: number;
+
+  visibility: number;
+
+  alphaTest: number;
+
+  repeat: THREE.Vector2;
+}
+
+export function MeshLineRaycast(
+  raycaster: THREE.Raycaster,
+  intersects: THREE.Intersection[]
+): void;

package/dist/objects/line/meshLine/shader/fragment.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/dist/objects/line/meshLine/shader/vertex.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/dist/objects/line/w.d.ts

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

package/dist/objects/node/index.d.ts

@@ -0,0 +1,30 @@
+import * as THREE from 'three';
+import BaseObject from '../../core/BaseObject';
+import Cache from '../../plugins/Cache';
+import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+interface Options {
+    children: HTMLElement;
+    position?: THREE.Vector3;
+    event?: string;
+    eventTarge?: string[];
+    handler?: (event: Event) => void;
+    zIndexFix?: number;
+}
+export declare class Node extends BaseObject {
+    options: Options;
+    pickObject?: THREE.Sprite;
+    object3d: CSS2DObject;
+    element: HTMLDivElement;
+    constructor(options: Options);
+    get clickTarge(): HTMLDivElement[];
+    create(): void;
+    getMaterial(show: boolean): Promise<THREE.SpriteMaterial>;
+    createPickObject({ show, scale, position, cache, }: {
+        show?: boolean;
+        scale?: THREE.Vector3;
+        position?: THREE.Vector3;
+        cache?: Cache;
+    }): Promise<void>;
+    dispose(): void;
+}
+export default Node;

package/dist/objects/text/index.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import BaseObject from '../../core/BaseObject';
+interface Options {
+    position: THREE.Vector3;
+    text: string;
+    fontSize?: number;
+    scale?: number;
+    fontFamily?: string;
+    fontWeight?: string;
+    flipX?: boolean;
+    lookAt?: THREE.Vector3;
+    sprite?: boolean;
+    sizeAttenuation?: boolean;
+}
+export default class extends BaseObject {
+    options: Omit<Required<Options>, 'lookAt'> & Pick<Options, 'lookAt'>;
+    width: number;
+    canvas: HTMLCanvasElement;
+    constructor(options: Options);
+    create(): void;
+    setText(t: string, options?: Pick<Options, 'fontSize' | 'fontFamily' | 'flipX'>): void;
+}
+export {};

package/dist/objects/video/index.d.ts

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+import BaseObject from '../../core/BaseObject';
+import Cache from '../../plugins/Cache';
+interface Options {
+    src: string;
+    scale?: number;
+    position?: THREE.Vector3;
+    cache?: Cache;
+    transparent?: boolean;
+    blending?: THREE.Blending;
+    depthWrite?: boolean;
+    alphaTest?: number;
+    autoPlay?: boolean;
+    loop?: boolean;
+    format?: THREE.PixelFormat;
+    sprite?: boolean;
+}
+export default class extends BaseObject {
+    options: Options & {
+        autoPlay: boolean;
+        loop: boolean;
+    };
+    video: HTMLVideoElement;
+    constructor(options: Options);
+    getMaterial(): Promise<any>;
+    create(): Promise<void>;
+    setScale(n: number): void;
+    render(): void;
+    dispose(): void;
+}
+export {};

package/dist/plugins/Cache.d.ts

@@ -0,0 +1,8 @@
+export default class {
+    cache: Map<any, any>;
+    install(): void;
+    init(key: string): void;
+    get(key: string): any;
+    set(key: string, value: any): void;
+    dispose(): void;
+}

package/dist/plugins/Data.d.ts

@@ -0,0 +1,8 @@
+export default class DataController<T> {
+    data: Partial<T>;
+    install(): void;
+    cb?: (type: keyof T) => void;
+    setData(key: keyof T, value: any): void;
+    runAll(): void;
+    dispose(): void;
+}

package/dist/plugins/Draw.d.ts

@@ -0,0 +1,35 @@
+import { IBaseObject } from '../core/BaseObject';
+import Pencil from '../core/Pencil';
+declare type KeyOf<T extends object> = Extract<keyof T, string>;
+export default class Draw<T extends {
+    [key: string]: new (...args: any[]) => IBaseObject;
+}> {
+    pencil: Pencil;
+    private objects_;
+    private objectNamesToFactories;
+    private objects;
+    get objectsPromise(): Promise<any>[];
+    constructor(objects: T);
+    install(pencil: Pencil): void;
+    initObjectFactories(): void;
+    getObject<Y extends KeyOf<T>>(nameOrigin: Y, options?: {
+        key: string;
+    }): InstanceType<T[Y]> | undefined;
+    getAllObject<Y extends KeyOf<T>>(nameOrigin: Y, options?: {
+        key: string;
+    }): InstanceType<T[Y]>[];
+    draw<Y extends KeyOf<T>, U extends KeyOf<T> | `${KeyOf<T>}#${string}` | IBaseObject>(nameOrigin: Y, options?: ConstructorParameters<T[Y]>[0] extends undefined ? {
+        key?: string;
+        target?: U;
+    } : ConstructorParameters<T[Y]>[0] & {
+        key?: string;
+        target?: U;
+    }, target?: U): Promise<InstanceType<T[Y]>>;
+    private addMesh;
+    erase(...args: (KeyOf<T> | `${KeyOf<T>}#${string}` | InstanceType<T[keyof T]>)[]): void;
+    private removeMesh;
+    update(delta: number, elapsed: number): void;
+    setSize(width: number, height: number): void;
+    dispose(): void;
+}
+export {};

package/dist/plugins/Worker.d.ts

@@ -0,0 +1,31 @@
+declare type GetWk = () => Worker;
+interface Options {
+    cache?: boolean;
+    cacheVersion?: string;
+}
+export default class {
+    workerList: {
+        worker: Worker;
+        inUse: boolean;
+    }[];
+    options: Required<Options>;
+    constructor(options?: Options);
+    install(): void;
+    init(scriptURL: string | GetWk, length: number): void;
+    messageList: {
+        req: Record<string, any>;
+        options: {
+            cb: any;
+            cacheVersion?: string;
+        };
+        uuid: string;
+        inUse: boolean;
+    }[];
+    postMessage(req: Record<string, any>, options: {
+        cb: any;
+        cacheVersion?: string;
+    }): void;
+    checkMessage(): void;
+    dispose(): void;
+}
+export {};

package/dist/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Cache } from './Cache';
+export { default as Draw } from './Draw';
+export { default as Data } from './Data';
+export { default as Wk } from './Worker';