10469566801

Committed 20 Aug 2024 10:08AM UTC coverage: 89.195% (-0.02%) from 89.217%

Build # 10469566801

Build Type

Pull #9093

github

Committed by

web-flow

Commit Message

Merge 0ec1e9748 into e10122308

Pull Request Pull Request #9093: Update PBR code to use luma pbrMaterial

Run Details

6539 of 7180 branches covered (91.07%)

Branch coverage included in aggregate %.

35 of 63 new or added lines in 6 files covered. (55.56%)

2 existing lines in 2 files now uncovered.

54696 of 61473 relevant lines covered (88.98%)

6293.62 hits per line

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

94.0

/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 {pbrMaterial} 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 {scenegraphUniforms, ScenegraphProps} from './scenegraph-layer-uniforms';
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 defines: {LIGHTING_PBR?: 1} = {};
    let pbr;

    if (this.props._lighting === 'pbr') {
      pbr = pbrMaterial;
      defines.LIGHTING_PBR = 1;
    } else {
      // Dummy shader module needed to handle
      // pbrMaterial.pbr_baseColorSampler binding
      pbr = {name: 'pbrMaterial'};
    }

    const modules = [project32, picking, scenegraphUniforms, pbr];
    return super.getShaders({defines, 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();
        })
        .catch(ex => {
          this.raiseError(ex, 'loading glTF');
        });
    }

    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, coordinateSystem} = this.props;

    const numInstances = this.getNumInstances();
    this.state.scenegraph.traverse((node, {worldMatrix}) => {
      if (node instanceof ModelNode) {
        const {model} = node;
        model.setInstanceCount(numInstances);

        const pbrProjectionProps = {
          // Needed for PBR (TODO: find better way to get it)
          // eslint-disable-next-line camelcase
          camera: model.uniforms.cameraPosition as [number, number, number]
        };
        const scenegraphProps: ScenegraphProps = {
          sizeScale,
          sizeMinPixels,
          sizeMaxPixels,
          composeModelMatrix: shouldComposeModelMatrix(viewport, coordinateSystem),
          sceneModelMatrix: worldMatrix
        };

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

visgl / deck.gl / 10469566801

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