8599229061

Committed 08 Apr 2024 11:25AM UTC coverage: 89.991% (+0.003%) from 89.988%

Build # 8599229061

Build Type

Pull #8769

github

Committed by

web-flow

Commit Message

Merge 84c88fb3c into 9e4fa084c

Pull Request Pull Request #8769: Only add necessary attributes in DataFilterExtension

Run Details

6298 of 6932 branches covered (90.85%)

Branch coverage included in aggregate %.

154 of 155 new or added lines in 2 files covered. (99.35%)

11 existing lines in 1 file now uncovered.

51637 of 57447 relevant lines covered (89.89%)

6698.13 hits per line

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

93.63

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

import type {ShaderModule} from '@luma.gl/shadertools';
import type {DataFilterExtensionProps} from './data-filter-extension';
import {glsl} from '../utils/syntax-tags';

/*
 * data filter shader module
 */
const vs = glsl`
uniform bool filter_useSoftMargin;
uniform bool filter_enabled;
uniform bool filter_transformSize;
uniform ivec4 filter_categoryBitMask;

#ifdef DATAFILTER_TYPE
  uniform DATAFILTER_TYPE filter_min;
  uniform DATAFILTER_TYPE filter_softMin;
  uniform DATAFILTER_TYPE filter_softMax;
  uniform DATAFILTER_TYPE filter_max;

  #ifdef NON_INSTANCED_MODEL
    #define DATAFILTER_ATTRIB filterValues
    #define DATAFILTER_ATTRIB_64LOW filterValues64Low
  #else
    #define DATAFILTER_ATTRIB instanceFilterValues
    #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low
  #endif

  in DATAFILTER_TYPE DATAFILTER_ATTRIB;
  #ifdef DATAFILTER_DOUBLE
    in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;

    uniform DATAFILTER_TYPE filter_min64High;
    uniform DATAFILTER_TYPE filter_max64High;
  #endif
#endif


#ifdef DATACATEGORY_TYPE
  #ifdef NON_INSTANCED_MODEL
    #define DATACATEGORY_ATTRIB filterCategoryValues
  #else
    #define DATACATEGORY_ATTRIB instanceFilterCategoryValues
  #endif
  in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;
#endif

out float dataFilter_value;

float dataFilter_reduceValue(float value) {
  return value;
}
float dataFilter_reduceValue(vec2 value) {
  return min(value.x, value.y);
}
float dataFilter_reduceValue(vec3 value) {
  return min(min(value.x, value.y), value.z);
}
float dataFilter_reduceValue(vec4 value) {
  return min(min(value.x, value.y), min(value.z, value.w));
}

#ifdef DATAFILTER_ATTRIB
  void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
    if (filter_useSoftMargin) {
      dataFilter_value = dataFilter_reduceValue(
        smoothstep(filter_min, filter_softMin, valueFromMin) *
          (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))
      );
    } else {
      dataFilter_value = dataFilter_reduceValue(
        step(filter_min, valueFromMin) * step(valueFromMax, filter_max)
      );
    }
  }
#endif

#ifdef DATACATEGORY_ATTRIB
  void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
    #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
    int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];
    #elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks
    ivec2 dataFilter_masks = ivec2(
      filter_categoryBitMask[int(category.x / 32.0)],
      filter_categoryBitMask[int(category.y / 32.0) + 2]
    );
    #elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks
    ivec3 dataFilter_masks = filter_categoryBitMask.xyz;
    #else // Four 32-bit masks
    ivec4 dataFilter_masks = filter_categoryBitMask;
    #endif

    // Shift mask and extract relevant bits
    DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));
    dataFilter_bits = mod(floor(dataFilter_bits), 2.0);

    #if DATACATEGORY_CHANNELS == 1
    if(dataFilter_bits == 0.0) dataFilter_value = 0.0;
    #else
    if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;
    #endif
  }
#endif
`;

const fs = glsl`
uniform bool filter_transformColor;
in float dataFilter_value;
`;

type DataFilterModuleSettings = {
  extensions: any[]; // used to detect if layer props are present
} & DataFilterExtensionProps;

