9805007446

Committed 05 Jul 2024 07:56AM UTC coverage: 89.28% (+0.03%) from 89.253%

Build # 9805007446

Build Type

Pull #9008

github

Committed by

web-flow

Commit Message

Merge 3b0194a02 into f8723cb97

Pull Request Pull Request #9008: WIP: Layers UBO

Run Details

6524 of 7162 branches covered (91.09%)

Branch coverage included in aggregate %.

291 of 292 new or added lines in 17 files covered. (99.66%)

4 existing lines in 1 file now uncovered.

54145 of 60792 relevant lines covered (89.07%)

6357.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.3

/modules/layers/src/path-layer/path-layer.ts

// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

import {Layer, project32, picking, UNIT} from '@deck.gl/core';
import {Geometry} from '@luma.gl/engine';
import {Model} from '@luma.gl/engine';
import PathTesselator from './path-tesselator';

import vs from './path-layer-vertex.glsl';
import fs from './path-layer-fragment.glsl';

import type {
  LayerProps,
  LayerDataSource,
  Color,
  Accessor,
  AccessorFunction,
  Unit,
  UpdateParameters,
  GetPickingInfoParams,
  PickingInfo,
  DefaultProps
} from '@deck.gl/core';
import type {PathGeometry} from './path';

type _PathLayerProps<DataT> = {
  data: LayerDataSource<DataT>;
  /** The units of the line width, one of `'meters'`, `'common'`, and `'pixels'`
   * @default 'meters'
   */
  widthUnits?: Unit;
  /**
   * Path width multiplier.
   * @default 1
   */
  widthScale?: number;
  /**
   * The minimum path width in pixels. This prop can be used to prevent the path from getting too thin when zoomed out.
   * @default 0
   */
  widthMinPixels?: number;
  /**
   * The maximum path width in pixels. This prop can be used to prevent the path from getting too thick when zoomed in.
   * @default Number.MAX_SAFE_INTEGER
   */
  widthMaxPixels?: number;
  /**
   * Type of joint. If `true`, draw round joints. Otherwise draw miter joints.
   * @default false
   */
  jointRounded?: boolean;
  /**
   * Type of caps. If `true`, draw round caps. Otherwise draw square caps.
   * @default false
   */
  capRounded?: boolean;
  /**
   * The maximum extent of a joint in ratio to the stroke width. Only works if `jointRounded` is `false`.
   * @default 4
   */
  miterLimit?: number;
  /**
   * If `true`, extrude the path in screen space (width always faces the camera).
   * If `false`, the width always faces up (z).
   * @default false
   */
  billboard?: boolean;
  /**
   * (Experimental) If `'loop'` or `'open'`, will skip normalizing the coordinates returned by `getPath` and instead assume all paths are to be loops or open paths.
   * When normalization is disabled, paths must be specified in the format of flat array. Open paths must contain at least 2 vertices and closed paths must contain at least 3 vertices.
   * @default null
   */
  _pathType?: null | 'loop' | 'open';
  /**
   * Path geometry accessor.
   */
  getPath?: AccessorFunction<DataT, PathGeometry>;
  /**
   * Path color accessor.
   * @default [0, 0, 0, 255]
   */
  getColor?: Accessor<DataT, Color | Color[]>;
  /**
   * Path width accessor.
   * @default 1
   */
  getWidth?: Accessor<DataT, number | number[]>;
  /**
   * @deprecated Use `jointRounded` and `capRounded` instead
   */
  rounded?: boolean;
};

export type PathLayerProps<DataT = unknown> = _PathLayerProps<DataT> & LayerProps;

const DEFAULT_COLOR: [number, number, number, number] = [0, 0, 0, 255];

const defaultProps: DefaultProps<PathLayerProps> = {
  widthUnits: 'meters',
  widthScale: {type: 'number', min: 0, value: 1},
  widthMinPixels: {type: 'number', min: 0, value: 0},
  widthMaxPixels: {type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER},
  jointRounded: false,
  capRounded: false,
  miterLimit: {type: 'number', min: 0, value: 4},
  billboard: false,
  _pathType: null,

  getPath: {type: 'accessor', value: (object: any) => object.path},
  getColor: {type: 'accessor', value: DEFAULT_COLOR},
  getWidth: {type: 'accessor', value: 1},

  // deprecated props
  rounded: {deprecatedFor: ['jointRounded', 'capRounded']}
};

