11049480719

Committed 26 Sep 2024 09:28AM UTC coverage: 91.729% (-0.009%) from 91.738%

Build # 11049480719

Build Type

Pull #9160

github

Committed by

web-flow

Commit Message

Merge 884c9db3c into 728d9a6a9

Pull Request Pull Request #9160: Remove updateModuleSettings from codebase

Run Details

6731 of 7368 branches covered (91.35%)

Branch coverage included in aggregate %.

36 of 38 new or added lines in 4 files covered. (94.74%)

4 existing lines in 1 file now uncovered.

54995 of 59924 relevant lines covered (91.77%)

14645.96 hits per line

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

95.17

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

import type {ShaderModule} from '@luma.gl/shadertools';
import type {DataFilterExtensionOptions, DataFilterExtensionProps} from './data-filter-extension';
import {UniformFormat} from '@luma.gl/shadertools/dist/types';

/*
 * data filter shader module
 */
export type Defines = {
  // Defines passed externally
  /**
   * Primitive type of parameter used for category filtering. If undefined, category filtering disabled.
   */
  DATACATEGORY_TYPE?: 'float' | 'vec2' | 'vec3' | 'vec4';
  /**
   * Number of category filtering channels. Must match dimension of `DATACATEGORY_TYPE`
   */
  DATACATEGORY_CHANNELS?: 1 | 2 | 3 | 4;

  /**
   * Primitive type of parameter used for numeric filtering. If undefined, numeric filtering disabled.
   */
  DATAFILTER_TYPE?: 'float' | 'vec2' | 'vec3' | 'vec4';

  /**
   * Enable 64-bit precision in numeric filter.
   */
  DATAFILTER_DOUBLE?: boolean;
};

const uniformBlock = /* glsl */ `\
uniform dataFilterUniforms {
  bool useSoftMargin;
  bool enabled;
  bool transformSize;
  bool transformColor;
#ifdef DATAFILTER_TYPE
  DATAFILTER_TYPE min;
  DATAFILTER_TYPE softMin;
  DATAFILTER_TYPE softMax;
  DATAFILTER_TYPE max;
#ifdef DATAFILTER_DOUBLE
  DATAFILTER_TYPE min64High;
  DATAFILTER_TYPE max64High;
#endif
#endif
#ifdef DATACATEGORY_TYPE
  highp ivec4 categoryBitMask;
#endif
} dataFilter;
`;

const vertex = /* glsl */ `
#ifdef DATAFILTER_TYPE
  in DATAFILTER_TYPE filterValues;
#ifdef DATAFILTER_DOUBLE
  in DATAFILTER_TYPE filterValues64Low;
#endif
#endif

#ifdef DATACATEGORY_TYPE
  in DATACATEGORY_TYPE filterCategoryValues;
#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_TYPE
  void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
    if (dataFilter.useSoftMargin) {
      // smoothstep results are undefined if edge0 ≥ edge1
      // Fallback to ignore filterSoftRange if it is truncated by filterRange
      DATAFILTER_TYPE leftInRange = mix(
        smoothstep(dataFilter.min, dataFilter.softMin, valueFromMin),
        step(dataFilter.min, valueFromMin),
        step(dataFilter.softMin, dataFilter.min)
      );
      DATAFILTER_TYPE rightInRange = mix(
        1.0 - smoothstep(dataFilter.softMax, dataFilter.max, valueFromMax),
        step(valueFromMax, dataFilter.max),
        step(dataFilter.max, dataFilter.softMax)
      );
      dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);
    } else {
      dataFilter_value = dataFilter_reduceValue(
        step(dataFilter.min, valueFromMin) * step(valueFromMax, dataFilter.max)
      );
    }
  }
#endif

#ifdef DATACATEGORY_TYPE
  void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {
    #if DATACATEGORY_CHANNELS == 1 // One 128-bit mask
    int dataFilter_masks = dataFilter.categoryBitMask[int(category / 32.0)];
    #elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks
    ivec2 dataFilter_masks = ivec2(
      dataFilter.categoryBitMask[int(category.x / 32.0)],
      dataFilter.categoryBitMask[int(category.y / 32.0) + 2]
    );
    #elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks
    ivec3 dataFilter_masks = dataFilter.categoryBitMask.xyz;
    #else // Four 32-bit masks
    ivec4 dataFilter_masks = dataFilter.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 vs = `