/* eslint-disable camelcase */
function getUniforms(opts?: DataFilterModuleSettings | {}): Record<string, any> {
  if (!opts || !('extensions' in opts)) {
    return {};
  }
  const {
    filterRange = [-1, 1],
    filterEnabled = true,
    filterTransformSize = true,
    filterTransformColor = true
  } = opts;
  const filterSoftRange = opts.filterSoftRange || filterRange;

  return {
    ...(Number.isFinite(filterRange[0])
      ? {
          filter_min: filterRange[0],
          filter_softMin: filterSoftRange[0],
          filter_softMax: filterSoftRange[1],
          filter_max: filterRange[1]
        }
      : {
          filter_min: filterRange.map(r => r[0]),
          filter_softMin: filterSoftRange.map(r => r[0]),
          filter_softMax: filterSoftRange.map(r => r[1]),
          filter_max: filterRange.map(r => r[1])
        }),
    filter_enabled: filterEnabled,
    filter_useSoftMargin: Boolean(opts.filterSoftRange),
    filter_transformSize: filterEnabled && filterTransformSize,
    filter_transformColor: filterEnabled && filterTransformColor
  };
}

function getUniforms64(opts?: DataFilterModuleSettings | {}): Record<string, any> {
  if (!opts || !('extensions' in opts)) {
    return {};
  }
  const uniforms = getUniforms(opts);
  if (Number.isFinite(uniforms.filter_min)) {
    const min64High = Math.fround(uniforms.filter_min);
    uniforms.filter_min -= min64High;
    uniforms.filter_softMin -= min64High;
    uniforms.filter_min64High = min64High;

    const max64High = Math.fround(uniforms.filter_max);
    uniforms.filter_max -= max64High;
    uniforms.filter_softMax -= max64High;
    uniforms.filter_max64High = max64High;
  } else {
    const min64High = uniforms.filter_min.map(Math.fround);
    uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);
    uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);
    uniforms.filter_min64High = min64High;

    const max64High = uniforms.filter_max.map(Math.fround);
    uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);
    uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);
    uniforms.filter_max64High = max64High;
  }
  return uniforms;
}

const inject = {
  'vs:#main-start': glsl`
    dataFilter_value = 1.0;
    if (filter_enabled) {
      #ifdef DATAFILTER_ATTRIB
        #ifdef DATAFILTER_DOUBLE
          dataFilter_setValue(
            DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,
            DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW
          );
        #else
          dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);
        #endif
      #endif

      #ifdef DATACATEGORY_ATTRIB
        dataFilter_setCategoryValue(DATACATEGORY_ATTRIB);
      #endif
    }
  `,

  'vs:#main-end': glsl`
    if (dataFilter_value == 0.0) {
      gl_Position = vec4(0.);
    }
  `,

  'vs:DECKGL_FILTER_SIZE': glsl`
    if (filter_transformSize) {
      size = size * dataFilter_value;
    }
  `,

  'fs:DECKGL_FILTER_COLOR': glsl`
    if (dataFilter_value == 0.0) discard;
    if (filter_transformColor) {
      color.a *= dataFilter_value;
    }
  `
};

export const shaderModule: ShaderModule<DataFilterModuleSettings> = {
  name: 'data-filter',
  vs,
  fs,
  inject,
  getUniforms
};

export const shaderModule64: ShaderModule<DataFilterModuleSettings> = {
  name: 'data-filter-fp64',
  vs,
  fs,
  inject,
  getUniforms: getUniforms64
};

