8142421448

Committed 04 Mar 2024 03:07PM UTC coverage: 70.681% (+0.04%) from 70.643%

Build # 8142421448

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Bump luma to 9.0.0-beta.6 (#8567)

Run Details

3402 of 4030 branches covered (84.42%)

Branch coverage included in aggregate %.

50 of 62 new or added lines in 22 files covered. (80.65%)

1 existing line in 1 file now uncovered.

39984 of 57353 relevant lines covered (69.72%)

298.55 hits per line

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

88.24

/modules/extensions/src/collision-filter/shader-module.ts

import {Framebuffer, Texture} from '@luma.gl/core';
import type {ShaderModule} from '@luma.gl/shadertools';
import {project} from '@deck.gl/core';
import {glsl} from '../utils/syntax-tags';

const vs = glsl`
#ifdef NON_INSTANCED_MODEL
in float collisionPriorities;
#else
in float instanceCollisionPriorities;
#endif

uniform sampler2D collision_texture;
uniform bool collision_sort;
uniform bool collision_enabled;

vec2 collision_getCoords(vec4 position) {
  vec4 collision_clipspace = project_common_position_to_clipspace(position);
  return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;
}

float collision_match(vec2 tex, vec3 pickingColor) {
  vec4 collision_pickingColor = texture(collision_texture, tex);
  float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));
  float e = 0.001;
  return step(delta, e);
}

float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
  if (!collision_enabled) {
    return 1.0;
  }

  // Visibility test, sample area of 5x5 pixels in order to fade in/out.
  // Due to the locality, the lookups will be cached
  // This reduces the flicker present when objects are shown/hidden
  const int N = 2;
  float accumulator = 0.0;
  vec2 step = vec2(1.0 / project_uViewportSize);

  const float floatN = float(N);
  vec2 delta = -floatN * step;
  for(int i = -N; i <= N; i++) {
    delta.x = -step.x * floatN;
    for(int j = -N; j <= N; j++) {
      accumulator += collision_match(texCoords + delta, pickingColor);
      delta.x += step.x;
    }
    delta.y += step.y;
  }

  float W = 2.0 * floatN + 1.0;
  return pow(accumulator / (W * W), 2.2);
}
`;

const inject = {
  'vs:#decl': glsl`
  float collision_fade = 1.0;
`,
  'vs:DECKGL_FILTER_GL_POSITION': glsl`
  if (collision_sort) {
    #ifdef NON_INSTANCED_MODEL
    float collisionPriority = collisionPriorities;
    #else
    float collisionPriority = instanceCollisionPriorities;
    #endif
    position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000
  }

  if (collision_enabled) {
    vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));
    vec2 collision_texCoords = collision_getCoords(collision_common_position);
    collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);
    if (collision_fade < 0.0001) {
      // Position outside clip space bounds to discard
      position = vec4(0.0, 0.0, 2.0, 1.0);
    }
  }
  `,
  'vs:DECKGL_FILTER_COLOR': glsl`
  color.a *= collision_fade;
  `
};

type CollisionModuleSettings = {
  collisionFBO?: Framebuffer;
  drawToCollisionMap?: boolean;
  dummyCollisionMap?: Texture;
};

/* eslint-disable camelcase */
type CollisionUniforms = {collision_sort?: boolean; collision_texture?: Texture};

const getCollisionUniforms = (
  opts: CollisionModuleSettings | {},
  uniforms: Record<string, any>
): CollisionUniforms => {
  if (!opts || !('dummyCollisionMap' in opts)) {
    return {};
  }
  const {collisionFBO, drawToCollisionMap, dummyCollisionMap} = opts;
  return {
    collision_sort: Boolean(drawToCollisionMap),
    // @ts-ignore (v9 not sure why this isn't allowed now)
    collision_texture:
      !drawToCollisionMap && collisionFBO ? collisionFBO.colorAttachments[0] : dummyCollisionMap
  };
};

// @ts-expect-error
export default {
  name: 'collision',
  dependencies: [project],
  vs,
  inject,
  getUniforms: getCollisionUniforms
} as ShaderModule<CollisionModuleSettings>;

1	import {Framebuffer, Texture} from '@luma.gl/core';	1✔
2	import type {ShaderModule} from '@luma.gl/shadertools';	1✔
3	import {project} from '@deck.gl/core';	1✔
4	import {glsl} from '../utils/syntax-tags';	1✔
5		1✔
6	const vs = glsl`	1✔
7	#ifdef NON_INSTANCED_MODEL	1✔
8	in float collisionPriorities;	1✔
9	#else	1✔
10	in float instanceCollisionPriorities;	1✔
11	#endif	1✔
12		1✔
13	uniform sampler2D collision_texture;	1✔
14	uniform bool collision_sort;	1✔
15	uniform bool collision_enabled;	1✔
16		1✔
17	vec2 collision_getCoords(vec4 position) {	1✔
18	vec4 collision_clipspace = project_common_position_to_clipspace(position);	1✔
19	return (1.0 + collision_clipspace.xy / collision_clipspace.w) / 2.0;	1✔
20	}	1✔
21		1✔
22	float collision_match(vec2 tex, vec3 pickingColor) {	1✔
23	vec4 collision_pickingColor = texture(collision_texture, tex);	1✔
24	float delta = dot(abs(collision_pickingColor.rgb - pickingColor), vec3(1.0));	1✔
25	float e = 0.001;	1✔
26	return step(delta, e);	1✔
27	}	1✔
28		1✔
29	float collision_isVisible(vec2 texCoords, vec3 pickingColor) {	1✔
30	if (!collision_enabled) {	1✔
31	return 1.0;	1✔
32	}	1✔
33		1✔
34	// Visibility test, sample area of 5x5 pixels in order to fade in/out.	1✔
35	// Due to the locality, the lookups will be cached	1✔
36	// This reduces the flicker present when objects are shown/hidden	1✔
37	const int N = 2;	1✔
38	float accumulator = 0.0;	1✔
39	vec2 step = vec2(1.0 / project_uViewportSize);	1✔
40		1✔
41	const float floatN = float(N);	1✔
42	vec2 delta = -floatN * step;	1✔
43	for(int i = -N; i <= N; i++) {	1✔
44	delta.x = -step.x * floatN;	1✔
45	for(int j = -N; j <= N; j++) {	1✔
46	accumulator += collision_match(texCoords + delta, pickingColor);	1✔
47	delta.x += step.x;	1✔
48	}	1✔
49	delta.y += step.y;	1✔
50	}	1✔
51		1✔
52	float W = 2.0 * floatN + 1.0;	1✔
53	return pow(accumulator / (W * W), 2.2);	1✔
54	}	1✔
55	`;	1✔
56		1✔
57	const inject = {	1✔
58	'vs:#decl': glsl`	1✔
59	float collision_fade = 1.0;	1✔
60	`,	1✔
61	'vs:DECKGL_FILTER_GL_POSITION': glsl`	1✔
62	if (collision_sort) {	1✔
63	#ifdef NON_INSTANCED_MODEL	1✔
64	float collisionPriority = collisionPriorities;	1✔
65	#else	1✔
66	float collisionPriority = instanceCollisionPriorities;	1✔
67	#endif	1✔
68	position.z = -0.001 * collisionPriority * position.w; // Support range -1000 -> 1000	1✔
69	}	1✔
70		1✔
71	if (collision_enabled) {	1✔
72	vec4 collision_common_position = project_position(vec4(geometry.worldPosition, 1.0));	1✔
73	vec2 collision_texCoords = collision_getCoords(collision_common_position);	1✔
74	collision_fade = collision_isVisible(collision_texCoords, geometry.pickingColor / 255.0);	1✔
75	if (collision_fade < 0.0001) {	1✔
76	// Position outside clip space bounds to discard	1✔
77	position = vec4(0.0, 0.0, 2.0, 1.0);	1✔
78	}	1✔
79	}	1✔
80	`,	1✔
81	'vs:DECKGL_FILTER_COLOR': glsl`	1✔
82	color.a *= collision_fade;	1✔
83	`	1✔
84	};	1✔
85		1✔
86	type CollisionModuleSettings = {	1✔
87	collisionFBO?: Framebuffer;	1✔
88	drawToCollisionMap?: boolean;	1✔
89	dummyCollisionMap?: Texture;	1✔
90	};	1✔
91		1✔
92	/* eslint-disable camelcase */	1✔
93	type CollisionUniforms = {collision_sort?: boolean; collision_texture?: Texture};	1✔
94		1✔
95	const getCollisionUniforms = (	1✔
96	opts: CollisionModuleSettings \| {},	×
97	uniforms: Record<string, any>	×
98	): CollisionUniforms => {	×
99	if (!opts \|\| !('dummyCollisionMap' in opts)) {	×
100	return {};	×
101	}	×
102	const {collisionFBO, drawToCollisionMap, dummyCollisionMap} = opts;	×
103	return {	×
104	collision_sort: Boolean(drawToCollisionMap),	×
NEW 105	// @ts-ignore (v9 not sure why this isn't allowed now)	×
106	collision_texture:	×
107	!drawToCollisionMap && collisionFBO ? collisionFBO.colorAttachments[0] : dummyCollisionMap	×
108	};	×
109	};	×
110		1✔
111	// @ts-expect-error	1✔
112	export default {	1✔
113	name: 'collision',	1✔
114	dependencies: [project],	1✔
115	vs,	1✔
116	inject,	1✔
117	getUniforms: getCollisionUniforms	1✔
118	} as ShaderModule<CollisionModuleSettings>;	1✔

visgl / deck.gl / 8142421448

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