gl-draw 0.15.0-beta.3 → 0.15.0-beta.30

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

@@ -1,7 +1,7 @@
 import { MeshLineGeometry } from './meshLine';
-import type { PointsRepresentation } from './meshLine/MeshLineGeometry';
+import type { PointsInput } from './meshLine/MeshLineGeometry';
 interface Options {
-    nodes: PointsRepresentation;
+    nodes: PointsInput;
     setPointWidth?: (p: number) => any;
 }
 declare const _default: (options: Options) => MeshLineGeometry;

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

@@ -1,11 +1,11 @@
 import { BufferGeometry } from 'three';
 import BaseObject from "../../core/BaseObject";
 import { MeshLineMaterial } from './meshLine';
+import type { PointsInput } from './meshLine/MeshLineGeometry';
 import type { MeshLineMaterialParameters } from './meshLine/MeshLineMaterial';
-import type { PointsRepresentation } from './meshLine/MeshLineGeometry';
 interface Options {
-    nodes?: PointsRepresentation;
-    nodesArr?: PointsRepresentation[];
+    nodes?: PointsInput;
+    nodesArr?: PointsInput[];
     geometry?: BufferGeometry;
     geometryArr?: BufferGeometry[];
     material?: MeshLineMaterial;
@@ -20,7 +20,7 @@ export default class Line extends BaseObject {
     constructor(options?: Partial<Options>);
     get material(): MeshLineMaterial;
     create(): Promise<void>;
-    setGeometry(nodes: PointsRepresentation, setPointWidth?: (p: number) => any): void;
+    setGeometry(nodes: PointsInput, setPointWidth?: (p: number) => any): void;
     getMaterial(materialOptions: Omit<MeshLineMaterialParameters, 'resolution'>): MeshLineMaterial;
     addGeometries(geometries: BufferGeometry[]): void;
     resize(w: number, h: number): void;

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

@@ -1,40 +1,21 @@
-import { BufferGeometry, Vector3, Vector2, Vector3Tuple, Vector2Tuple, BufferAttribute, Matrix4 } from 'three';
-export type PointsRepresentation = BufferGeometry | Float32Array | Vector3[] | Vector2[] | Vector3Tuple[] | Vector2Tuple[] | number[];
-export type WidthCallback = (p: number) => any;
+import { BufferGeometry, Matrix4, Vector2, Vector3 } from 'three';
+export type WidthCallback = (p: number) => number;
+export type PointsInput = Vector3[] | Vector2[] | number[][];
 export declare class MeshLineGeometry extends BufferGeometry {
     type: string;
-    isMeshLine: boolean;
-    positions: number[];
-    previous: number[];
-    next: number[];
-    side: number[];
-    width: number[];
-    indices_array: number[];
-    uvs: number[];
-    counters: number[];
-    widthCallback: WidthCallback | null;
-    _attributes: {
-        position: BufferAttribute;
-        previous: BufferAttribute;
-        next: BufferAttribute;
-        side: BufferAttribute;
-        width: BufferAttribute;
-        uv: BufferAttribute;
-        index: BufferAttribute;
-        counters: BufferAttribute;
-    };
-    _points: Float32Array | number[];
-    points: Float32Array | number[];
+    private pointCount;
+    private _points;
+    private shape;
+    private shapeFunction;
     matrixWorld: Matrix4;
-    constructor();
+    constructor(points?: PointsInput, shape?: 'none' | 'taper' | 'custom', shapeFunction?: WidthCallback);
+    private convertToVector3Array;
     setMatrixWorld(matrixWorld: Matrix4): void;
-    setPoints(points: PointsRepresentation, wcb?: WidthCallback): void;
-    compareV3(a: number, b: number): boolean;
-    copyV3(a: number): Vector3Tuple;
-    process(): void;
-    /**
-     * Fast method to advance the line by one position.  The oldest position is removed.
-     * @param position
-     */
-    advance({ x, y, z }: Vector3): void;
+    setPoints(points: PointsInput, shapeFunction?: WidthCallback): void;
+    private initializeGeometry;
+    private updateGeometry;
+    get points(): Vector3[];
+    set points(value: PointsInput);
+    updatePoints(points: PointsInput, shapeFunction?: WidthCallback): void;
+    setShape(shape: 'none' | 'taper' | 'custom', shapeFunction?: WidthCallback): void;
 }

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

@@ -1,49 +1,68 @@
-import { Texture, Color, Vector2, ShaderMaterial } from 'three';
-export interface MeshLineMaterialParameters {
-    name?: string;
+import { type ColorRepresentation, ShaderMaterial, type ShaderMaterialParameters, Texture, Vector2 } from 'three';
+export interface MeshLineMaterialParameters extends ShaderMaterialParameters {
+    /**
+     * Line width
+     * @default 1
+     */
     lineWidth?: number;
+    /**
+     * Line color
+     * @default '#ffffff'
+     */
+    color?: ColorRepresentation;
+    /**
+     * Texture map
+     */
     map?: Texture;
+    /**
+     * Whether to use texture map
+     * @default 0
+     */
     useMap?: number;
-    alphaMap?: Texture;
-    useAlphaMap?: number;
-    color?: string | Color | number;
-    opacity?: number;
-    resolution?: Vector2;
-    sizeAttenuation?: number;
-    dashArray?: number;
+    /**
+     * Dash offset for dashed lines
+     * @default 0
+     */
     dashOffset?: number;
+    /**
+     * Dash array for dashed lines
+     * @default 0
+     */
+    dashArray?: number;
+    /**
+     * Dash ratio for dashed lines
+     * @default 0
+     */
     dashRatio?: number;
-    useDash?: number;
-    visibility?: number;
+    /**
+     * Whether to apply size attenuation (alias for attenuate)
+     * @default true
+     */
+    sizeAttenuation?: boolean;
+    offsetLoop?: boolean;
+    /**
+     * Scale down factor
+     * @default 0
+     */
+    scaleDown?: number;
+    /**
+     * Alpha map texture
+     */
+    alphaMap?: Texture | undefined;
     alphaTest?: number;
+    /**
+     * Texture repeat
+     * @default Vector2(1, 1)
+     */
     repeat?: Vector2;
-    lineLightAnimation?: number;
-    time?: number;
-    size?: number;
-    speed?: number;
-    lightWidth?: number;
-    uCenter?: Vector2;
-    lightColor?: string | Color | number;
-    transparent?: boolean;
-    depthTest?: boolean;
+    /**
+     * Screen resolution for line width calculation
+     */
+    resolution?: Vector2;
+    offset?: Vector2;
 }
-export declare class MeshLineMaterial extends ShaderMaterial implements MeshLineMaterialParameters {
-    lineWidth: number;
-    map: Texture;
-    useMap: number;
-    alphaMap: Texture;
-    useAlphaMap: number;
-    color: Color;
-    opacity: number;
-    resolution: Vector2;
-    sizeAttenuation: number;
-    dashArray: number;
-    dashOffset: number;
-    dashRatio: number;
-    useDash: number;
-    useDepth: number;
-    visibility: number;
-    repeat: Vector2;
-    constructor(parameters: MeshLineMaterialParameters);
-    copy(source: MeshLineMaterial): this;
+export declare class MeshLineMaterial extends ShaderMaterial {
+    type: string;
+    constructor(parameters?: MeshLineMaterialParameters);
+    updateUniforms(parameters: Partial<MeshLineMaterialParameters>): void;
 }

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

@@ -0,0 +1 @@
+export declare const fragmentShader: string;

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

@@ -0,0 +1,4 @@
+export declare const setXYZXYZ: (array: number[], location: number, x: number, y: number, z: number) => void;
+export declare const setXY: (array: number[], location: number, x: number, y: number) => void;
+export declare const setXYZ: (array: number[], location: number, x: number, y: number, z: number) => void;
+export declare const setXYZW: (array: number[], location: number, x: number, y: number, z: number, w: number) => void;

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

@@ -0,0 +1 @@
+export declare const vertexShader: string;

package/dist/objects/line2/WebGPULineSegments2.d.ts

@@ -1,4 +1,4 @@
-export class LineSegments2 extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
+export class LineSegments2 extends Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> {
     constructor(geometry: LineSegmentsGeometry | undefined, material: any);
     isLineSegments2: boolean;
     type: string;

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

@@ -2,5 +2,5 @@ import { Vector3, BufferGeometry } from 'three';
 interface Options {
     points: Vector3[];
 }
-declare const _default: (options: Options) => BufferGeometry<import("three").NormalBufferAttributes>;
+declare const _default: (options: Options) => BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
 export default _default;

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

@@ -27,7 +27,11 @@ export default class extends BaseObject {
         index: import("three").BufferAttribute | null;
         indirect: import("three/src/renderers/common/IndirectStorageBufferAttribute").default | null;
         attributes: import("three").NormalBufferAttributes;
-        morphAttributes: Record<"position" | "normal" | "color", Array<import("three").BufferAttribute | import("three").InterleavedBufferAttribute>>;
+        morphAttributes: {
+            position?: Array<import("three").BufferAttribute | import("three").InterleavedBufferAttribute> | undefined;
+            normal?: Array<import("three").BufferAttribute | import("three").InterleavedBufferAttribute> | undefined;
+            color?: Array<import("three").BufferAttribute | import("three").InterleavedBufferAttribute> | undefined;
+        };
         morphTargetsRelative: boolean;
         groups: import("three").GeometryGroup[];
         boundingBox: import("three").Box3 | null;
@@ -67,18 +71,10 @@ export default class extends BaseObject {
         toNonIndexed(): import("three").BufferGeometry;
         clone(): any;
         dispose(): void;
-        addEventListener<T extends "dispose">(type: T, listener: import("three").EventListener<{
-            dispose: {};
-        }[T], T, any>): void;
-        hasEventListener<T extends "dispose">(type: T, listener: import("three").EventListener<{
-            dispose: {};
-        }[T], T, any>): boolean;
-        removeEventListener<T extends "dispose">(type: T, listener: import("three").EventListener<{
-            dispose: {};
-        }[T], T, any>): void;
-        dispatchEvent<T extends "dispose">(event: import("three").BaseEvent<T> & {
-            dispose: {};
-        }[T]): void;
+        addEventListener<T extends "dispose">(type: T, listener: import("three").EventListener<import("three").BufferGeometryEventMap[T], T, any>): void;
+        hasEventListener<T extends "dispose">(type: T, listener: import("three").EventListener<import("three").BufferGeometryEventMap[T], T, any>): boolean;
+        removeEventListener<T extends "dispose">(type: T, listener: import("three").EventListener<import("three").BufferGeometryEventMap[T], T, any>): void;
+        dispatchEvent<T extends "dispose">(event: import("three").BaseEvent<T> & import("three").BufferGeometryEventMap[T]): void;
     };
     handlePick(e: MouseEvent, scale?: number): any;
     setActive(index: number, scale?: number): any;

package/dist/plugins/Worker/createGeometry.d.ts

@@ -1,3 +1,3 @@
 import { BufferGeometry } from 'three';
-declare const _default: (attributes: any) => BufferGeometry<import("three").NormalBufferAttributes>;
+declare const _default: (attributes: any) => BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
 export default _default;