8898676906

Committed 30 Apr 2024 04:54PM UTC coverage: 89.838% (+0.008%) from 89.83%

Build # 8898676906

Build Type

Pull #8782

github

Committed by

web-flow

Commit Message

Merge ae4edea47 into 65f9a250b

Pull Request Pull Request #8782: WIP: Use UBOs in project module

Run Details

6316 of 6949 branches covered (90.89%)

Branch coverage included in aggregate %.

220 of 225 new or added lines in 29 files covered. (97.78%)

14 existing lines in 3 files now uncovered.

52193 of 58178 relevant lines covered (89.71%)

6626.12 hits per line

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

98.24

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

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

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;
    let vertexCount = Math.floor(this.currentLength / attribute.size);
    if (useFp64(attribute)) {
      vertexCount /= 2;
    }
    model.setVertexCount(vertexCount);
    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);
}
`;
const vs64 = `\
#version 300 es
#define SHADER_NAME interpolation-transition-vertex-shader

uniform float time;
in ATTRIBUTE_TYPE aFrom;
in ATTRIBUTE_TYPE aFrom64Low;
in ATTRIBUTE_TYPE aTo;
in ATTRIBUTE_TYPE aTo64Low;
out ATTRIBUTE_TYPE vCurrent;
out ATTRIBUTE_TYPE vCurrent64Low;

vec2 mix_fp64(vec2 a, vec2 b, float x) {
  vec2 range = sub_fp64(b, a);
  return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));
}

void main(void) {
  for (int i=0; i<ATTRIBUTE_SIZE; i++) {
    vec2 value = mix_fp64(vec2(aFrom[i], aFrom64Low[i]), vec2(aTo[i], aTo64Low[i]), time);
    vCurrent[i] = value.x;
    vCurrent64Low[i] = value.y;
  }
  gl_Position = vec4(0.0);
}
`;

function useFp64(attribute: Attribute): boolean {
  return attribute.doublePrecision && attribute.value instanceof Float64Array;
}

function getTransform(device: Device, attribute: Attribute): BufferTransform {
  const attributeSize = attribute.size;
  const attributeType = getAttributeTypeFromSize(attributeSize);
  const inputFormat = getFloat32VertexFormat(attributeSize);
  const bufferLayout = attribute.getBufferLayout();

  if (useFp64(attribute)) {
    return new BufferTransform(device, {
      vs: vs64,
      bufferLayout: [
        {
          name: 'aFrom',
          byteStride: 8 * attributeSize,
          attributes: [
            {attribute: 'aFrom', format: inputFormat, byteOffset: 0},
            {attribute: 'aFrom64Low', format: inputFormat, byteOffset: 4 * attributeSize}
          ]
        },
        {
          name: 'aTo',
          byteStride: 8 * attributeSize,
          attributes: [
            {attribute: 'aTo', format: inputFormat, byteOffset: 0},
            {attribute: 'aTo64Low', format: inputFormat, byteOffset: 4 * attributeSize}
          ]
        }
      ],
      modules: [fp64arithmetic],
      defines: {
        ATTRIBUTE_TYPE: attributeType,
        ATTRIBUTE_SIZE: attributeSize
      },
      // Default uniforms are not set without this
      moduleSettings: {},
      varyings: ['vCurrent', 'vCurrent64Low'],
      // @ts-expect-error WebGLRenderPipeline only prop TODO - support in RenderPipeline?
      bufferMode: GL.INTERLEAVED_ATTRIBS,
      disableWarnings: true
    });
  }
  return new BufferTransform(device, {
    vs,
    bufferLayout: [
      {name: 'aFrom', format: inputFormat},
      {name: 'aTo', format: bufferLayout.attributes![0].format}
    ],
    defines: {
      ATTRIBUTE_TYPE: attributeType
    },
    varyings: ['vCurrent'],

    // TODO investigate why this is needed
    modules: [project],
    disableWarnings: true
  });
}

1	import type {Device} from '@luma.gl/core';	1✔
2	import {Timeline, BufferTransform} from '@luma.gl/engine';	1✔
3	import {fp64arithmetic} from '@luma.gl/shadertools';	1✔
4	import {GL} from '@luma.gl/constants';	1✔
5	import Attribute from '../lib/attribute/attribute';	1✔
6	import {	1✔
7	getAttributeTypeFromSize,	1✔
8	cycleBuffers,	1✔
9	padBuffer,	1✔
10	matchBuffer,	1✔
11	getFloat32VertexFormat	1✔
12	} from './gpu-transition-utils';	1✔
13	import {GPUTransitionBase} from './gpu-transition';	1✔
14	import project from '../shaderlib/project/project';	1✔
15		1✔
16	import type {InterpolationTransitionSettings} from '../lib/attribute/transition-settings';	1✔
17	import type {TypedArray} from '../types/types';	1✔
18		1✔
19	export default class GPUInterpolationTransition extends GPUTransitionBase<InterpolationTransitionSettings> {	1✔
20	type = 'interpolation';	1✔
21		1✔
22	private transform: BufferTransform;	1✔
23		1✔
24	constructor({	1✔
25	device,	7✔
26	attribute,	7✔
27	timeline	7✔
28	}: {	7✔
29	device: Device;	7✔
30	attribute: Attribute;	7✔
31	timeline: Timeline;	7✔
32	}) {	7✔
33	super({device, attribute, timeline});	7✔
34	this.transform = getTransform(device, attribute);	7✔
35	}	7✔
36		1✔
37	override start(transitionSettings: InterpolationTransitionSettings, numInstances: number): void {	1✔
38	const prevLength = this.currentLength;	16✔
39	const prevStartIndices = this.currentStartIndices;	16✔
40		16✔
41	super.start(transitionSettings, numInstances, transitionSettings.duration);	16✔
42		16✔
43	if (transitionSettings.duration <= 0) {	16!
44	this.transition.cancel();	×
45	return;	×
UNCOV 46	}	×
47		16✔
48	const {buffers, attribute} = this;	16✔
49	// Alternate between two buffers when new transitions start.	16✔
50	// Last destination buffer is used as an attribute (from state),	16✔
51	// And the other buffer is now the current buffer.	16✔
52	cycleBuffers(buffers);	16✔
53		16✔
54	buffers[0] = padBuffer({	16✔
55	device: this.device,	16✔
56	buffer: buffers[0],	16✔
57	attribute,	16✔
58	fromLength: prevLength,	16✔
59	toLength: this.currentLength,	16✔
60	fromStartIndices: prevStartIndices,	16✔
61	getData: transitionSettings.enter	16✔
62	});	16✔
63	buffers[1] = matchBuffer({	16✔
64	device: this.device,	16✔
65	source: buffers[0],	16✔
66	target: buffers[1]	16✔
67	});	16✔
68		16✔
69	this.setBuffer(buffers[1]);	16✔
70		16✔
71	const {transform} = this;	16✔
72	const model = transform.model;	16✔
73	let vertexCount = Math.floor(this.currentLength / attribute.size);	16✔
74	if (useFp64(attribute)) {	16✔
75	vertexCount /= 2;	2✔
76	}	2✔
77	model.setVertexCount(vertexCount);	16✔
78	if (attribute.isConstant) {	16✔
79	model.setAttributes({aFrom: buffers[0]});	5✔
80	model.setConstantAttributes({aTo: attribute.value as TypedArray});	5✔
81	} else {	16✔
82	model.setAttributes({	11✔
83	aFrom: buffers[0],	11✔
84	aTo: attribute.getBuffer()!	11✔
85	});	11✔
86	}	11✔
87	transform.transformFeedback.setBuffers({vCurrent: buffers[1]});	16✔
88	}	16✔
89		1✔
90	onUpdate() {	1✔
91	const {duration, easing} = this.settings!;	141✔
92	const {time} = this.transition;	141✔
93	let t = time / duration;	141✔
94	if (easing) {	141✔
95	t = easing(t);	141✔
96	}	141✔
97	const {model} = this.transform;	141✔
98	model.setUniforms({time: t});	141✔
99	// @ts-ignore	141✔
100	const gl = model.device.gl as WebGL2RenderingContext;	141✔
101	// TODO - remove after https://github.com/visgl/luma.gl/pull/2023	141✔
102	gl.bindBuffer(gl.ARRAY_BUFFER, null);	141✔
103		141✔
104	this.transform.run({discard: true});	141✔
105	}	141✔
106		1✔
107	override delete() {	1✔
108	super.delete();	7✔
109	this.transform.destroy();	7✔
110	}	7✔
111	}	1✔
112		1✔
113	const vs = `\	1✔
114	#version 300 es	1✔
115	#define SHADER_NAME interpolation-transition-vertex-shader	1✔
116		1✔
117	uniform float time;	1✔
118	in ATTRIBUTE_TYPE aFrom;	1✔
119	in ATTRIBUTE_TYPE aTo;	1✔
120	out ATTRIBUTE_TYPE vCurrent;	1✔
121		1✔
122	void main(void) {	1✔
123	vCurrent = mix(aFrom, aTo, time);	1✔
124	gl_Position = vec4(0.0);	1✔
125	}	1✔
126	`;	1✔
127	const vs64 = `\	1✔
128	#version 300 es	1✔
129	#define SHADER_NAME interpolation-transition-vertex-shader	1✔
130		1✔
131	uniform float time;	1✔
132	in ATTRIBUTE_TYPE aFrom;	1✔
133	in ATTRIBUTE_TYPE aFrom64Low;	1✔
134	in ATTRIBUTE_TYPE aTo;	1✔
135	in ATTRIBUTE_TYPE aTo64Low;	1✔
136	out ATTRIBUTE_TYPE vCurrent;	1✔
137	out ATTRIBUTE_TYPE vCurrent64Low;	1✔
138		1✔
139	vec2 mix_fp64(vec2 a, vec2 b, float x) {	1✔
140	vec2 range = sub_fp64(b, a);	1✔
141	return sum_fp64(a, mul_fp64(range, vec2(x, 0.0)));	1✔
142	}	1✔
143		1✔
144	void main(void) {	1✔
145	for (int i=0; i<ATTRIBUTE_SIZE; i++) {	1✔
146	vec2 value = mix_fp64(vec2(aFrom[i], aFrom64Low[i]), vec2(aTo[i], aTo64Low[i]), time);	1✔
147	vCurrent[i] = value.x;	1✔
148	vCurrent64Low[i] = value.y;	1✔
149	}	1✔
150	gl_Position = vec4(0.0);	1✔
151	}	1✔
152	`;	1✔
153		1✔
154	function useFp64(attribute: Attribute): boolean {	23✔
155	return attribute.doublePrecision && attribute.value instanceof Float64Array;	23✔
156	}	23✔
157		1✔
158	function getTransform(device: Device, attribute: Attribute): BufferTransform {	7✔
159	const attributeSize = attribute.size;	7✔
160	const attributeType = getAttributeTypeFromSize(attributeSize);	7✔
161	const inputFormat = getFloat32VertexFormat(attributeSize);	7✔
162	const bufferLayout = attribute.getBufferLayout();	7✔
163		7✔
164	if (useFp64(attribute)) {	7✔
165	return new BufferTransform(device, {	1✔
166	vs: vs64,	1✔
167	bufferLayout: [	1✔
168	{	1✔
169	name: 'aFrom',	1✔
170	byteStride: 8 * attributeSize,	1✔
171	attributes: [	1✔
172	{attribute: 'aFrom', format: inputFormat, byteOffset: 0},	1✔
173	{attribute: 'aFrom64Low', format: inputFormat, byteOffset: 4 * attributeSize}	1✔
174	]	1✔
175	},	1✔
176	{	1✔
177	name: 'aTo',	1✔
178	byteStride: 8 * attributeSize,	1✔
179	attributes: [	1✔
180	{attribute: 'aTo', format: inputFormat, byteOffset: 0},	1✔
181	{attribute: 'aTo64Low', format: inputFormat, byteOffset: 4 * attributeSize}	1✔
182	]	1✔
183	}	1✔
184	],	1✔
185	modules: [fp64arithmetic],	1✔
186	defines: {	1✔
187	ATTRIBUTE_TYPE: attributeType,	1✔
188	ATTRIBUTE_SIZE: attributeSize	1✔
189	},	1✔
190	// Default uniforms are not set without this	1✔
191	moduleSettings: {},	1✔
192	varyings: ['vCurrent', 'vCurrent64Low'],	1✔
193	// @ts-expect-error WebGLRenderPipeline only prop TODO - support in RenderPipeline?	1✔
194	bufferMode: GL.INTERLEAVED_ATTRIBS,	1✔
195	disableWarnings: true	1✔
196	});	1✔
197	}	1✔
198	return new BufferTransform(device, {	6✔
199	vs,	6✔
200	bufferLayout: [	6✔
201	{name: 'aFrom', format: inputFormat},	6✔
202	{name: 'aTo', format: bufferLayout.attributes![0].format}	6✔
203	],	6✔
204	defines: {	6✔
205	ATTRIBUTE_TYPE: attributeType	6✔
206	},	6✔
207	varyings: ['vCurrent'],	6✔
208		6✔
209	// TODO investigate why this is needed	6✔
210	modules: [project],	6✔
211	disableWarnings: true	6✔
212	});	6✔
213	}	6✔

visgl / deck.gl / 8898676906

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