${uniformBlock}
${vertex}
`;

const fragment = /* glsl */ `
in float dataFilter_value;
`;

const fs = `
${uniformBlock}
${fragment}
`;

export type CategoryBitMask = Uint32Array;
export type DataFilterModuleProps = {
  extensions: any[]; // used to detect if layer props are present
  categoryBitMask?: CategoryBitMask;
} & DataFilterExtensionProps;

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

  return {
    ...(Number.isFinite(filterRange[0])
      ? {
          min: filterRange[0],
          softMin: filterSoftRange[0],
          softMax: filterSoftRange[1],
          max: filterRange[1]
        }
      : {
          min: filterRange.map(r => r[0]),
          softMin: filterSoftRange.map(r => r[0]),
          softMax: filterSoftRange.map(r => r[1]),
          max: filterRange.map(r => r[1])
        }),
    enabled: filterEnabled,
    useSoftMargin: Boolean(opts.filterSoftRange),
    transformSize: filterEnabled && filterTransformSize,
    transformColor: filterEnabled && filterTransformColor,
    categoryBitMask
  };
}

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

    const max64High = Math.fround(uniforms.max);
    uniforms.max -= max64High;
    uniforms.softMax -= max64High;
    uniforms.max64High = max64High;
  } else {
    const min64High = uniforms.min.map(Math.fround);
    uniforms.min = uniforms.min.map((x, i) => x - min64High[i]);
    uniforms.softMin = uniforms.softMin.map((x, i) => x - min64High[i]);
    uniforms.min64High = min64High;

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

const inject = {
  'vs:#main-start': /* glsl */ `
    dataFilter_value = 1.0;
    if (dataFilter.enabled) {
      #ifdef DATAFILTER_TYPE
        #ifdef DATAFILTER_DOUBLE
          dataFilter_setValue(
            filterValues - dataFilter.min64High + filterValues64Low,
            filterValues - dataFilter.max64High + filterValues64Low
          );
        #else
          dataFilter_setValue(filterValues, filterValues);
        #endif
      #endif

      #ifdef DATACATEGORY_TYPE
        dataFilter_setCategoryValue(filterCategoryValues);
      #endif
    }
  `,

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

  'vs:DECKGL_FILTER_SIZE': /* glsl */ `
    if (dataFilter.transformSize) {
      size = size * dataFilter_value;
    }
  `,

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

type UniformTypesFunc = (opts: DataFilterExtensionOptions) => any;
function uniformTypesFromOptions(opts: DataFilterExtensionOptions): any {
  const {categorySize, filterSize, fp64} = opts;
  const uniformTypes: Record<string, UniformFormat> = {
    useSoftMargin: 'i32',
    enabled: 'i32',
    transformSize: 'i32',
    transformColor: 'i32'
  };

  if (filterSize) {
    const uniformFormat: UniformFormat = filterSize === 1 ? 'f32' : `vec${filterSize}<f32>`;
    uniformTypes.min = uniformFormat;
    uniformTypes.softMin = uniformFormat;
    uniformTypes.softMax = uniformFormat;
    uniformTypes.max = uniformFormat;
    if (fp64) {
      uniformTypes.min64High = uniformFormat;
      uniformTypes.max64High = uniformFormat;
    }
  }

  if (categorySize) {
    uniformTypes.categoryBitMask = 'vec4<i32>';
  }

  return uniformTypes;
}

export const dataFilter: ShaderModule<DataFilterModuleProps> & {
  uniformTypesFromOptions: UniformTypesFunc;
} = {
  name: 'dataFilter',
  vs,
  fs,
  inject,
  getUniforms,
  uniformTypesFromOptions
};

export const dataFilter64: ShaderModule<DataFilterModuleProps> & {
  uniformTypesFromOptions: UniformTypesFunc;
} = {
  name: 'dataFilter',
  vs,
  fs,
  inject,
  getUniforms: getUniforms64,
  uniformTypesFromOptions
};

1	import type {ShaderModule} from '@luma.gl/shadertools';	1✔
2	import type {DataFilterExtensionOptions, DataFilterExtensionProps} from './data-filter-extension';	1✔
3	import {UniformFormat} from '@luma.gl/shadertools/dist/types';	1✔
4		1✔
5	/*	1✔
6	* data filter shader module	1✔
7	*/	1✔
8	export type Defines = {	1✔
9	// Defines passed externally	1✔
10	/**	1✔
11	* Primitive type of parameter used for category filtering. If undefined, category filtering disabled.	1✔
12	*/	1✔
13	DATACATEGORY_TYPE?: 'float' \| 'vec2' \| 'vec3' \| 'vec4';	1✔
14	/**	1✔
15	* Number of category filtering channels. Must match dimension of `DATACATEGORY_TYPE`	1✔
16	*/	1✔
17	DATACATEGORY_CHANNELS?: 1 \| 2 \| 3 \| 4;	1✔
18		1✔
19	/**	1✔
20	* Primitive type of parameter used for numeric filtering. If undefined, numeric filtering disabled.	1✔
21	*/	1✔
22	DATAFILTER_TYPE?: 'float' \| 'vec2' \| 'vec3' \| 'vec4';	1✔
23		1✔
24	/**	1✔
25	* Enable 64-bit precision in numeric filter.	1✔
26	*/	1✔
27	DATAFILTER_DOUBLE?: boolean;	1✔
28	};	1✔
29		1✔
30	const uniformBlock = /* glsl */ `\	1✔
31	uniform dataFilterUniforms {	1✔
32	bool useSoftMargin;	1✔
33	bool enabled;	1✔
34	bool transformSize;	1✔
35	bool transformColor;	1✔
36	#ifdef DATAFILTER_TYPE	1✔
37	DATAFILTER_TYPE min;	1✔
38	DATAFILTER_TYPE softMin;	1✔
39	DATAFILTER_TYPE softMax;	1✔
40	DATAFILTER_TYPE max;	1✔
41	#ifdef DATAFILTER_DOUBLE	1✔
42	DATAFILTER_TYPE min64High;	1✔
43	DATAFILTER_TYPE max64High;	1✔
44	#endif	1✔
45	#endif	1✔
46	#ifdef DATACATEGORY_TYPE	1✔
47	highp ivec4 categoryBitMask;	1✔
48	#endif	1✔
49	} dataFilter;	1✔
50	`;	1✔
51		1✔
52	const vertex = /* glsl */ `	1✔
53	#ifdef DATAFILTER_TYPE	1✔
54	in DATAFILTER_TYPE filterValues;	1✔
55	#ifdef DATAFILTER_DOUBLE	1✔
56	in DATAFILTER_TYPE filterValues64Low;	1✔
57	#endif	1✔
58	#endif	1✔
59		1✔
60	#ifdef DATACATEGORY_TYPE	1✔
61	in DATACATEGORY_TYPE filterCategoryValues;	1✔
62	#endif	1✔
63		1✔
64	out float dataFilter_value;	1✔
65		1✔
66	float dataFilter_reduceValue(float value) {	1✔
67	return value;	1✔
68	}	1✔
69	float dataFilter_reduceValue(vec2 value) {	1✔
70	return min(value.x, value.y);	1✔
71	}	1✔
72	float dataFilter_reduceValue(vec3 value) {	1✔
73	return min(min(value.x, value.y), value.z);	1✔
74	}	1✔
75	float dataFilter_reduceValue(vec4 value) {	1✔
76	return min(min(value.x, value.y), min(value.z, value.w));	1✔
77	}	1✔
78		1✔
79	#ifdef DATAFILTER_TYPE	1✔
80	void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {	1✔
81	if (dataFilter.useSoftMargin) {	1✔
82	// smoothstep results are undefined if edge0 ≥ edge1	1✔
83	// Fallback to ignore filterSoftRange if it is truncated by filterRange	1✔
84	DATAFILTER_TYPE leftInRange = mix(	1✔
85	smoothstep(dataFilter.min, dataFilter.softMin, valueFromMin),	1✔
86	step(dataFilter.min, valueFromMin),	1✔
87	step(dataFilter.softMin, dataFilter.min)	1✔
88	);	1✔
89	DATAFILTER_TYPE rightInRange = mix(	1✔
90	1.0 - smoothstep(dataFilter.softMax, dataFilter.max, valueFromMax),	1✔
91	step(valueFromMax, dataFilter.max),	1✔
92	step(dataFilter.max, dataFilter.softMax)	1✔
93	);	1✔
94	dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);	1✔
95	} else {	1✔
96	dataFilter_value = dataFilter_reduceValue(	1✔
97	step(dataFilter.min, valueFromMin) * step(valueFromMax, dataFilter.max)	1✔
98	);	1✔
99	}	1✔
100	}	1✔
101	#endif	1✔
102		1✔
103	#ifdef DATACATEGORY_TYPE	1✔
104	void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {	1✔
105	#if DATACATEGORY_CHANNELS == 1 // One 128-bit mask	1✔
106	int dataFilter_masks = dataFilter.categoryBitMask[int(category / 32.0)];	1✔
107	#elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks	1✔
108	ivec2 dataFilter_masks = ivec2(	1✔
109	dataFilter.categoryBitMask[int(category.x / 32.0)],	1✔
110	dataFilter.categoryBitMask[int(category.y / 32.0) + 2]	1✔
111	);	1✔
112	#elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks	1✔
113	ivec3 dataFilter_masks = dataFilter.categoryBitMask.xyz;	1✔
114	#else // Four 32-bit masks	1✔
115	ivec4 dataFilter_masks = dataFilter.categoryBitMask;	1✔
116	#endif	1✔
117		1✔
118	// Shift mask and extract relevant bits	1✔
119	DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));	1✔
120	dataFilter_bits = mod(floor(dataFilter_bits), 2.0);	1✔
121		1✔
122	#if DATACATEGORY_CHANNELS == 1	1✔
123	if(dataFilter_bits == 0.0) dataFilter_value = 0.0;	1✔
124	#else	1✔
125	if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;	1✔
126	#endif	1✔
127	}	1✔
128	#endif	1✔
129	`;	1✔
130		1✔
131	const vs = `	1✔
132	${uniformBlock}	1✔
133	${vertex}	1✔
134	`;	1✔
135		1✔
136	const fragment = /* glsl */ `	1✔
137	in float dataFilter_value;	1✔
138	`;	1✔
139		1✔
140	const fs = `	1✔
141	${uniformBlock}	1✔
142	${fragment}	1✔
143	`;	1✔
144		1✔
145	export type CategoryBitMask = Uint32Array;	1✔
146	export type DataFilterModuleProps = {	1✔
147	extensions: any[]; // used to detect if layer props are present	1✔
148	categoryBitMask?: CategoryBitMask;	1✔
149	} & DataFilterExtensionProps;	1✔
150		1✔
151	/* eslint-disable camelcase */	1✔
152	function getUniforms(opts?: DataFilterModuleProps \| {}): Record<string, any> {	22✔
153	if (!opts \|\| !('extensions' in opts)) {	22!
UNCOV 154	return {};	×
UNCOV 155	}	×
156	const {	22✔
157	filterRange = [-1, 1],	22✔
158	filterEnabled = true,	22✔
159	filterTransformSize = true,	22✔
160	filterTransformColor = true,	22✔
161	categoryBitMask = [0, 0, 0, 0]	22✔
162	} = opts;	22✔
163	const filterSoftRange = opts.filterSoftRange \|\| filterRange;	22✔
164		22✔
165	return {	22✔
166	...(Number.isFinite(filterRange[0])	22✔
167	? {	18✔
168	min: filterRange[0],	18✔
169	softMin: filterSoftRange[0],	18✔
170	softMax: filterSoftRange[1],	18✔
171	max: filterRange[1]	18✔
172	}	18✔
173	: {	4✔
174	min: filterRange.map(r => r[0]),	4✔
175	softMin: filterSoftRange.map(r => r[0]),	4✔
176	softMax: filterSoftRange.map(r => r[1]),	4✔
177	max: filterRange.map(r => r[1])	4✔
178	}),	4✔
179	enabled: filterEnabled,	22✔
180	useSoftMargin: Boolean(opts.filterSoftRange),	22✔
181	transformSize: filterEnabled && filterTransformSize,	22✔
182	transformColor: filterEnabled && filterTransformColor,	22✔
183	categoryBitMask	22✔
184	};	22✔
185	}	22✔
186		1✔
187	function getUniforms64(opts?: DataFilterModuleProps \| {}): Record<string, any> {	1✔
188	if (!opts \|\| !('extensions' in opts)) {	1!
UNCOV 189	return {};	×
UNCOV 190	}	×
191	const uniforms = getUniforms(opts);	1✔
192	if (Number.isFinite(uniforms.min)) {	1!
193	const min64High = Math.fround(uniforms.min);	×
194	uniforms.min -= min64High;	×
195	uniforms.softMin -= min64High;	×
196	uniforms.min64High = min64High;	×
197		×
198	const max64High = Math.fround(uniforms.max);	×
199	uniforms.max -= max64High;	×
200	uniforms.softMax -= max64High;	×
201	uniforms.max64High = max64High;	×
202	} else {	1✔
203	const min64High = uniforms.min.map(Math.fround);	1✔
204	uniforms.min = uniforms.min.map((x, i) => x - min64High[i]);	1✔
205	uniforms.softMin = uniforms.softMin.map((x, i) => x - min64High[i]);	1✔
206	uniforms.min64High = min64High;	1✔
207		1✔
208	const max64High = uniforms.max.map(Math.fround);	1✔
209	uniforms.max = uniforms.max.map((x, i) => x - max64High[i]);	1✔
210	uniforms.softMax = uniforms.softMax.map((x, i) => x - max64High[i]);	1✔
211	uniforms.max64High = max64High;	1✔
212	}	1✔
213	return uniforms;	1✔
214	}	1✔
215		1✔
216	const inject = {	1✔
217	'vs:#main-start': /* glsl */ `	1✔
218	dataFilter_value = 1.0;	1✔
219	if (dataFilter.enabled) {	1✔
220	#ifdef DATAFILTER_TYPE	1✔
221	#ifdef DATAFILTER_DOUBLE	1✔
222	dataFilter_setValue(	1✔
223	filterValues - dataFilter.min64High + filterValues64Low,	1✔
224	filterValues - dataFilter.max64High + filterValues64Low	1✔
225	);	1✔
226	#else	1✔
227	dataFilter_setValue(filterValues, filterValues);	1✔
228	#endif	1✔
229	#endif	1✔
230		1✔
231	#ifdef DATACATEGORY_TYPE	1✔
232	dataFilter_setCategoryValue(filterCategoryValues);	1✔
233	#endif	1✔
234	}	1✔
235	`,	1✔
236		1✔
237	'vs:#main-end': /* glsl */ `	1✔
238	if (dataFilter_value == 0.0) {	1✔
239	gl_Position = vec4(0.);	1✔
240	}	1✔
241	`,	1✔
242		1✔
243	'vs:DECKGL_FILTER_SIZE': /* glsl */ `	1✔
244	if (dataFilter.transformSize) {	1✔
245	size = size * dataFilter_value;	1✔
246	}	1✔
247	`,	1✔
248		1✔
249	'fs:DECKGL_FILTER_COLOR': /* glsl */ `	1✔
250	if (dataFilter_value == 0.0) discard;	1✔
251	if (dataFilter.transformColor) {	1✔
252	color.a *= dataFilter_value;	1✔
253	}	1✔
254	`	1✔
255	};	1✔
256		1✔
257	type UniformTypesFunc = (opts: DataFilterExtensionOptions) => any;	1✔
258	function uniformTypesFromOptions(opts: DataFilterExtensionOptions): any {	18✔
259	const {categorySize, filterSize, fp64} = opts;	18✔
260	const uniformTypes: Record<string, UniformFormat> = {	18✔
261	useSoftMargin: 'i32',	18✔
262	enabled: 'i32',	18✔
263	transformSize: 'i32',	18✔
264	transformColor: 'i32'	18✔
265	};	18✔
266		18✔
267	if (filterSize) {	18✔
268	const uniformFormat: UniformFormat = filterSize === 1 ? 'f32' : `vec${filterSize}<f32>`;	16✔
269	uniformTypes.min = uniformFormat;	16✔
270	uniformTypes.softMin = uniformFormat;	16✔
271	uniformTypes.softMax = uniformFormat;	16✔
272	uniformTypes.max = uniformFormat;	16✔
273	if (fp64) {	16✔
274	uniformTypes.min64High = uniformFormat;	1✔
275	uniformTypes.max64High = uniformFormat;	1✔
276	}	1✔
277	}	16✔
278		18✔
279	if (categorySize) {	18✔
280	uniformTypes.categoryBitMask = 'vec4<i32>';	6✔
281	}	6✔
282		18✔
283	return uniformTypes;	18✔
284	}	18✔
285		1✔
286	export const dataFilter: ShaderModule<DataFilterModuleProps> & {	1✔
287	uniformTypesFromOptions: UniformTypesFunc;	1✔
288	} = {	1✔
289	name: 'dataFilter',	1✔
290	vs,	1✔
291	fs,	1✔
292	inject,	1✔
293	getUniforms,	1✔
294	uniformTypesFromOptions	1✔
295	};	1✔
296		1✔
297	export const dataFilter64: ShaderModule<DataFilterModuleProps> & {	1✔
298	uniformTypesFromOptions: UniformTypesFunc;	1✔
299	} = {	1✔
300	name: 'dataFilter',	1✔
301	vs,	1✔
302	fs,	1✔
303	inject,	1✔
304	getUniforms: getUniforms64,	1✔
305	uniformTypesFromOptions	1✔
306	};	1✔

visgl / deck.gl / 11049480719

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