gl-draw 0.15.20 → 0.15.21

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,11 +20,11 @@ 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;
-    useMaterial(type: string): void;
+    handleMaterialChange(mat: MeshLineMaterial | null): void;
     animate({ duration, delay, repeat, lineLoop, onRepeat, onUpdate, onComplete, startShow, }?: {
         duration?: number;
         delay?: number;

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[][] | 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,75 @@
-import { Texture, Color, Vector2, ShaderMaterial } from 'three';
-export interface MeshLineMaterialParameters {
-    name?: string;
+import { Color, type ColorRepresentation, ShaderMaterial, type ShaderMaterialParameters, Texture, Vector2 } from 'three';
+export interface MeshLineMaterialParameters extends ShaderMaterialParameters {
+    /**
+     * Line width
+     * @default 1
+     */
     lineWidth?: number;
-    map?: Texture;
-    useMap?: number;
-    alphaMap?: Texture;
-    useAlphaMap?: number;
-    color?: string | Color | number;
+    /**
+     * Line color
+     * @default '#ffffff'
+     */
+    color?: ColorRepresentation;
     opacity?: number;
-    resolution?: Vector2;
-    sizeAttenuation?: number;
-    dashArray?: number;
+    /**
+     * Texture map
+     */
+    map?: Texture;
+    /**
+     * 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);
+    get color(): Color;
+    set color(value: ColorRepresentation);
+    get opacity(): number;
+    set opacity(value: number);
+    get map(): Texture | null;
+    set map(value: Texture | null);
+    get repeat(): Vector2;
+    set repeat(value: Vector2);
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    get sizeAttenuation(): boolean;
+    set sizeAttenuation(value: boolean);
 }

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

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

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

@@ -1,2 +1,3 @@
 export * from './MeshLineGeometry';
 export * from './MeshLineMaterial';
+export * from './raycast';

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

@@ -0,0 +1,3 @@
+import { BufferGeometry, Intersection, Mesh, Raycaster } from 'three';
+import { MeshLineMaterial } from './MeshLineMaterial';
+export declare function MeshLineRaycast(this: Mesh<BufferGeometry, MeshLineMaterial>, raycaster: Raycaster, intersects: Intersection[]): void;

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

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