8266991353

Committed 13 Mar 2024 03:08PM UTC coverage: 84.071% (+0.2%) from 83.892%

Build # 8266991353

Build Type

Pull #8643

github

Committed by

web-flow

Commit Message

Merge 22425c501 into 3bb7fb3e6

Pull Request Pull Request #8643: Fix attribute transition

Run Details

5314 of 5997 branches covered (88.61%)

Branch coverage included in aggregate %.

443 of 494 new or added lines in 11 files covered. (89.68%)

24 existing lines in 5 files now uncovered.

47806 of 57188 relevant lines covered (83.59%)

2373.77 hits per line

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

97.2

/modules/core/src/transitions/gpu-interpolation-transition.ts

import type {Device} from '@luma.gl/core';
import {Timeline, BufferTransform} from '@luma.gl/engine';
import Attribute from '../lib/attribute/attribute';
import {
  getAttributeTypeFromSize,
  cycleBuffers,
  padBuffer,
  matchBuffer,
  getFloat32VertexFormat
} from './gpu-transition-utils';
import {GPUTransitionBase} from './gpu-transition';

import type {InterpolationTransitionSettings} from '../lib/attribute/transition-settings';
import type {TypedArray} from '../types/types';

export default class GPUInterpolationTransition extends GPUTransitionBase<InterpolationTransitionSettings> {
  type = 'interpolation';

  private transform: BufferTransform;

  constructor({
    device,
    attribute,
    timeline
  }: {
    device: Device;
    attribute: Attribute;
    timeline: Timeline;
  }) {
    super({device, attribute, timeline});
    this.transform = getTransform(device, attribute);
  }

  override start(transitionSettings: InterpolationTransitionSettings, numInstances: number): void {
    const prevLength = this.currentLength;
    const prevStartIndices = this.currentStartIndices;

    super.start(transitionSettings, numInstances, transitionSettings.duration);

    if (transitionSettings.duration <= 0) {
      this.transition.cancel();
      return;
    }

    const {buffers, attribute} = this;
    // Alternate between two buffers when new transitions start.
    // Last destination buffer is used as an attribute (from state),
    // And the other buffer is now the current buffer.
    cycleBuffers(buffers);

    buffers[0] = padBuffer({
      device: this.device,
      buffer: buffers[0],
      attribute,
      fromLength: prevLength,
      toLength: this.currentLength,
      fromStartIndices: prevStartIndices,
      getData: transitionSettings.enter
    });
    buffers[1] = matchBuffer({
      device: this.device,
      source: buffers[0],
      target: buffers[1]
    });

    this.setBuffer(buffers[1]);

    const {transform} = this;
    const model = transform.model;
    model.setVertexCount(Math.floor(this.currentLength / attribute.size));
    if (attribute.isConstant) {
      model.setAttributes({aFrom: buffers[0]});
      model.setConstantAttributes({aTo: attribute.value as TypedArray});
    } else {
      model.setAttributes({
        aFrom: buffers[0],
        aTo: attribute.getBuffer()!
      });
    }
    transform.transformFeedback.setBuffers({vCurrent: buffers[1]});
  }

  onUpdate() {
    const {duration, easing} = this.settings!;
    const {time} = this.transition;
    let t = time / duration;
    if (easing) {
      t = easing(t);
    }
    const {model} = this.transform;
    model.setUniforms({time: t});
    // @ts-ignore
    const gl = model.device.gl as WebGL2RenderingContext;
    // TODO - remove after https://github.com/visgl/luma.gl/pull/2023
    gl.bindBuffer(gl.ARRAY_BUFFER, null);

    this.transform.run({discard: true});
  }

  override delete() {
    super.delete();
    this.transform.destroy();
  }
}

const vs = `\
#version 300 es
#define SHADER_NAME interpolation-transition-vertex-shader

uniform float time;
in ATTRIBUTE_TYPE aFrom;
in ATTRIBUTE_TYPE aTo;
out ATTRIBUTE_TYPE vCurrent;

void main(void) {
  vCurrent = mix(aFrom, aTo, time);
  gl_Position = vec4(0.0);
}
`;

function getTransform(device: Device, attribute: Attribute): BufferTransform {
  const attributeType = getAttributeTypeFromSize(attribute.size);
  return new BufferTransform(device, {
    vs,
    bufferLayout: [
      {name: 'aFrom', format: getFloat32VertexFormat(attribute.size)},
      {name: 'aTo', format: attribute.getBufferLayout().attributes![0].format}
    ],
    defines: {
      ATTRIBUTE_TYPE: attributeType
    },
    varyings: ['vCurrent']
  });
}

