8556837587

Committed 04 Apr 2024 02:59PM UTC coverage: 89.978% (-0.004%) from 89.982%

Build # 8556837587

Build Type

push

github

Committed by

web-flow

Commit Message

fix(mesh-layers): ScenegraphLayer picking (#8752)

Run Details

6292 of 6924 branches covered (90.87%)

Branch coverage included in aggregate %.

17 of 18 new or added lines in 1 file covered. (94.44%)

1 existing line in 1 file now uncovered.

51560 of 57372 relevant lines covered (89.87%)

6707.42 hits per line

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

95.13

/modules/mesh-layers/src/scenegraph-layer/scenegraph-layer.ts

// Copyright (c) 2019 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, log} from '@deck.gl/core';
import type {Device} from '@luma.gl/core';
import {pbr} from '@luma.gl/shadertools';
import {ScenegraphNode, GroupNode, ModelNode, Model} from '@luma.gl/engine';
import {GLTFAnimator, PBREnvironment, createScenegraphsFromGLTF} from '@luma.gl/gltf';
import {GLTFLoader, postProcessGLTF} from '@loaders.gl/gltf';
import {waitForGLTFAssets} from './gltf-utils';

import {MATRIX_ATTRIBUTES, shouldComposeModelMatrix} from '../utils/matrix';

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

import {
  UpdateParameters,
  LayerContext,
  LayerProps,
  LayerDataSource,
  Position,
  Color,
  Accessor,
  DefaultProps
} from '@deck.gl/core';

type GLTFInstantiatorOptions = Parameters<typeof createScenegraphsFromGLTF>[2];

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

export type ScenegraphLayerProps<DataT = unknown> = _ScenegraphLayerProps<DataT> & LayerProps;

type _ScenegraphLayerProps<DataT> = {
  data: LayerDataSource<DataT>;
  // TODO - define in luma.gl
  /**
   * A url for a glTF model or scenegraph loaded via a [scenegraph loader](https://loaders.gl/docs/specifications/category-scenegraph)
   */
  scenegraph: any;
  /**
   * Create a luma.gl GroupNode from the resolved scenegraph prop
   */
  getScene?: (
    scenegraph: any,
    context: {device?: Device; layer: ScenegraphLayer<DataT>}
  ) => GroupNode;
  /**
   * Create a luma.gl GLTFAnimator from the resolved scenegraph prop
   */
  getAnimator?: (
    scenegraph: any,
    context: {device?: Device; layer: ScenegraphLayer<DataT>}
  ) => GLTFAnimator;
  /**
   * (Experimental) animation configurations. Requires `_animate` on deck object.
   */
  _animations?: {
    [name: number | string | '*']: {
      /** If the animation is playing */
      playing?: boolean;
      /** Start time of the animation, default `0` */
      startTime?: number;
      /** Speed multiplier of the animation, default `1` */
      speed?: number;
    };
  } | null;
  /**
   * (Experimental) lighting mode
   * @default 'flat'
   */
  _lighting?: 'flat' | 'pbr';
  /**
   * (Experimental) lighting environment. Requires `_lighting` to be `'pbr'`.
   */
  _imageBasedLightingEnvironment?:
    | PBREnvironment
    | ((context: {gl: WebGL2RenderingContext; layer: ScenegraphLayer<DataT>}) => PBREnvironment);

  /** Anchor position accessor. */
  getPosition?: Accessor<DataT, Position>;
  /** Color value or accessor.
   * @default [255, 255, 255, 255]
   */
  getColor?: Accessor<DataT, Color>;
  /**
   * Orientation in [pitch, yaw, roll] in degrees.
   * @see https://en.wikipedia.org/wiki/Euler_angles
   * @default [0, 0, 0]
   */
  getOrientation?: Accessor<DataT, [number, number, number]>;
  /**
   * Scaling factor of the model along each axis.
   * @default [1, 1, 1]
   */
  getScale?: Accessor<DataT, [number, number, number]>;
  /**
   * Translation from the anchor point, [x, y, z] in meters.
   * @default [0, 0, 0]
   */
  getTranslation?: Accessor<DataT, [number, number, number]>;
  /**
   * TransformMatrix. If specified, `getOrientation`, `getScale` and `getTranslation` are ignored.
   */
  getTransformMatrix?: Accessor<DataT, number[]>;
  /**
   * Multiplier to scale each geometry by.
   * @default 1
   */
  sizeScale?: number;
  /**
   * The minimum size in pixels for one unit of the scene.
   * @default 0
   */
  sizeMinPixels?: number;
  /**
   * The maximum size in pixels for one unit of the scene.
   * @default Number.MAX_SAFE_INTEGER
   */
  sizeMaxPixels?: number;
};

const defaultProps: DefaultProps<ScenegraphLayerProps> = {
  scenegraph: {type: 'object', value: null, async: true},
  getScene: gltf => {
    if (gltf && gltf.scenes) {
      // gltf post processor replaces `gltf.scene` number with the scene `object`
      return typeof gltf.scene === 'object' ? gltf.scene : gltf.scenes[gltf.scene || 0];
    }
    return gltf;
  },
  getAnimator: scenegraph => scenegraph && scenegraph.animator,
  _animations: null,

  sizeScale: {type: 'number', value: 1, min: 0},
  sizeMinPixels: {type: 'number', min: 0, value: 0},
  sizeMaxPixels: {type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER},

  getPosition: {type: 'accessor', value: (x: any) => x.position},
  getColor: {type: 'accessor', value: DEFAULT_COLOR},

  // flat or pbr
  _lighting: 'flat',
  // _lighting must be pbr for this to work
  _imageBasedLightingEnvironment: undefined,

  // yaw, pitch and roll are in degrees
  // https://en.wikipedia.org/wiki/Euler_angles
  // [pitch, yaw, roll]
  getOrientation: {type: 'accessor', value: [0, 0, 0]},
  getScale: {type: 'accessor', value: [1, 1, 1]},
  getTranslation: {type: 'accessor', value: [0, 0, 0]},
  // 4x4 matrix
  getTransformMatrix: {type: 'accessor', value: []},

  loaders: [GLTFLoader]
};

/** Render a number of instances of a complete glTF scenegraph. */
export default class ScenegraphLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<
  ExtraPropsT & Required<_ScenegraphLayerProps<DataT>>
> {
  static defaultProps = defaultProps;
  static layerName = 'ScenegraphLayer';

  state!: {
    scenegraph: GroupNode;
    animator: GLTFAnimator;
    models: Model[];
  };

  getShaders() {
    const modules = [project32, picking];

    if (this.props._lighting === 'pbr') {
      modules.push(pbr);
    }

    return super.getShaders({vs, fs, modules});
  }

  initializeState() {
    const attributeManager = this.getAttributeManager();
    // attributeManager is always defined for primitive layers
    attributeManager!.addInstanced({
      instancePositions: {
        size: 3,
        type: 'float64',
        fp64: this.use64bitPositions(),
        accessor: 'getPosition',
        transition: true
      },
      instanceColors: {
        type: 'unorm8',
        size: this.props.colorFormat.length,
        accessor: 'getColor',
        defaultValue: DEFAULT_COLOR,
        transition: true
      },
      instanceModelMatrix: MATRIX_ATTRIBUTES
    });
  }

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

    if (props.scenegraph !== oldProps.scenegraph) {
      this._updateScenegraph();
    } else if (props._animations !== oldProps._animations) {
      this._applyAnimationsProp(this.state.animator, props._animations);
    }
  }

  finalizeState(context: LayerContext) {
    super.finalizeState(context);
    this.state.scenegraph?.destroy();
  }

  get isLoaded(): boolean {
    return Boolean(this.state?.scenegraph && super.isLoaded);
  }

  private _updateScenegraph(): void {
    const props = this.props;
    const {device} = this.context;
    let scenegraphData: any = null;
    if (props.scenegraph instanceof ScenegraphNode) {
      // Signature 1: props.scenegraph is a proper luma.gl Scenegraph
      scenegraphData = {scenes: [props.scenegraph]};
    } else if (props.scenegraph && typeof props.scenegraph === 'object') {
      // Converts loaders.gl gltf to luma.gl scenegraph using the undocumented @luma.gl/experimental function
      const gltf = props.scenegraph;

      // Tiles3DLoader already processes GLTF
      const processedGLTF = gltf.json ? postProcessGLTF(gltf) : gltf;

      const gltfObjects = createScenegraphsFromGLTF(device, processedGLTF, this._getModelOptions());
      scenegraphData = {gltf: processedGLTF, ...gltfObjects};

      waitForGLTFAssets(gltfObjects).then(() => {
        this.setNeedsRedraw();
      }); // eslint-disable-line @typescript-eslint/no-floating-promises
    }

    const options = {layer: this, device: this.context.device};
    const scenegraph = props.getScene(scenegraphData, options);
    const animator = props.getAnimator(scenegraphData, options);

    if (scenegraph instanceof GroupNode) {
      this.state.scenegraph?.destroy();

      this._applyAnimationsProp(animator, props._animations);

      const models: Model[] = [];
      scenegraph.traverse(node => {
        if (node instanceof ModelNode) {
          models.push(node.model);
        }
      });

      this.setState({scenegraph, animator, models});
      this.getAttributeManager()!.invalidateAll();
    } else if (scenegraph !== null) {
      log.warn('invalid scenegraph:', scenegraph)();
    }
  }

  private _applyAnimationsProp(animator: GLTFAnimator, animationsProp: any): void {
    if (!animator || !animationsProp) {
      return;
    }

    const animations = animator.getAnimations();

    // sort() to ensure '*' comes first so that other values can override
    Object.keys(animationsProp)
      .sort()
      .forEach(key => {
        // Key can be:
        //  - number for index number
        //  - name for animation name
        //  - * to affect all animations
        const value = animationsProp[key];

        if (key === '*') {
          animations.forEach(animation => {
            Object.assign(animation, value);
          });
        } else if (Number.isFinite(Number(key))) {
          const number = Number(key);
          if (number >= 0 && number < animations.length) {
            Object.assign(animations[number], value);
          } else {
            log.warn(`animation ${key} not found`)();
          }
        } else {
          const findResult = animations.find(({name}) => name === key);
          if (findResult) {
            Object.assign(findResult, value);
          } else {
            log.warn(`animation ${key} not found`)();
          }
        }
      });
  }

  private _getModelOptions(): GLTFInstantiatorOptions {
    const {_imageBasedLightingEnvironment} = this.props;

    let env: PBREnvironment | undefined;
    if (_imageBasedLightingEnvironment) {
      if (typeof _imageBasedLightingEnvironment === 'function') {
        env = _imageBasedLightingEnvironment({gl: this.context.gl, layer: this});
      } else {
        env = _imageBasedLightingEnvironment;
      }
    }

    return {
      imageBasedLightingEnvironment: env,
      modelOptions: {
        id: this.props.id,
        isInstanced: true,
        bufferLayout: this.getAttributeManager()!.getBufferLayouts(),
        ...this.getShaders()
      },
      // tangents are not supported
      useTangents: false
    };
  }

  draw({context}) {
    if (!this.state.scenegraph) return;

    if (this.props._animations && this.state.animator) {
      this.state.animator.animate(context.timeline.getTime());
      this.setNeedsRedraw();
    }

    const {viewport, renderPass} = this.context;
    const {sizeScale, sizeMinPixels, sizeMaxPixels, opacity, coordinateSystem} = this.props;

    const numInstances = this.getNumInstances();
    this.state.scenegraph.traverse((node, {worldMatrix}) => {
      if (node instanceof ModelNode) {
        const {model} = node;
        model.setInstanceCount(numInstances);
        model.setUniforms({
          sizeScale,
          opacity,
          sizeMinPixels,
          sizeMaxPixels,
          composeModelMatrix: shouldComposeModelMatrix(viewport, coordinateSystem),
          sceneModelMatrix: worldMatrix,
          // Needed for PBR (TODO: find better way to get it)
          // eslint-disable-next-line camelcase
          u_Camera: model.uniforms.project_uCameraPosition
        });

        model.draw(renderPass);
      }
    });
  }
}