const ATTRIBUTE_TRANSITION = {
  enter: (value, chunk) => {
    return chunk.length ? chunk.subarray(chunk.length - value.length) : value;
  }
};

/** Render lists of coordinate points as extruded polylines with mitering. */
export default class PathLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<
  ExtraPropsT & Required<_PathLayerProps<DataT>>
> {
  static defaultProps = defaultProps;
  static layerName = 'PathLayer';

  state!: {
    model?: Model;
    pathTesselator: PathTesselator;
  };

  getShaders() {
    return super.getShaders({vs, fs, modules: [project32, picking]}); // 'project' module added by default.
  }

  get wrapLongitude(): boolean {
    return false;
  }

  getBounds(): [number[], number[]] | null {
    return this.getAttributeManager()?.getBounds(['vertexPositions']);
  }

  initializeState() {
    const noAlloc = true;
    const attributeManager = this.getAttributeManager();
    /* eslint-disable max-len */
    attributeManager!.addInstanced({
      vertexPositions: {
        size: 3,
        // Start filling buffer from 1 vertex in
        vertexOffset: 1,
        type: 'float64',
        fp64: this.use64bitPositions(),
        transition: ATTRIBUTE_TRANSITION,
        accessor: 'getPath',
        // eslint-disable-next-line @typescript-eslint/unbound-method
        update: this.calculatePositions,
        noAlloc,
        shaderAttributes: {
          instanceLeftPositions: {
            vertexOffset: 0
          },
          instanceStartPositions: {
            vertexOffset: 1
          },
          instanceEndPositions: {
            vertexOffset: 2
          },
          instanceRightPositions: {
            vertexOffset: 3
          }
        }
      },
      instanceTypes: {
        size: 1,
        type: 'uint8',
        // eslint-disable-next-line @typescript-eslint/unbound-method
        update: this.calculateSegmentTypes,
        noAlloc
      },
      instanceStrokeWidths: {
        size: 1,
        accessor: 'getWidth',
        transition: ATTRIBUTE_TRANSITION,
        defaultValue: 1
      },
      instanceColors: {
        size: this.props.colorFormat.length,
        type: 'unorm8',
        accessor: 'getColor',
        transition: ATTRIBUTE_TRANSITION,
        defaultValue: DEFAULT_COLOR
      },
      instancePickingColors: {
        size: 4,
        type: 'uint8',
        accessor: (object, {index, target: value}) =>
          this.encodePickingColor(object && object.__source ? object.__source.index : index, value)
      }
    });
    /* eslint-enable max-len */

    this.setState({
      pathTesselator: new PathTesselator({
        fp64: this.use64bitPositions()
      })
    });
  }

  updateState(params: UpdateParameters<this>) {
    super.updateState(params);
    const {props, changeFlags} = params;

    const attributeManager = this.getAttributeManager();

    const geometryChanged =
      changeFlags.dataChanged ||
      (changeFlags.updateTriggersChanged &&
        (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPath));

    if (geometryChanged) {
      const {pathTesselator} = this.state;
      const buffers = (props.data as any).attributes || {};

      pathTesselator.updateGeometry({
        data: props.data,
        geometryBuffer: buffers.getPath,
        buffers,
        normalize: !props._pathType,
        loop: props._pathType === 'loop',
        getGeometry: props.getPath,
        positionFormat: props.positionFormat,
        wrapLongitude: props.wrapLongitude,
        // TODO - move the flag out of the viewport
        resolution: this.context.viewport.resolution,
        dataChanged: changeFlags.dataChanged
      });
      this.setState({
        numInstances: pathTesselator.instanceCount,
        startIndices: pathTesselator.vertexStarts
      });
      if (!changeFlags.dataChanged) {
        // Base `layer.updateState` only invalidates all attributes on data change
        // Cover the rest of the scenarios here
        attributeManager!.invalidateAll();
      }
    }

    if (changeFlags.extensionsChanged) {
      this.state.model?.destroy();
      this.state.model = this._getModel();
      attributeManager!.invalidateAll();
    }
  }

  getPickingInfo(params: GetPickingInfoParams): PickingInfo {
    const info = super.getPickingInfo(params);
    const {index} = info;
    const data = this.props.data as any[];

    // Check if data comes from a composite layer, wrapped with getSubLayerRow
    if (data[0] && data[0].__source) {
      // index decoded from picking color refers to the source index
      info.object = data.find(d => d.__source.index === index);
    }
    return info;
  }

  /** Override base Layer method */
  disablePickingIndex(objectIndex: number) {
    const data = this.props.data as any[];

    // Check if data comes from a composite layer, wrapped with getSubLayerRow
    if (data[0] && data[0].__source) {
      // index decoded from picking color refers to the source index
      for (let i = 0; i < data.length; i++) {
        if (data[i].__source.index === objectIndex) {
          this._disablePickingIndex(i);
        }
      }
    } else {
      super.disablePickingIndex(objectIndex);
    }
  }

  draw({uniforms}) {
    const {
      jointRounded,
      capRounded,
      billboard,
      miterLimit,
      widthUnits,
      widthScale,
      widthMinPixels,
      widthMaxPixels
    } = this.props;

    const model = this.state.model!;
    model.setUniforms(uniforms);
    model.setUniforms({
      jointType: Number(jointRounded),
      capType: Number(capRounded),
      billboard,
      widthUnits: UNIT[widthUnits],
      widthScale,
      miterLimit,
      widthMinPixels,
      widthMaxPixels
    });
    model.draw(this.context.renderPass);
  }

  protected _getModel(): Model {
    /*
     *       _
     *        "-_ 1                   3                       5
     *     _     "o---------------------o-------------------_-o
     *       -   / ""--..__              '.             _.-' /
     *   _     "@- - - - - ""--..__- - - - x - - - -_.@'    /
     *    "-_  /                   ""--..__ '.  _,-` :     /
     *       "o----------------------------""-o'    :     /
     *      0,2                            4 / '.  :     /
     *                                      /   '.:     /
     *                                     /     :'.   /
     *                                    /     :  ', /
     *                                   /     :     o
     */

    // prettier-ignore
    const SEGMENT_INDICES = [
      // start corner
      0, 1, 2,
      // body
      1, 4, 2,
      1, 3, 4,
      // end corner
      3, 5, 4
    ];

    // [0] position on segment - 0: start, 1: end
    // [1] side of path - -1: left, 0: center (joint), 1: right
    // prettier-ignore
    const SEGMENT_POSITIONS = [
      // bevel start corner
      0, 0,
      // start inner corner
      0, -1,
      // start outer corner
      0, 1,
      // end inner corner
      1, -1,
      // end outer corner
      1, 1,
      // bevel end corner
      1, 0
    ];

    return new Model(this.context.device, {
      ...this.getShaders(),
      id: this.props.id,
      bufferLayout: this.getAttributeManager()!.getBufferLayouts(),
      geometry: new Geometry({
        topology: 'triangle-list',
        attributes: {
          indices: new Uint16Array(SEGMENT_INDICES),
          positions: {value: new Float32Array(SEGMENT_POSITIONS), size: 2}
        }
      }),
      isInstanced: true
    });
  }

  protected calculatePositions(attribute) {
    const {pathTesselator} = this.state;

    attribute.startIndices = pathTesselator.vertexStarts;
    attribute.value = pathTesselator.get('positions');
  }

  protected calculateSegmentTypes(attribute) {
    const {pathTesselator} = this.state;

    attribute.startIndices = pathTesselator.vertexStarts;
    attribute.value = pathTesselator.get('segmentTypes');
  }
}