1	import type {Device} from '@luma.gl/core';	1✔
2	import {Timeline, BufferTransform} from '@luma.gl/engine';	1✔
3	import Attribute from '../lib/attribute/attribute';	1✔
4	import {	1✔
5	getAttributeTypeFromSize,	1✔
6	cycleBuffers,	1✔
7	padBuffer,	1✔
8	matchBuffer,	1✔
9	getFloat32VertexFormat	1✔
10	} from './gpu-transition-utils';	1✔
11	import {GPUTransitionBase} from './gpu-transition';	1✔
12		1✔
13	import type {InterpolationTransitionSettings} from '../lib/attribute/transition-settings';	1✔
14	import type {TypedArray} from '../types/types';	1✔
15		1✔
16	export default class GPUInterpolationTransition extends GPUTransitionBase<InterpolationTransitionSettings> {	1✔
17	type = 'interpolation';	1✔
18		1✔
19	private transform: BufferTransform;	1✔
20		1✔
21	constructor({	1✔
22	device,	7✔
23	attribute,	7✔
24	timeline	7✔
25	}: {	7✔
26	device: Device;	7✔
27	attribute: Attribute;	7✔
28	timeline: Timeline;	7✔
29	}) {	7✔
30	super({device, attribute, timeline});	7✔
31	this.transform = getTransform(device, attribute);	7✔
32	}	7✔
33		1✔
34	override start(transitionSettings: InterpolationTransitionSettings, numInstances: number): void {	1✔
35	const prevLength = this.currentLength;	16✔
36	const prevStartIndices = this.currentStartIndices;	16✔
37		16✔
38	super.start(transitionSettings, numInstances, transitionSettings.duration);	16✔
39		16✔
40	if (transitionSettings.duration <= 0) {	16!
UNCOV 41	this.transition.cancel();	×
42	return;	×
43	}	×
44		16✔
45	const {buffers, attribute} = this;	16✔
46	// Alternate between two buffers when new transitions start.	16✔
47	// Last destination buffer is used as an attribute (from state),	16✔
48	// And the other buffer is now the current buffer.	16✔
49	cycleBuffers(buffers);	16✔
50		16✔
51	buffers[0] = padBuffer({	16✔
52	device: this.device,	16✔
53	buffer: buffers[0],	16✔
54	attribute,	16✔
55	fromLength: prevLength,	16✔
56	toLength: this.currentLength,	16✔
57	fromStartIndices: prevStartIndices,	16✔
58	getData: transitionSettings.enter	16✔
59	});	16✔
60	buffers[1] = matchBuffer({	16✔
61	device: this.device,	16✔
62	source: buffers[0],	16✔
63	target: buffers[1]	16✔
64	});	16✔
65		16✔
66	this.setBuffer(buffers[1]);	16✔
67		16✔
68	const {transform} = this;	16✔
69	const model = transform.model;	16✔
70	model.setVertexCount(Math.floor(this.currentLength / attribute.size));	16✔
71	if (attribute.isConstant) {	16✔
72	model.setAttributes({aFrom: buffers[0]});	5✔
73	model.setConstantAttributes({aTo: attribute.value as TypedArray});	5✔
74	} else {	16✔
75	model.setAttributes({	11✔
76	aFrom: buffers[0],	11✔
77	aTo: attribute.getBuffer()!	11✔
78	});	11✔
79	}	11✔
80	transform.transformFeedback.setBuffers({vCurrent: buffers[1]});	16✔
81	}	16✔
82		1✔
83	onUpdate() {	1✔
84	const {duration, easing} = this.settings!;	117✔
85	const {time} = this.transition;	117✔
86	let t = time / duration;	117✔
87	if (easing) {	117✔
88	t = easing(t);	117✔
89	}	117✔
90	const {model} = this.transform;	117✔
91	model.setUniforms({time: t});	117✔
92	// @ts-ignore	117✔
93	const gl = model.device.gl as WebGL2RenderingContext;	117✔
94	// TODO - remove after https://github.com/visgl/luma.gl/pull/2023	117✔
95	gl.bindBuffer(gl.ARRAY_BUFFER, null);	117✔
96		117✔
97	this.transform.run({discard: true});	117✔
98	}	117✔
99		1✔
100	override delete() {	1✔
101	super.delete();	7✔
102	this.transform.destroy();	7✔
103	}	7✔
104	}	1✔
105		1✔
106	const vs = `\	1✔
107	#version 300 es	1✔
108	#define SHADER_NAME interpolation-transition-vertex-shader	1✔
109		1✔
110	uniform float time;	1✔
111	in ATTRIBUTE_TYPE aFrom;	1✔
112	in ATTRIBUTE_TYPE aTo;	1✔
113	out ATTRIBUTE_TYPE vCurrent;	1✔
114		1✔
115	void main(void) {	1✔
116	vCurrent = mix(aFrom, aTo, time);	1✔
117	gl_Position = vec4(0.0);	1✔
118	}	1✔
119	`;	1✔
120		1✔
121	function getTransform(device: Device, attribute: Attribute): BufferTransform {	7✔
122	const attributeType = getAttributeTypeFromSize(attribute.size);	7✔
123	return new BufferTransform(device, {	7✔
124	vs,	7✔
125	bufferLayout: [	7✔
126	{name: 'aFrom', format: getFloat32VertexFormat(attribute.size)},	7✔
127	{name: 'aTo', format: attribute.getBufferLayout().attributes![0].format}	7✔
128	],	7✔
129	defines: {	7✔
130	ATTRIBUTE_TYPE: attributeType	7✔
131	},	7✔
132	varyings: ['vCurrent']	7✔
133	});	7✔
134	}	7✔

visgl / deck.gl / 8266991353

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