1	// Copyright (c) 2019 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, log} from '@deck.gl/core';	1✔
22	import type {Device} from '@luma.gl/core';	1✔
23	import {pbr} from '@luma.gl/shadertools';	1✔
24	import {ScenegraphNode, GroupNode, ModelNode, Model} from '@luma.gl/engine';	1✔
25	import {GLTFAnimator, PBREnvironment, createScenegraphsFromGLTF} from '@luma.gl/gltf';	1✔
26	import {GLTFLoader, postProcessGLTF} from '@loaders.gl/gltf';	1✔
27	import {waitForGLTFAssets} from './gltf-utils';	1✔
28		1✔
29	import {MATRIX_ATTRIBUTES, shouldComposeModelMatrix} from '../utils/matrix';	1✔
30		1✔
31	import vs from './scenegraph-layer-vertex.glsl';	1✔
32	import fs from './scenegraph-layer-fragment.glsl';	1✔
33		1✔
34	import {	1✔
35	UpdateParameters,	1✔
36	LayerContext,	1✔
37	LayerProps,	1✔
38	LayerDataSource,	1✔
39	Position,	1✔
40	Color,	1✔
41	Accessor,	1✔
42	DefaultProps	1✔
43	} from '@deck.gl/core';	1✔
44		1✔
45	type GLTFInstantiatorOptions = Parameters<typeof createScenegraphsFromGLTF>[2];	1✔
46		1✔
47	const DEFAULT_COLOR: [number, number, number, number] = [255, 255, 255, 255];	1✔
48		1✔
49	export type ScenegraphLayerProps<DataT = unknown> = _ScenegraphLayerProps<DataT> & LayerProps;	1✔
50		1✔
51	type _ScenegraphLayerProps<DataT> = {	1✔
52	data: LayerDataSource<DataT>;	1✔
53	// TODO - define in luma.gl	1✔
54	/**	1✔
55	* A url for a glTF model or scenegraph loaded via a [scenegraph loader](https://loaders.gl/docs/specifications/category-scenegraph)	1✔
56	*/	1✔
57	scenegraph: any;	1✔
58	/**	1✔
59	* Create a luma.gl GroupNode from the resolved scenegraph prop	1✔
60	*/	1✔
61	getScene?: (	1✔
62	scenegraph: any,	1✔
63	context: {device?: Device; layer: ScenegraphLayer<DataT>}	1✔
64	) => GroupNode;	1✔
65	/**	1✔
66	* Create a luma.gl GLTFAnimator from the resolved scenegraph prop	1✔
67	*/	1✔
68	getAnimator?: (	1✔
69	scenegraph: any,	1✔
70	context: {device?: Device; layer: ScenegraphLayer<DataT>}	1✔
71	) => GLTFAnimator;	1✔
72	/**	1✔
73	* (Experimental) animation configurations. Requires `_animate` on deck object.	1✔
74	*/	1✔
75	_animations?: {	1✔
76	[name: number \| string \| '*']: {	1✔
77	/** If the animation is playing */	1✔
78	playing?: boolean;	1✔
79	/** Start time of the animation, default `0` */	1✔
80	startTime?: number;	1✔
81	/** Speed multiplier of the animation, default `1` */	1✔
82	speed?: number;	1✔
83	};	1✔
84	} \| null;	1✔
85	/**	1✔
86	* (Experimental) lighting mode	1✔
87	* @default 'flat'	1✔
88	*/	1✔
89	_lighting?: 'flat' \| 'pbr';	1✔
90	/**	1✔
91	* (Experimental) lighting environment. Requires `_lighting` to be `'pbr'`.	1✔
92	*/	1✔
93	_imageBasedLightingEnvironment?:	1✔
94	\| PBREnvironment	1✔
95	\| ((context: {gl: WebGL2RenderingContext; layer: ScenegraphLayer<DataT>}) => PBREnvironment);	1✔
96		1✔
97	/** Anchor position accessor. */	1✔
98	getPosition?: Accessor<DataT, Position>;	1✔
99	/** Color value or accessor.	1✔
100	* @default [255, 255, 255, 255]	1✔
101	*/	1✔
102	getColor?: Accessor<DataT, Color>;	1✔
103	/**	1✔
104	* Orientation in [pitch, yaw, roll] in degrees.	1✔
105	* @see https://en.wikipedia.org/wiki/Euler_angles	1✔
106	* @default [0, 0, 0]	1✔
107	*/	1✔
108	getOrientation?: Accessor<DataT, [number, number, number]>;	1✔
109	/**	1✔
110	* Scaling factor of the model along each axis.	1✔
111	* @default [1, 1, 1]	1✔
112	*/	1✔
113	getScale?: Accessor<DataT, [number, number, number]>;	1✔
114	/**	1✔
115	* Translation from the anchor point, [x, y, z] in meters.	1✔
116	* @default [0, 0, 0]	1✔
117	*/	1✔
118	getTranslation?: Accessor<DataT, [number, number, number]>;	1✔
119	/**	1✔
120	* TransformMatrix. If specified, `getOrientation`, `getScale` and `getTranslation` are ignored.	1✔
121	*/	1✔
122	getTransformMatrix?: Accessor<DataT, number[]>;	1✔
123	/**	1✔
124	* Multiplier to scale each geometry by.	1✔
125	* @default 1	1✔
126	*/	1✔
127	sizeScale?: number;	1✔
128	/**	1✔
129	* The minimum size in pixels for one unit of the scene.	1✔
130	* @default 0	1✔
131	*/	1✔
132	sizeMinPixels?: number;	1✔
133	/**	1✔
134	* The maximum size in pixels for one unit of the scene.	1✔
135	* @default Number.MAX_SAFE_INTEGER	1✔
136	*/	1✔
137	sizeMaxPixels?: number;	1✔
138	};	1✔
139		1✔
140	const defaultProps: DefaultProps<ScenegraphLayerProps> = {	1✔
141	scenegraph: {type: 'object', value: null, async: true},	1✔
142	getScene: gltf => {	1✔
143	if (gltf && gltf.scenes) {	4✔
144	// gltf post processor replaces `gltf.scene` number with the scene `object`	2✔
145	return typeof gltf.scene === 'object' ? gltf.scene : gltf.scenes[gltf.scene \|\| 0];	2!
146	}	2✔
147	return gltf;	2✔
148	},	4✔
149	getAnimator: scenegraph => scenegraph && scenegraph.animator,	1✔
150	_animations: null,	1✔
151		1✔
152	sizeScale: {type: 'number', value: 1, min: 0},	1✔
153	sizeMinPixels: {type: 'number', min: 0, value: 0},	1✔
154	sizeMaxPixels: {type: 'number', min: 0, value: Number.MAX_SAFE_INTEGER},	1✔
155		1✔
156	getPosition: {type: 'accessor', value: (x: any) => x.position},	1✔
157	getColor: {type: 'accessor', value: DEFAULT_COLOR},	1✔
158		1✔
159	// flat or pbr	1✔
160	_lighting: 'flat',	1✔
161	// _lighting must be pbr for this to work	1✔
162	_imageBasedLightingEnvironment: undefined,	1✔
163		1✔
164	// yaw, pitch and roll are in degrees	1✔
165	// https://en.wikipedia.org/wiki/Euler_angles	1✔
166	// [pitch, yaw, roll]	1✔
167	getOrientation: {type: 'accessor', value: [0, 0, 0]},	1✔
168	getScale: {type: 'accessor', value: [1, 1, 1]},	1✔
169	getTranslation: {type: 'accessor', value: [0, 0, 0]},	1✔
170	// 4x4 matrix	1✔
171	getTransformMatrix: {type: 'accessor', value: []},	1✔
172		1✔
173	loaders: [GLTFLoader]	1✔
174	};	1✔
175		1✔
176	/** Render a number of instances of a complete glTF scenegraph. */	1✔
177	export default class ScenegraphLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<	1✔
178	ExtraPropsT & Required<_ScenegraphLayerProps<DataT>>	1✔
179	> {	1✔
180	static defaultProps = defaultProps;	1✔
181	static layerName = 'ScenegraphLayer';	1✔
182		1✔
183	state!: {	1✔
184	scenegraph: GroupNode;	1✔
185	animator: GLTFAnimator;	1✔
186	models: Model[];	1✔
187	};	1✔
188		1✔
189	getShaders() {	1✔
190	const modules = [project32, picking];	2✔
191		2✔
192	if (this.props._lighting === 'pbr') {	2✔
193	modules.push(pbr);	2✔
194	}	2✔
195		2✔
196	return super.getShaders({vs, fs, modules});	2✔
197	}	2✔
198		1✔
199	initializeState() {	1✔
200	const attributeManager = this.getAttributeManager();	3✔
201	// attributeManager is always defined for primitive layers	3✔
202	attributeManager!.addInstanced({	3✔
203	instancePositions: {	3✔
204	size: 3,	3✔
205	type: 'float64',	3✔
206	fp64: this.use64bitPositions(),	3✔
207	accessor: 'getPosition',	3✔
208	transition: true	3✔
209	},	3✔
210	instanceColors: {	3✔
211	type: 'unorm8',	3✔
212	size: this.props.colorFormat.length,	3✔
213	accessor: 'getColor',	3✔
214	defaultValue: DEFAULT_COLOR,	3✔
215	transition: true	3✔
216	},	3✔
217	instanceModelMatrix: MATRIX_ATTRIBUTES	3✔
218	});	3✔
219	}	3✔
220		1✔
221	updateState(params: UpdateParameters<this>) {	1✔
222	super.updateState(params);	21✔
223	const {props, oldProps} = params;	21✔
224		21✔
225	if (props.scenegraph !== oldProps.scenegraph) {	21✔
226	this._updateScenegraph();	5✔
227	} else if (props._animations !== oldProps._animations) {	21✔
228	this._applyAnimationsProp(this.state.animator, props._animations);	2✔
229	}	2✔
230	}	21✔
231		1✔
232	finalizeState(context: LayerContext) {	1✔
233	super.finalizeState(context);	3✔
234	this.state.scenegraph?.destroy();	3✔
235	}	3✔
236		1✔
237	get isLoaded(): boolean {	1✔
238	return Boolean(this.state?.scenegraph && super.isLoaded);	23✔
239	}	23✔
240		1✔
241	private _updateScenegraph(): void {	1✔
242	const props = this.props;	5✔
243	const {device} = this.context;	5✔
244	let scenegraphData: any = null;	5✔
245	if (props.scenegraph instanceof ScenegraphNode) {	5!
246	// Signature 1: props.scenegraph is a proper luma.gl Scenegraph	×
247	scenegraphData = {scenes: [props.scenegraph]};	×
248	} else if (props.scenegraph && typeof props.scenegraph === 'object') {	5✔
249	// Converts loaders.gl gltf to luma.gl scenegraph using the undocumented @luma.gl/experimental function	2✔
250	const gltf = props.scenegraph;	2✔
251		2✔
252	// Tiles3DLoader already processes GLTF	2✔
253	const processedGLTF = gltf.json ? postProcessGLTF(gltf) : gltf;	2✔
254		2✔
255	const gltfObjects = createScenegraphsFromGLTF(device, processedGLTF, this._getModelOptions());	2✔
256	scenegraphData = {gltf: processedGLTF, ...gltfObjects};	2✔
257		2✔
258	waitForGLTFAssets(gltfObjects).then(() => {	2✔
259	this.setNeedsRedraw();	2✔
260	}); // eslint-disable-line @typescript-eslint/no-floating-promises	2✔
261	}	2✔
262		5✔
263	const options = {layer: this, device: this.context.device};	5✔
264	const scenegraph = props.getScene(scenegraphData, options);	5✔
265	const animator = props.getAnimator(scenegraphData, options);	5✔
266		5✔
267	if (scenegraph instanceof GroupNode) {	5✔
268	this.state.scenegraph?.destroy();	3!
269		3✔
270	this._applyAnimationsProp(animator, props._animations);	3✔
271		3✔
272	const models: Model[] = [];	3✔
273	scenegraph.traverse(node => {	3✔
274	if (node instanceof ModelNode) {	4✔
275	models.push(node.model);	4✔
276	}	4✔
277	});	3✔
278		3✔
279	this.setState({scenegraph, animator, models});	3✔
280	this.getAttributeManager()!.invalidateAll();	3✔
281	} else if (scenegraph !== null) {	5!
NEW 282	log.warn('invalid scenegraph:', scenegraph)();	×
UNCOV 283	}	×
284	}	5✔
285		1✔
286	private _applyAnimationsProp(animator: GLTFAnimator, animationsProp: any): void {	1✔
287	if (!animator \|\| !animationsProp) {	5✔
288	return;	1✔
289	}	1✔
290		4✔
291	const animations = animator.getAnimations();	4✔
292		4✔
293	// sort() to ensure '*' comes first so that other values can override	4✔
294	Object.keys(animationsProp)	4✔
295	.sort()	4✔
296	.forEach(key => {	4✔
297	// Key can be:	6✔
298	// - number for index number	6✔
299	// - name for animation name	6✔
300	// - * to affect all animations	6✔
301	const value = animationsProp[key];	6✔
302		6✔
303	if (key === '*') {	6✔
304	animations.forEach(animation => {	4✔
305	Object.assign(animation, value);	6✔
306	});	4✔
307	} else if (Number.isFinite(Number(key))) {	6✔
308	const number = Number(key);	1✔
309	if (number >= 0 && number < animations.length) {	1✔
310	Object.assign(animations[number], value);	1✔
311	} else {	1!
312	log.warn(`animation ${key} not found`)();	×
313	}	×
314	} else {	1✔
315	const findResult = animations.find(({name}) => name === key);	1✔
316	if (findResult) {	1✔
317	Object.assign(findResult, value);	1✔
318	} else {	1!
319	log.warn(`animation ${key} not found`)();	×
320	}	×
321	}	1✔
322	});	4✔
323	}	5✔
324		1✔
325	private _getModelOptions(): GLTFInstantiatorOptions {	1✔
326	const {_imageBasedLightingEnvironment} = this.props;	2✔
327		2✔
328	let env: PBREnvironment \| undefined;	2✔
329	if (_imageBasedLightingEnvironment) {	2!
330	if (typeof _imageBasedLightingEnvironment === 'function') {	×
331	env = _imageBasedLightingEnvironment({gl: this.context.gl, layer: this});	×
332	} else {	×
333	env = _imageBasedLightingEnvironment;	×
334	}	×
335	}	×
336		2✔
337	return {	2✔
338	imageBasedLightingEnvironment: env,	2✔
339	modelOptions: {	2✔
340	id: this.props.id,	2✔
341	isInstanced: true,	2✔
342	bufferLayout: this.getAttributeManager()!.getBufferLayouts(),	2✔
343	...this.getShaders()	2✔
344	},	2✔
345	// tangents are not supported	2✔
346	useTangents: false	2✔
347	};	2✔
348	}	2✔
349		1✔
350	draw({context}) {	1✔
351	if (!this.state.scenegraph) return;	37✔
352		34✔
353	if (this.props._animations && this.state.animator) {	37✔
354	this.state.animator.animate(context.timeline.getTime());	32✔
355	this.setNeedsRedraw();	32✔
356	}	32✔
357		34✔
358	const {viewport, renderPass} = this.context;	34✔
359	const {sizeScale, sizeMinPixels, sizeMaxPixels, opacity, coordinateSystem} = this.props;	34✔
360		34✔
361	const numInstances = this.getNumInstances();	34✔
362	this.state.scenegraph.traverse((node, {worldMatrix}) => {	34✔
363	if (node instanceof ModelNode) {	52✔
364	const {model} = node;	52✔
365	model.setInstanceCount(numInstances);	52✔
366	model.setUniforms({	52✔
367	sizeScale,	52✔
368	opacity,	52✔
369	sizeMinPixels,	52✔
370	sizeMaxPixels,	52✔
371	composeModelMatrix: shouldComposeModelMatrix(viewport, coordinateSystem),	52✔
372	sceneModelMatrix: worldMatrix,	52✔
373	// Needed for PBR (TODO: find better way to get it)	52✔
374	// eslint-disable-next-line camelcase	52✔
375	u_Camera: model.uniforms.project_uCameraPosition	52✔
376	});	52✔
377		52✔
378	model.draw(renderPass);	52✔
379	}	52✔
380	});	34✔
381	}	37✔
382	}	1✔

visgl / deck.gl / 8556837587

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