1	// Copyright (c) 2015 - 2017 Uber Technologies, Inc.	1✔
2	//	1✔
3	// Permission is hereby granted, free of charge, to any person obtaining a copy	1✔
4	// of this software and associated documentation files (the "Software"), to deal	1✔
5	// in the Software without restriction, including without limitation the rights	1✔
6	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell	1✔
7	// copies of the Software, and to permit persons to whom the Software is	1✔
8	// furnished to do so, subject to the following conditions:	1✔
9	//	1✔
10	// The above copyright notice and this permission notice shall be included in	1✔
11	// all copies or substantial portions of the Software.	1✔
12	//	1✔
13	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	1✔
14	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,	1✔
15	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE	1✔
16	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER	1✔
17	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,	1✔
18	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN	1✔
19	// THE SOFTWARE.	1✔
20		1✔
21	import {Layer, project32, picking, UNIT} from '@deck.gl/core';	1✔
22	import {Geometry} from '@luma.gl/engine';	1✔
23	import {Model} from '@luma.gl/engine';	1✔
24	import PathTesselator from './path-tesselator';	1✔
25		1✔
26	import vs from './path-layer-vertex.glsl';	1✔
27	import fs from './path-layer-fragment.glsl';	1✔
28		1✔
29	import type {	1✔
30	LayerProps,	1✔
31	LayerDataSource,	1✔
32	Color,	1✔
33	Accessor,	1✔
34	AccessorFunction,	1✔
35	Unit,	1✔
36	UpdateParameters,	1✔
37	GetPickingInfoParams,	1✔
38	PickingInfo,	1✔
39	DefaultProps	1✔
40	} from '@deck.gl/core';	1✔
41	import type {PathGeometry} from './path';	1✔
42		1✔
43	type _PathLayerProps<DataT> = {	1✔
44	data: LayerDataSource<DataT>;	1✔
45	/** The units of the line width, one of `'meters'`, `'common'`, and `'pixels'`	1✔
46	* @default 'meters'	1✔
47	*/	1✔
48	widthUnits?: Unit;	1✔
49	/**	1✔
50	* Path width multiplier.	1✔
51	* @default 1	1✔
52	*/	1✔
53	widthScale?: number;	1✔
54	/**	1✔
55	* The minimum path width in pixels. This prop can be used to prevent the path from getting too thin when zoomed out.	1✔
56	* @default 0	1✔
57	*/	1✔
58	widthMinPixels?: number;	1✔
59	/**	1✔
60	* The maximum path width in pixels. This prop can be used to prevent the path from getting too thick when zoomed in.	1✔
61	* @default Number.MAX_SAFE_INTEGER	1✔
62	*/	1✔
63	widthMaxPixels?: number;	1✔
64	/**	1✔
65	* Type of joint. If `true`, draw round joints. Otherwise draw miter joints.	1✔
66	* @default false	1✔
67	*/	1✔
68	jointRounded?: boolean;	1✔
69	/**	1✔
70	* Type of caps. If `true`, draw round caps. Otherwise draw square caps.	1✔
71	* @default false	1✔
72	*/	1✔
73	capRounded?: boolean;	1✔
74	/**	1✔
75	* The maximum extent of a joint in ratio to the stroke width. Only works if `jointRounded` is `false`.	1✔
76	* @default 4	1✔
77	*/	1✔
78	miterLimit?: number;	1✔
79	/**	1✔
80	* If `true`, extrude the path in screen space (width always faces the camera).	1✔
81	* If `false`, the width always faces up (z).	1✔
82	* @default false	1✔
83	*/	1✔
84	billboard?: boolean;	1✔
85	/**	1✔
86	* (Experimental) If `'loop'` or `'open'`, will skip normalizing the coordinates returned by `getPath` and instead assume all paths are to be loops or open paths.	1✔
87	* When normalization is disabled, paths must be specified in the format of flat array. Open paths must contain at least 2 vertices and closed paths must contain at least 3 vertices.	1✔
88	* @default null	1✔
89	*/	1✔
90	_pathType?: null \| 'loop' \| 'open';	1✔
91	/**	1✔
92	* Path geometry accessor.	1✔
93	*/	1✔
94	getPath?: AccessorFunction<DataT, PathGeometry>;	1✔
95	/**	1✔
96	* Path color accessor.	1✔
97	* @default [0, 0, 0, 255]	1✔
98	*/	1✔
99	getColor?: Accessor<DataT, Color \| Color[]>;	1✔
100	/**	1✔
101	* Path width accessor.	1✔
102	* @default 1	1✔
103	*/	1✔
104	getWidth?: Accessor<DataT, number \| number[]>;	1✔
105	/**	1✔
106	* @deprecated Use `jointRounded` and `capRounded` instead	1✔
107	*/	1✔
108	rounded?: boolean;	1✔
109	};	1✔
110		1✔
111	export type PathLayerProps<DataT = unknown> = _PathLayerProps<DataT> & LayerProps;	1✔
112		1✔
113	const DEFAULT_COLOR: [number, number, number, number] = [0, 0, 0, 255];	1✔
114		1✔
115	const defaultProps: DefaultProps<PathLayerProps> = {	1✔
116	widthUnits: 'meters',	1✔
117	widthScale: {type: 'number', min: 0, value: 1},	1✔
118	widthMinPixels: {type: 'number', min: 0, value: 0},	1✔
119	widthMaxPixels: {type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER},	1✔
120	jointRounded: false,	1✔
121	capRounded: false,	1✔
122	miterLimit: {type: 'number', min: 0, value: 4},	1✔
123	billboard: false,	1✔
124	_pathType: null,	1✔
125		1✔
126	getPath: {type: 'accessor', value: (object: any) => object.path},	1✔
127	getColor: {type: 'accessor', value: DEFAULT_COLOR},	1✔
128	getWidth: {type: 'accessor', value: 1},	1✔
129		1✔
130	// deprecated props	1✔
131	rounded: {deprecatedFor: ['jointRounded', 'capRounded']}	1✔
132	};	1✔
133		1✔
134	const ATTRIBUTE_TRANSITION = {	1✔
135	enter: (value, chunk) => {	1✔
UNCOV 136	return chunk.length ? chunk.subarray(chunk.length - value.length) : value;	×
137	}	×
138	};	1✔
139		1✔
140	/** Render lists of coordinate points as extruded polylines with mitering. */	1✔
141	export default class PathLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<	1✔
142	ExtraPropsT & Required<_PathLayerProps<DataT>>	1✔
143	> {	1✔
144	static defaultProps = defaultProps;	1✔
145	static layerName = 'PathLayer';	1✔
146		1✔
147	state!: {	1✔
148	model?: Model;	1✔
149	pathTesselator: PathTesselator;	1✔
150	};	1✔
151		1✔
152	getShaders() {	1✔
153	return super.getShaders({vs, fs, modules: [project32, picking]}); // 'project' module added by default.	127✔
154	}	127✔
155		1✔
156	get wrapLongitude(): boolean {	1✔
157	return false;	448✔
158	}	448✔
159		1✔
160	getBounds(): [number[], number[]] \| null {	1✔
UNCOV 161	return this.getAttributeManager()?.getBounds(['vertexPositions']);	×
162	}	×
163		1✔
164	initializeState() {	1✔
165	const noAlloc = true;	124✔
166	const attributeManager = this.getAttributeManager();	124✔
167	/* eslint-disable max-len */	124✔
168	attributeManager!.addInstanced({	124✔
169	vertexPositions: {	124✔
170	size: 3,	124✔
171	// Start filling buffer from 1 vertex in	124✔
172	vertexOffset: 1,	124✔
173	type: 'float64',	124✔
174	fp64: this.use64bitPositions(),	124✔
175	transition: ATTRIBUTE_TRANSITION,	124✔
176	accessor: 'getPath',	124✔
177	// eslint-disable-next-line @typescript-eslint/unbound-method	124✔
178	update: this.calculatePositions,	124✔
179	noAlloc,	124✔
180	shaderAttributes: {	124✔
181	instanceLeftPositions: {	124✔
182	vertexOffset: 0	124✔
183	},	124✔
184	instanceStartPositions: {	124✔
185	vertexOffset: 1	124✔
186	},	124✔
187	instanceEndPositions: {	124✔
188	vertexOffset: 2	124✔
189	},	124✔
190	instanceRightPositions: {	124✔
191	vertexOffset: 3	124✔
192	}	124✔
193	}	124✔
194	},	124✔
195	instanceTypes: {	124✔
196	size: 1,	124✔
197	type: 'uint8',	124✔
198	// eslint-disable-next-line @typescript-eslint/unbound-method	124✔
199	update: this.calculateSegmentTypes,	124✔
200	noAlloc	124✔
201	},	124✔
202	instanceStrokeWidths: {	124✔
203	size: 1,	124✔
204	accessor: 'getWidth',	124✔
205	transition: ATTRIBUTE_TRANSITION,	124✔
206	defaultValue: 1	124✔
207	},	124✔
208	instanceColors: {	124✔
209	size: this.props.colorFormat.length,	124✔
210	type: 'unorm8',	124✔
211	accessor: 'getColor',	124✔
212	transition: ATTRIBUTE_TRANSITION,	124✔
213	defaultValue: DEFAULT_COLOR	124✔
214	},	124✔
215	instancePickingColors: {	124✔
216	size: 4,	124✔
217	type: 'uint8',	124✔
218	accessor: (object, {index, target: value}) =>	124✔
219	this.encodePickingColor(object && object.__source ? object.__source.index : index, value)	10,142✔
220	}	124✔
221	});	124✔
222	/* eslint-enable max-len */	124✔
223		124✔
224	this.setState({	124✔
225	pathTesselator: new PathTesselator({	124✔
226	fp64: this.use64bitPositions()	124✔
227	})	124✔
228	});	124✔
229	}	124✔
230		1✔
231	updateState(params: UpdateParameters<this>) {	1✔
232	super.updateState(params);	247✔
233	const {props, changeFlags} = params;	247✔
234		247✔
235	const attributeManager = this.getAttributeManager();	247✔
236		247✔
237	const geometryChanged =	247✔
238	changeFlags.dataChanged \|\|	247✔
239	(changeFlags.updateTriggersChanged &&	80✔
240	(changeFlags.updateTriggersChanged.all \|\| changeFlags.updateTriggersChanged.getPath));	18✔
241		247✔
242	if (geometryChanged) {	247✔
243	const {pathTesselator} = this.state;	167✔
244	const buffers = (props.data as any).attributes \|\| {};	167✔
245		167✔
246	pathTesselator.updateGeometry({	167✔
247	data: props.data,	167✔
248	geometryBuffer: buffers.getPath,	167✔
249	buffers,	167✔
250	normalize: !props._pathType,	167✔
251	loop: props._pathType === 'loop',	167✔
252	getGeometry: props.getPath,	167✔
253	positionFormat: props.positionFormat,	167✔
254	wrapLongitude: props.wrapLongitude,	167✔
255	// TODO - move the flag out of the viewport	167✔
256	resolution: this.context.viewport.resolution,	167✔
257	dataChanged: changeFlags.dataChanged	167✔
258	});	167✔
259	this.setState({	167✔
260	numInstances: pathTesselator.instanceCount,	167✔
261	startIndices: pathTesselator.vertexStarts	167✔
262	});	167✔
263	if (!changeFlags.dataChanged) {	167!
UNCOV 264	// Base `layer.updateState` only invalidates all attributes on data change	×
265	// Cover the rest of the scenarios here	×
266	attributeManager!.invalidateAll();	×
267	}	×
268	}	167✔
269		247✔
270	if (changeFlags.extensionsChanged) {	247✔
271	this.state.model?.destroy();	127✔
272	this.state.model = this._getModel();	127✔
273	attributeManager!.invalidateAll();	127✔
274	}	127✔
275	}	247✔
276		1✔
277	getPickingInfo(params: GetPickingInfoParams): PickingInfo {	1✔
278	const info = super.getPickingInfo(params);	38✔
279	const {index} = info;	38✔
280	const data = this.props.data as any[];	38✔
281		38✔
282	// Check if data comes from a composite layer, wrapped with getSubLayerRow	38✔
283	if (data[0] && data[0].__source) {	38✔
284	// index decoded from picking color refers to the source index	27✔
285	info.object = data.find(d => d.__source.index === index);	27✔
286	}	27✔
287	return info;	38✔
288	}	38✔
289		1✔
290	/** Override base Layer method */	1✔
291	disablePickingIndex(objectIndex: number) {	1✔
292	const data = this.props.data as any[];	3✔
293		3✔
294	// Check if data comes from a composite layer, wrapped with getSubLayerRow	3✔
295	if (data[0] && data[0].__source) {	3!
UNCOV 296	// index decoded from picking color refers to the source index	×
297	for (let i = 0; i < data.length; i++) {	×
298	if (data[i].__source.index === objectIndex) {	×
299	this._disablePickingIndex(i);	×
300	}	×
301	}	×
302	} else {	3✔
303	super.disablePickingIndex(objectIndex);	3✔
304	}	3✔
305	}	3✔
306		1✔
307	draw({uniforms}) {	1✔
308	const {	450✔
309	jointRounded,	450✔
310	capRounded,	450✔
311	billboard,	450✔
312	miterLimit,	450✔
313	widthUnits,	450✔
314	widthScale,	450✔
315	widthMinPixels,	450✔
316	widthMaxPixels	450✔
317	} = this.props;	450✔
318		450✔
319	const model = this.state.model!;	450✔
320	model.setUniforms(uniforms);	450✔
321	model.setUniforms({	450✔
322	jointType: Number(jointRounded),	450✔
323	capType: Number(capRounded),	450✔
324	billboard,	450✔
325	widthUnits: UNIT[widthUnits],	450✔
326	widthScale,	450✔
327	miterLimit,	450✔
328	widthMinPixels,	450✔
329	widthMaxPixels	450✔
330	});	450✔
331	model.draw(this.context.renderPass);	450✔
332	}	450✔
333		1✔
334	protected _getModel(): Model {	1✔
335	/*	127✔
336	* _	127✔
337	* "-_ 1 3 5	127✔
338	* _ "o---------------------o-------------------_-o	127✔
339	* - / ""--..__ '. _.-' /	127✔
340	* _ "@- - - - - ""--..__- - - - x - - - -_.@' /	127✔
341	* "-_ / ""--..__ '. _,-` : /	127✔
342	* "o----------------------------""-o' : /	127✔
343	* 0,2 4 / '. : /	127✔
344	* / '.: /	127✔
345	* / :'. /	127✔
346	* / : ', /	127✔
347	* / : o	127✔
348	*/	127✔
349		127✔
350	// prettier-ignore	127✔
351	const SEGMENT_INDICES = [	127✔
352	// start corner	127✔
353	0, 1, 2,	127✔
354	// body	127✔
355	1, 4, 2,	127✔
356	1, 3, 4,	127✔
357	// end corner	127✔
358	3, 5, 4	127✔
359	];	127✔
360		127✔
361	// [0] position on segment - 0: start, 1: end	127✔
362	// [1] side of path - -1: left, 0: center (joint), 1: right	127✔
363	// prettier-ignore	127✔
364	const SEGMENT_POSITIONS = [	127✔
365	// bevel start corner	127✔
366	0, 0,	127✔
367	// start inner corner	127✔
368	0, -1,	127✔
369	// start outer corner	127✔
370	0, 1,	127✔
371	// end inner corner	127✔
372	1, -1,	127✔
373	// end outer corner	127✔
374	1, 1,	127✔
375	// bevel end corner	127✔
376	1, 0	127✔
377	];	127✔
378		127✔
379	return new Model(this.context.device, {	127✔
380	...this.getShaders(),	127✔
381	id: this.props.id,	127✔
382	bufferLayout: this.getAttributeManager()!.getBufferLayouts(),	127✔
383	geometry: new Geometry({	127✔
384	topology: 'triangle-list',	127✔
385	attributes: {	127✔
386	indices: new Uint16Array(SEGMENT_INDICES),	127✔
387	positions: {value: new Float32Array(SEGMENT_POSITIONS), size: 2}	127✔
388	}	127✔
389	}),	127✔
390	isInstanced: true	127✔
391	});	127✔
392	}	127✔
393		1✔
394	protected calculatePositions(attribute) {	1✔
395	const {pathTesselator} = this.state;	141✔
396		141✔
397	attribute.startIndices = pathTesselator.vertexStarts;	141✔
398	attribute.value = pathTesselator.get('positions');	141✔
399	}	141✔
400		1✔
401	protected calculateSegmentTypes(attribute) {	1✔
402	const {pathTesselator} = this.state;	167✔
403		167✔
404	attribute.startIndices = pathTesselator.vertexStarts;	167✔
405	attribute.value = pathTesselator.get('segmentTypes');	167✔
406	}	167✔
407	}	1✔

visgl / deck.gl / 9805007446

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous