8983135957

Committed 07 May 2024 09:38AM UTC coverage: 89.817% (+0.01%) from 89.807%

Build # 8983135957

Build Type

Pull #8782

github

Committed by

web-flow

Commit Message

Merge f3f62b9cc into 1a9dd6f19

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

Run Details

6315 of 6951 branches covered (90.85%)

Branch coverage included in aggregate %.

227 of 232 new or added lines in 30 files covered. (97.84%)

11 existing lines in 2 files now uncovered.

52073 of 58057 relevant lines covered (89.69%)

6635.92 hits per line

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

39.81

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

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

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

export default class GPUSpringTransition extends GPUTransitionBase<SpringTransitionSettings> {
  type = 'spring';

  private texture: Texture;
  private framebuffer: Framebuffer;
  private transform: BufferTransform;

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

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

    const {buffers, attribute} = this;

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

    this.setBuffer(buffers[1]);

    const {model} = this.transform;
    model.setVertexCount(Math.floor(this.currentLength / attribute.size));
    if (attribute.isConstant) {
      model.setConstantAttributes({aTo: attribute.value as TypedArray});
    } else {
      model.setAttributes({aTo: attribute.getBuffer()!});
    }
  }

  onUpdate() {
    const {buffers, transform, framebuffer, transition} = this;

    const settings = this.settings as SpringTransitionSettings;

    transform.model.setAttributes({
      aPrev: buffers[0],
      aCur: buffers[1]
    });
    transform.transformFeedback.setBuffers({vNext: buffers[2]});
    transform.model.setUniforms({
      stiffness: settings.stiffness,
      damping: settings.damping
    });
    transform.run({
      framebuffer,
      discard: false,
      parameters: {viewport: [0, 0, 1, 1]},
      clearColor: [0, 0, 0, 0]
    });

    cycleBuffers(buffers);
    this.setBuffer(buffers[1]);

    const isTransitioning = this.device.readPixelsToArrayWebGL(framebuffer)[0] > 0;

    if (!isTransitioning) {
      transition.end();
    }
  }

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

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

#define EPSILON 0.00001

uniform float stiffness;
uniform float damping;
in ATTRIBUTE_TYPE aPrev;
in ATTRIBUTE_TYPE aCur;
in ATTRIBUTE_TYPE aTo;
out ATTRIBUTE_TYPE vNext;
out float vIsTransitioningFlag;

ATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) {
  ATTRIBUTE_TYPE velocity = cur - prev;
  ATTRIBUTE_TYPE delta = dest - cur;
  ATTRIBUTE_TYPE spring = delta * stiffness;
  ATTRIBUTE_TYPE damper = velocity * -1.0 * damping;
  return spring + damper + velocity + cur;
}

void main(void) {
  bool isTransitioning = length(aCur - aPrev) > EPSILON || length(aTo - aCur) > EPSILON;
  vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0;

  vNext = getNextValue(aCur, aPrev, aTo);
  gl_Position = vec4(0, 0, 0, 1);
  gl_PointSize = 100.0;
}
`;

const fs = `\
#version 300 es
#define SHADER_NAME spring-transition-is-transitioning-fragment-shader

in float vIsTransitioningFlag;

out vec4 fragColor;

void main(void) {
  if (vIsTransitioningFlag == 0.0) {
    discard;
  }
  fragColor = vec4(1.0);
}`;

function getTransform(device: Device, attribute: Attribute): BufferTransform {
  const attributeType = getAttributeTypeFromSize(attribute.size);
  const format = getFloat32VertexFormat(attribute.size);
  return new BufferTransform(device, {
    vs,
    fs,
    bufferLayout: [
      {name: 'aPrev', format},
      {name: 'aCur', format},
      {name: 'aTo', format: attribute.getBufferLayout().attributes![0].format}
    ],
    varyings: ['vNext'],
    defines: {ATTRIBUTE_TYPE: attributeType},
    parameters: {
      depthCompare: 'always',
      blendColorOperation: 'max',
      blendColorSrcFactor: 'one',
      blendColorDstFactor: 'one',
      blendAlphaOperation: 'max',
      blendAlphaSrcFactor: 'one',
      blendAlphaDstFactor: 'one'
    },

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

function getTexture(device: Device): Texture {
  return device.createTexture({
    data: new Uint8Array(4),
    format: 'rgba8unorm',
    mipmaps: false,
    width: 1,
    height: 1
  });
}

function getFramebuffer(device: Device, texture: Texture): Framebuffer {
  return device.createFramebuffer({
    id: 'spring-transition-is-transitioning-framebuffer',
    width: 1,
    height: 1,
    colorAttachments: [texture]
  });
}

1	import type {Device, Framebuffer, Texture} from '@luma.gl/core';	1✔
2	import {Timeline, BufferTransform} from '@luma.gl/engine';	1✔
3	import {	1✔
4	padBuffer,	1✔
5	matchBuffer,	1✔
6	getAttributeTypeFromSize,	1✔
7	getFloat32VertexFormat,	1✔
8	cycleBuffers	1✔
9	} from './gpu-transition-utils';	1✔
10	import Attribute from '../lib/attribute/attribute';	1✔
11	import {GPUTransitionBase} from './gpu-transition';	1✔
12	import project from '../shaderlib/project/project';	1✔
13		1✔
14	import type {SpringTransitionSettings} from '../lib/attribute/transition-settings';	1✔
15	import type {TypedArray} from '../types/types';	1✔
16		1✔
17	export default class GPUSpringTransition extends GPUTransitionBase<SpringTransitionSettings> {	1✔
18	type = 'spring';	1✔
19		1✔
20	private texture: Texture;	1✔
21	private framebuffer: Framebuffer;	1✔
22	private transform: BufferTransform;	1✔
23		1✔
24	constructor({	1✔
25	device,	×
26	attribute,	×
27	timeline	×
28	}: {	×
29	device: Device;	×
30	attribute: Attribute;	×
31	timeline: Timeline;	×
32	}) {	×
33	super({device, attribute, timeline});	×
34	this.texture = getTexture(device);	×
35	this.framebuffer = getFramebuffer(device, this.texture);	×
36	this.transform = getTransform(device, attribute);	×
UNCOV 37	}	×
38		1✔
39	override start(transitionSettings: SpringTransitionSettings, numInstances: number): void {	1✔
40	const prevLength = this.currentLength;	×
41	const prevStartIndices = this.currentStartIndices;	×
42	super.start(transitionSettings, numInstances);	×
43		×
44	const {buffers, attribute} = this;	×
45		×
46	for (let i = 0; i < 2; i++) {	×
47	buffers[i] = padBuffer({	×
48	device: this.device,	×
49	buffer: buffers[i],	×
50	attribute,	×
51	fromLength: prevLength,	×
52	toLength: this.currentLength,	×
53	fromStartIndices: prevStartIndices,	×
54	getData: transitionSettings.enter	×
55	});	×
56	}	×
57	buffers[2] = matchBuffer({	×
58	device: this.device,	×
59	source: buffers[0],	×
60	target: buffers[2]	×
61	});	×
62		×
63	this.setBuffer(buffers[1]);	×
64		×
65	const {model} = this.transform;	×
66	model.setVertexCount(Math.floor(this.currentLength / attribute.size));	×
67	if (attribute.isConstant) {	×
68	model.setConstantAttributes({aTo: attribute.value as TypedArray});	×
69	} else {	×
70	model.setAttributes({aTo: attribute.getBuffer()!});	×
71	}	×
UNCOV 72	}	×
73		1✔
74	onUpdate() {	1✔
75	const {buffers, transform, framebuffer, transition} = this;	×
76		×
77	const settings = this.settings as SpringTransitionSettings;	×
78		×
79	transform.model.setAttributes({	×
80	aPrev: buffers[0],	×
81	aCur: buffers[1]	×
82	});	×
83	transform.transformFeedback.setBuffers({vNext: buffers[2]});	×
84	transform.model.setUniforms({	×
85	stiffness: settings.stiffness,	×
86	damping: settings.damping	×
87	});	×
88	transform.run({	×
89	framebuffer,	×
90	discard: false,	×
91	parameters: {viewport: [0, 0, 1, 1]},	×
92	clearColor: [0, 0, 0, 0]	×
93	});	×
94		×
95	cycleBuffers(buffers);	×
96	this.setBuffer(buffers[1]);	×
97		×
98	const isTransitioning = this.device.readPixelsToArrayWebGL(framebuffer)[0] > 0;	×
99		×
100	if (!isTransitioning) {	×
101	transition.end();	×
102	}	×
UNCOV 103	}	×
104		1✔
105	override delete() {	1✔
106	super.delete();	×
107	this.transform.destroy();	×
108	this.texture.destroy();	×
109	this.framebuffer.destroy();	×
UNCOV 110	}	×
111	}	1✔
112		1✔
113	const vs = `\	1✔
114	#version 300 es	1✔
115	#define SHADER_NAME spring-transition-vertex-shader	1✔
116		1✔
117	#define EPSILON 0.00001	1✔
118		1✔
119	uniform float stiffness;	1✔
120	uniform float damping;	1✔
121	in ATTRIBUTE_TYPE aPrev;	1✔
122	in ATTRIBUTE_TYPE aCur;	1✔
123	in ATTRIBUTE_TYPE aTo;	1✔
124	out ATTRIBUTE_TYPE vNext;	1✔
125	out float vIsTransitioningFlag;	1✔
126		1✔
127	ATTRIBUTE_TYPE getNextValue(ATTRIBUTE_TYPE cur, ATTRIBUTE_TYPE prev, ATTRIBUTE_TYPE dest) {	1✔
128	ATTRIBUTE_TYPE velocity = cur - prev;	1✔
129	ATTRIBUTE_TYPE delta = dest - cur;	1✔
130	ATTRIBUTE_TYPE spring = delta * stiffness;	1✔
131	ATTRIBUTE_TYPE damper = velocity * -1.0 * damping;	1✔
132	return spring + damper + velocity + cur;	1✔
133	}	1✔
134		1✔
135	void main(void) {	1✔
136	bool isTransitioning = length(aCur - aPrev) > EPSILON \|\| length(aTo - aCur) > EPSILON;	1✔
137	vIsTransitioningFlag = isTransitioning ? 1.0 : 0.0;	1✔
138		1✔
139	vNext = getNextValue(aCur, aPrev, aTo);	1✔
140	gl_Position = vec4(0, 0, 0, 1);	1✔
141	gl_PointSize = 100.0;	1✔
142	}	1✔
143	`;	1✔
144		1✔
145	const fs = `\	1✔
146	#version 300 es	1✔
147	#define SHADER_NAME spring-transition-is-transitioning-fragment-shader	1✔
148		1✔
149	in float vIsTransitioningFlag;	1✔
150		1✔
151	out vec4 fragColor;	1✔
152		1✔
153	void main(void) {	1✔
154	if (vIsTransitioningFlag == 0.0) {	1✔
155	discard;	1✔
156	}	1✔
157	fragColor = vec4(1.0);	1✔
158	}`;	1✔
159		1✔
160	function getTransform(device: Device, attribute: Attribute): BufferTransform {	×
161	const attributeType = getAttributeTypeFromSize(attribute.size);	×
162	const format = getFloat32VertexFormat(attribute.size);	×
163	return new BufferTransform(device, {	×
164	vs,	×
165	fs,	×
166	bufferLayout: [	×
167	{name: 'aPrev', format},	×
168	{name: 'aCur', format},	×
169	{name: 'aTo', format: attribute.getBufferLayout().attributes![0].format}	×
170	],	×
171	varyings: ['vNext'],	×
172	defines: {ATTRIBUTE_TYPE: attributeType},	×
173	parameters: {	×
174	depthCompare: 'always',	×
175	blendColorOperation: 'max',	×
176	blendColorSrcFactor: 'one',	×
177	blendColorDstFactor: 'one',	×
178	blendAlphaOperation: 'max',	×
179	blendAlphaSrcFactor: 'one',	×
180	blendAlphaDstFactor: 'one'	×
NEW 181	},	×
NEW 182		×
NEW UNCOV 183	// TODO investigate why this is needed	×
NEW 184	modules: [project]	×
185	});	×
186	}	×
187		1✔
188	function getTexture(device: Device): Texture {	×
189	return device.createTexture({	×
190	data: new Uint8Array(4),	×
191	format: 'rgba8unorm',	×
192	mipmaps: false,	×
UNCOV 193	width: 1,	×
194	height: 1	×
195	});	×
196	}	×
197		1✔
198	function getFramebuffer(device: Device, texture: Texture): Framebuffer {	×
199	return device.createFramebuffer({	×
200	id: 'spring-transition-is-transitioning-framebuffer',	×
201	width: 1,	×
UNCOV 202	height: 1,	×
UNCOV 203	colorAttachments: [texture]	×
UNCOV 204	});	×
UNCOV 205	}	×

visgl / deck.gl / 8983135957

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