1	import type {ShaderModule} from '@luma.gl/shadertools';	1✔
2	import type {DataFilterExtensionProps} from './data-filter-extension';	1✔
3	import {glsl} from '../utils/syntax-tags';	1✔
4		1✔
5	/*	1✔
6	* data filter shader module	1✔
7	*/	1✔
8	const vs = glsl`	1✔
9	uniform bool filter_useSoftMargin;	1✔
10	uniform bool filter_enabled;	1✔
11	uniform bool filter_transformSize;	1✔
12	uniform ivec4 filter_categoryBitMask;	1✔
13		1✔
14	#ifdef DATAFILTER_TYPE	1✔
15	uniform DATAFILTER_TYPE filter_min;	1✔
16	uniform DATAFILTER_TYPE filter_softMin;	1✔
17	uniform DATAFILTER_TYPE filter_softMax;	1✔
18	uniform DATAFILTER_TYPE filter_max;	1✔
19		1✔
20	#ifdef NON_INSTANCED_MODEL	1✔
21	#define DATAFILTER_ATTRIB filterValues	1✔
22	#define DATAFILTER_ATTRIB_64LOW filterValues64Low	1✔
23	#else	1✔
24	#define DATAFILTER_ATTRIB instanceFilterValues	1✔
25	#define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low	1✔
26	#endif	1✔
27		1✔
28	in DATAFILTER_TYPE DATAFILTER_ATTRIB;	1✔
29	#ifdef DATAFILTER_DOUBLE	1✔
30	in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;	1✔
31		1✔
32	uniform DATAFILTER_TYPE filter_min64High;	1✔
33	uniform DATAFILTER_TYPE filter_max64High;	1✔
34	#endif	1✔
35	#endif	1✔
36		1✔
37		1✔
38	#ifdef DATACATEGORY_TYPE	1✔
39	#ifdef NON_INSTANCED_MODEL	1✔
40	#define DATACATEGORY_ATTRIB filterCategoryValues	1✔
41	#else	1✔
42	#define DATACATEGORY_ATTRIB instanceFilterCategoryValues	1✔
43	#endif	1✔
44	in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;	1✔
45	#endif	1✔
46		1✔
47	out float dataFilter_value;	1✔
48		1✔
49	float dataFilter_reduceValue(float value) {	1✔
50	return value;	1✔
51	}	1✔
52	float dataFilter_reduceValue(vec2 value) {	1✔
53	return min(value.x, value.y);	1✔
54	}	1✔
55	float dataFilter_reduceValue(vec3 value) {	1✔
56	return min(min(value.x, value.y), value.z);	1✔
57	}	1✔
58	float dataFilter_reduceValue(vec4 value) {	1✔
59	return min(min(value.x, value.y), min(value.z, value.w));	1✔
60	}	1✔
61		1✔
62	#ifdef DATAFILTER_ATTRIB	1✔
63	void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {	1✔
64	if (filter_useSoftMargin) {	1✔
65	dataFilter_value = dataFilter_reduceValue(	1✔
66	smoothstep(filter_min, filter_softMin, valueFromMin) *	1✔
67	(1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))	1✔
68	);	1✔
69	} else {	1✔
70	dataFilter_value = dataFilter_reduceValue(	1✔
71	step(filter_min, valueFromMin) * step(valueFromMax, filter_max)	1✔
72	);	1✔
73	}	1✔
74	}	1✔
75	#endif	1✔
76		1✔
77	#ifdef DATACATEGORY_ATTRIB	1✔
78	void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {	1✔
79	#if DATACATEGORY_CHANNELS == 1 // One 128-bit mask	1✔
80	int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];	1✔
81	#elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks	1✔
82	ivec2 dataFilter_masks = ivec2(	1✔
83	filter_categoryBitMask[int(category.x / 32.0)],	1✔
84	filter_categoryBitMask[int(category.y / 32.0) + 2]	1✔
85	);	1✔
86	#elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks	1✔
87	ivec3 dataFilter_masks = filter_categoryBitMask.xyz;	1✔
88	#else // Four 32-bit masks	1✔
89	ivec4 dataFilter_masks = filter_categoryBitMask;	1✔
90	#endif	1✔
91		1✔
92	// Shift mask and extract relevant bits	1✔
93	DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));	1✔
94	dataFilter_bits = mod(floor(dataFilter_bits), 2.0);	1✔
95		1✔
96	#if DATACATEGORY_CHANNELS == 1	1✔
97	if(dataFilter_bits == 0.0) dataFilter_value = 0.0;	1✔
98	#else	1✔
99	if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;	1✔
100	#endif	1✔
101	}	1✔
102	#endif	1✔
103	`;	1✔
104		1✔
105	const fs = glsl`	1✔
106	uniform bool filter_transformColor;	1✔
107	in float dataFilter_value;	1✔
108	`;	1✔
109		1✔
110	type DataFilterModuleSettings = {	1✔
111	extensions: any[]; // used to detect if layer props are present	1✔
112	} & DataFilterExtensionProps;	1✔
113		1✔
114	/* eslint-disable camelcase */	1✔
115	function getUniforms(opts?: DataFilterModuleSettings \| {}): Record<string, any> {	19✔
116	if (!opts \|\| !('extensions' in opts)) {	19!
UNCOV 117	return {};	×
NEW 118	}	×
119	const {	19✔
120	filterRange = [-1, 1],	19✔
121	filterEnabled = true,	19✔
122	filterTransformSize = true,	19✔
123	filterTransformColor = true	19✔
124	} = opts;	19✔
125	const filterSoftRange = opts.filterSoftRange \|\| filterRange;	19✔
126		19✔
127	return {	19✔
128	...(Number.isFinite(filterRange[0])	19✔
129	? {	17✔
130	filter_min: filterRange[0],	17✔
131	filter_softMin: filterSoftRange[0],	17✔
132	filter_softMax: filterSoftRange[1],	17✔
133	filter_max: filterRange[1]	17✔
134	}	17✔
135	: {	2✔
136	filter_min: filterRange.map(r => r[0]),	2✔
137	filter_softMin: filterSoftRange.map(r => r[0]),	2✔
138	filter_softMax: filterSoftRange.map(r => r[1]),	2✔
139	filter_max: filterRange.map(r => r[1])	2✔
140	}),	2✔
141	filter_enabled: filterEnabled,	19✔
142	filter_useSoftMargin: Boolean(opts.filterSoftRange),	19✔
143	filter_transformSize: filterEnabled && filterTransformSize,	19✔
144	filter_transformColor: filterEnabled && filterTransformColor	19✔
145	};	19✔
146	}	19✔
147		1✔
148	function getUniforms64(opts?: DataFilterModuleSettings \| {}): Record<string, any> {	1✔
149	if (!opts \|\| !('extensions' in opts)) {	1!
UNCOV 150	return {};	×
UNCOV 151	}	×
152	const uniforms = getUniforms(opts);	1✔
153	if (Number.isFinite(uniforms.filter_min)) {	1!
154	const min64High = Math.fround(uniforms.filter_min);	×
UNCOV 155	uniforms.filter_min -= min64High;	×
UNCOV 156	uniforms.filter_softMin -= min64High;	×
UNCOV 157	uniforms.filter_min64High = min64High;	×
UNCOV 158		×
UNCOV 159	const max64High = Math.fround(uniforms.filter_max);	×
UNCOV 160	uniforms.filter_max -= max64High;	×
UNCOV 161	uniforms.filter_softMax -= max64High;	×
UNCOV 162	uniforms.filter_max64High = max64High;	×
163	} else {	1✔
164	const min64High = uniforms.filter_min.map(Math.fround);	1✔
165	uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);	1✔
166	uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);	1✔
167	uniforms.filter_min64High = min64High;	1✔
168		1✔
169	const max64High = uniforms.filter_max.map(Math.fround);	1✔
170	uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);	1✔
171	uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);	1✔
172	uniforms.filter_max64High = max64High;	1✔
173	}	1✔
174	return uniforms;	1✔
175	}	1✔
176		1✔
177	const inject = {	1✔
178	'vs:#main-start': glsl`	1✔
179	dataFilter_value = 1.0;	1✔
180	if (filter_enabled) {	1✔
181	#ifdef DATAFILTER_ATTRIB	1✔
182	#ifdef DATAFILTER_DOUBLE	1✔
183	dataFilter_setValue(	1✔
184	DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,	1✔
185	DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW	1✔
186	);	1✔
187	#else	1✔
188	dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);	1✔
189	#endif	1✔
190	#endif	1✔
191		1✔
192	#ifdef DATACATEGORY_ATTRIB	1✔
193	dataFilter_setCategoryValue(DATACATEGORY_ATTRIB);	1✔
194	#endif	1✔
195	}	1✔
196	`,	1✔
197		1✔
198	'vs:#main-end': glsl`	1✔
199	if (dataFilter_value == 0.0) {	1✔
200	gl_Position = vec4(0.);	1✔
201	}	1✔
202	`,	1✔
203		1✔
204	'vs:DECKGL_FILTER_SIZE': glsl`	1✔
205	if (filter_transformSize) {	1✔
206	size = size * dataFilter_value;	1✔
207	}	1✔
208	`,	1✔
209		1✔
210	'fs:DECKGL_FILTER_COLOR': glsl`	1✔
211	if (dataFilter_value == 0.0) discard;	1✔
212	if (filter_transformColor) {	1✔
213	color.a *= dataFilter_value;	1✔
214	}	1✔
215	`	1✔
216	};	1✔
217		1✔
218	export const shaderModule: ShaderModule<DataFilterModuleSettings> = {	1✔
219	name: 'data-filter',	1✔
220	vs,	1✔
221	fs,	1✔
222	inject,	1✔
223	getUniforms	1✔
224	};	1✔
225		1✔
226	export const shaderModule64: ShaderModule<DataFilterModuleSettings> = {	1✔
227	name: 'data-filter-fp64',	1✔
228	vs,	1✔
229	fs,	1✔
230	inject,	1✔
231	getUniforms: getUniforms64	1✔
232	};	1✔

visgl / deck.gl / 8599229061

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