8729593332

Committed 17 Apr 2024 10:40PM UTC coverage: 90.006% (+0.004%) from 90.002%

Build # 8729593332

Build Type

Pull #8800

github

Committed by

web-flow

Commit Message

Merge a2695e3b3 into 68a336d2f

Pull Request Pull Request #8800: fix(extensions): DataFilterExtension handling of filterSoftRange

Run Details

6299 of 6932 branches covered (90.87%)

Branch coverage included in aggregate %.

13 of 13 new or added lines in 1 file covered. (100.0%)

12 existing lines in 2 files now uncovered.

51725 of 57535 relevant lines covered (89.9%)

6696.15 hits per line

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

94.79

/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
 */
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';
  /**
   * Number of numeric filtering channels. Must match dimension of `DATAFILTER_TYPE`
   */
  DATAFILTER_CHANNELS?: 1 | 2 | 3 | 4;
  /**
   * Enable 64-bit precision in numeric filter.
   */
  DATAFILTER_DOUBLE?: boolean;

  // Defines derived in shader
  /**
   * Numeric filter attribute
   */
  DATAFILTER_ATTRIB?: 'filterValues' | 'instanceFilterValues';
  /**
   * Numeric filter attribute (low bits). Only used when `DATAFILTER_DOUBLE = true`
   */
  DATAFILTER_ATTRIB_64LOW?: 'filterValues64Low' | 'instanceFilterValues64Low';
  /**
   * Category filter attribute
   */
  DATACATEGORY_ATTRIB?: 'filterCategoryValues' | 'instanceFilterCategoryValues';
};

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_TYPE
  void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {
    if (filter_useSoftMargin) {
      // smoothstep results are undefined if edge0 ≥ edge1
      // Fallback to ignore filterSoftRange if it is truncated by filterRange
      DATAFILTER_TYPE leftInRange = mix(
        step(filter_min, valueFromMin),
        smoothstep(filter_min, filter_softMin, valueFromMin),
        #if DATAFILTER_CHANNELS == 1
        filter_min < filter_softMin
        #else
        lessThan(filter_min, filter_softMin)
        #endif
      );
      DATAFILTER_TYPE rightInRange = mix(
        step(valueFromMax, filter_max),
        1.0 - smoothstep(filter_softMax, filter_max, valueFromMax),
        #if DATAFILTER_CHANNELS == 1
        filter_softMax < filter_max
        #else
        lessThan(filter_softMax, filter_max)
        #endif
      );
      dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);
    } 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	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	* Number of numeric filtering channels. Must match dimension of `DATAFILTER_TYPE`	1✔
25	*/	1✔
26	DATAFILTER_CHANNELS?: 1 \| 2 \| 3 \| 4;	1✔
27	/**	1✔
28	* Enable 64-bit precision in numeric filter.	1✔
29	*/	1✔
30	DATAFILTER_DOUBLE?: boolean;	1✔
31		1✔
32	// Defines derived in shader	1✔
33	/**	1✔
34	* Numeric filter attribute	1✔
35	*/	1✔
36	DATAFILTER_ATTRIB?: 'filterValues' \| 'instanceFilterValues';	1✔
37	/**	1✔
38	* Numeric filter attribute (low bits). Only used when `DATAFILTER_DOUBLE = true`	1✔
39	*/	1✔
40	DATAFILTER_ATTRIB_64LOW?: 'filterValues64Low' \| 'instanceFilterValues64Low';	1✔
41	/**	1✔
42	* Category filter attribute	1✔
43	*/	1✔
44	DATACATEGORY_ATTRIB?: 'filterCategoryValues' \| 'instanceFilterCategoryValues';	1✔
45	};	1✔
46		1✔
47	const vs = glsl`	1✔
48	uniform bool filter_useSoftMargin;	1✔
49	uniform bool filter_enabled;	1✔
50	uniform bool filter_transformSize;	1✔
51	uniform ivec4 filter_categoryBitMask;	1✔
52		1✔
53	#ifdef DATAFILTER_TYPE	1✔
54	uniform DATAFILTER_TYPE filter_min;	1✔
55	uniform DATAFILTER_TYPE filter_softMin;	1✔
56	uniform DATAFILTER_TYPE filter_softMax;	1✔
57	uniform DATAFILTER_TYPE filter_max;	1✔
58		1✔
59	#ifdef NON_INSTANCED_MODEL	1✔
60	#define DATAFILTER_ATTRIB filterValues	1✔
61	#define DATAFILTER_ATTRIB_64LOW filterValues64Low	1✔
62	#else	1✔
63	#define DATAFILTER_ATTRIB instanceFilterValues	1✔
64	#define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low	1✔
65	#endif	1✔
66		1✔
67	in DATAFILTER_TYPE DATAFILTER_ATTRIB;	1✔
68	#ifdef DATAFILTER_DOUBLE	1✔
69	in DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;	1✔
70		1✔
71	uniform DATAFILTER_TYPE filter_min64High;	1✔
72	uniform DATAFILTER_TYPE filter_max64High;	1✔
73	#endif	1✔
74	#endif	1✔
75		1✔
76		1✔
77	#ifdef DATACATEGORY_TYPE	1✔
78	#ifdef NON_INSTANCED_MODEL	1✔
79	#define DATACATEGORY_ATTRIB filterCategoryValues	1✔
80	#else	1✔
81	#define DATACATEGORY_ATTRIB instanceFilterCategoryValues	1✔
82	#endif	1✔
83	in DATACATEGORY_TYPE DATACATEGORY_ATTRIB;	1✔
84	#endif	1✔
85		1✔
86	out float dataFilter_value;	1✔
87		1✔
88	float dataFilter_reduceValue(float value) {	1✔
89	return value;	1✔
90	}	1✔
91	float dataFilter_reduceValue(vec2 value) {	1✔
92	return min(value.x, value.y);	1✔
93	}	1✔
94	float dataFilter_reduceValue(vec3 value) {	1✔
95	return min(min(value.x, value.y), value.z);	1✔
96	}	1✔
97	float dataFilter_reduceValue(vec4 value) {	1✔
98	return min(min(value.x, value.y), min(value.z, value.w));	1✔
99	}	1✔
100		1✔
101	#ifdef DATAFILTER_TYPE	1✔
102	void dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {	1✔
103	if (filter_useSoftMargin) {	1✔
104	// smoothstep results are undefined if edge0 ≥ edge1	1✔
105	// Fallback to ignore filterSoftRange if it is truncated by filterRange	1✔
106	DATAFILTER_TYPE leftInRange = mix(	1✔
107	step(filter_min, valueFromMin),	1✔
108	smoothstep(filter_min, filter_softMin, valueFromMin),	1✔
109	#if DATAFILTER_CHANNELS == 1	1✔
110	filter_min < filter_softMin	1✔
111	#else	1✔
112	lessThan(filter_min, filter_softMin)	1✔
113	#endif	1✔
114	);	1✔
115	DATAFILTER_TYPE rightInRange = mix(	1✔
116	step(valueFromMax, filter_max),	1✔
117	1.0 - smoothstep(filter_softMax, filter_max, valueFromMax),	1✔
118	#if DATAFILTER_CHANNELS == 1	1✔
119	filter_softMax < filter_max	1✔
120	#else	1✔
121	lessThan(filter_softMax, filter_max)	1✔
122	#endif	1✔
123	);	1✔
124	dataFilter_value = dataFilter_reduceValue(leftInRange * rightInRange);	1✔
125	} else {	1✔
126	dataFilter_value = dataFilter_reduceValue(	1✔
127	step(filter_min, valueFromMin) * step(valueFromMax, filter_max)	1✔
128	);	1✔
129	}	1✔
130	}	1✔
131	#endif	1✔
132		1✔
133	#ifdef DATACATEGORY_ATTRIB	1✔
134	void dataFilter_setCategoryValue(DATACATEGORY_TYPE category) {	1✔
135	#if DATACATEGORY_CHANNELS == 1 // One 128-bit mask	1✔
136	int dataFilter_masks = filter_categoryBitMask[int(category / 32.0)];	1✔
137	#elif DATACATEGORY_CHANNELS == 2 // Two 64-bit masks	1✔
138	ivec2 dataFilter_masks = ivec2(	1✔
139	filter_categoryBitMask[int(category.x / 32.0)],	1✔
140	filter_categoryBitMask[int(category.y / 32.0) + 2]	1✔
141	);	1✔
142	#elif DATACATEGORY_CHANNELS == 3 // Three 32-bit masks	1✔
143	ivec3 dataFilter_masks = filter_categoryBitMask.xyz;	1✔
144	#else // Four 32-bit masks	1✔
145	ivec4 dataFilter_masks = filter_categoryBitMask;	1✔
146	#endif	1✔
147		1✔
148	// Shift mask and extract relevant bits	1✔
149	DATACATEGORY_TYPE dataFilter_bits = DATACATEGORY_TYPE(dataFilter_masks) / pow(DATACATEGORY_TYPE(2.0), mod(category, 32.0));	1✔
150	dataFilter_bits = mod(floor(dataFilter_bits), 2.0);	1✔
151		1✔
152	#if DATACATEGORY_CHANNELS == 1	1✔
153	if(dataFilter_bits == 0.0) dataFilter_value = 0.0;	1✔
154	#else	1✔
155	if(any(equal(dataFilter_bits, DATACATEGORY_TYPE(0.0)))) dataFilter_value = 0.0;	1✔
156	#endif	1✔
157	}	1✔
158	#endif	1✔
159	`;	1✔
160		1✔
161	const fs = glsl`	1✔
162	uniform bool filter_transformColor;	1✔
163	in float dataFilter_value;	1✔
164	`;	1✔
165		1✔
166	type DataFilterModuleSettings = {	1✔
167	extensions: any[]; // used to detect if layer props are present	1✔
168	} & DataFilterExtensionProps;	1✔
169		1✔
170	/* eslint-disable camelcase */	1✔
171	function getUniforms(opts?: DataFilterModuleSettings \| {}): Record<string, any> {	22✔
172	if (!opts \|\| !('extensions' in opts)) {	22!
UNCOV 173	return {};	×
UNCOV 174	}	×
175	const {	22✔
176	filterRange = [-1, 1],	22✔
177	filterEnabled = true,	22✔
178	filterTransformSize = true,	22✔
179	filterTransformColor = true	22✔
180	} = opts;	22✔
181	const filterSoftRange = opts.filterSoftRange \|\| filterRange;	22✔
182		22✔
183	return {	22✔
184	...(Number.isFinite(filterRange[0])	22✔
185	? {	18✔
186	filter_min: filterRange[0],	18✔
187	filter_softMin: filterSoftRange[0],	18✔
188	filter_softMax: filterSoftRange[1],	18✔
189	filter_max: filterRange[1]	18✔
190	}	18✔
191	: {	4✔
192	filter_min: filterRange.map(r => r[0]),	4✔
193	filter_softMin: filterSoftRange.map(r => r[0]),	4✔
194	filter_softMax: filterSoftRange.map(r => r[1]),	4✔
195	filter_max: filterRange.map(r => r[1])	4✔
196	}),	4✔
197	filter_enabled: filterEnabled,	22✔
198	filter_useSoftMargin: Boolean(opts.filterSoftRange),	22✔
199	filter_transformSize: filterEnabled && filterTransformSize,	22✔
200	filter_transformColor: filterEnabled && filterTransformColor	22✔
201	};	22✔
202	}	22✔
203		1✔
204	function getUniforms64(opts?: DataFilterModuleSettings \| {}): Record<string, any> {	1✔
205	if (!opts \|\| !('extensions' in opts)) {	1!
206	return {};	×
207	}	×
208	const uniforms = getUniforms(opts);	1✔
209	if (Number.isFinite(uniforms.filter_min)) {	1!
UNCOV 210	const min64High = Math.fround(uniforms.filter_min);	×
UNCOV 211	uniforms.filter_min -= min64High;	×
UNCOV 212	uniforms.filter_softMin -= min64High;	×
UNCOV 213	uniforms.filter_min64High = min64High;	×
UNCOV 214		×
UNCOV 215	const max64High = Math.fround(uniforms.filter_max);	×
UNCOV 216	uniforms.filter_max -= max64High;	×
UNCOV 217	uniforms.filter_softMax -= max64High;	×
UNCOV 218	uniforms.filter_max64High = max64High;	×
219	} else {	1✔
220	const min64High = uniforms.filter_min.map(Math.fround);	1✔
221	uniforms.filter_min = uniforms.filter_min.map((x, i) => x - min64High[i]);	1✔
222	uniforms.filter_softMin = uniforms.filter_softMin.map((x, i) => x - min64High[i]);	1✔
223	uniforms.filter_min64High = min64High;	1✔
224		1✔
225	const max64High = uniforms.filter_max.map(Math.fround);	1✔
226	uniforms.filter_max = uniforms.filter_max.map((x, i) => x - max64High[i]);	1✔
227	uniforms.filter_softMax = uniforms.filter_softMax.map((x, i) => x - max64High[i]);	1✔
228	uniforms.filter_max64High = max64High;	1✔
229	}	1✔
230	return uniforms;	1✔
231	}	1✔
232		1✔
233	const inject = {	1✔
234	'vs:#main-start': glsl`	1✔
235	dataFilter_value = 1.0;	1✔
236	if (filter_enabled) {	1✔
237	#ifdef DATAFILTER_ATTRIB	1✔
238	#ifdef DATAFILTER_DOUBLE	1✔
239	dataFilter_setValue(	1✔
240	DATAFILTER_ATTRIB - filter_min64High + DATAFILTER_ATTRIB_64LOW,	1✔
241	DATAFILTER_ATTRIB - filter_max64High + DATAFILTER_ATTRIB_64LOW	1✔
242	);	1✔
243	#else	1✔
244	dataFilter_setValue(DATAFILTER_ATTRIB, DATAFILTER_ATTRIB);	1✔
245	#endif	1✔
246	#endif	1✔
247		1✔
248	#ifdef DATACATEGORY_ATTRIB	1✔
249	dataFilter_setCategoryValue(DATACATEGORY_ATTRIB);	1✔
250	#endif	1✔
251	}	1✔
252	`,	1✔
253		1✔
254	'vs:#main-end': glsl`	1✔
255	if (dataFilter_value == 0.0) {	1✔
256	gl_Position = vec4(0.);	1✔
257	}	1✔
258	`,	1✔
259		1✔
260	'vs:DECKGL_FILTER_SIZE': glsl`	1✔
261	if (filter_transformSize) {	1✔
262	size = size * dataFilter_value;	1✔
263	}	1✔
264	`,	1✔
265		1✔
266	'fs:DECKGL_FILTER_COLOR': glsl`	1✔
267	if (dataFilter_value == 0.0) discard;	1✔
268	if (filter_transformColor) {	1✔
269	color.a *= dataFilter_value;	1✔
270	}	1✔
271	`	1✔
272	};	1✔
273		1✔
274	export const shaderModule: ShaderModule<DataFilterModuleSettings> = {	1✔
275	name: 'data-filter',	1✔
276	vs,	1✔
277	fs,	1✔
278	inject,	1✔
279	getUniforms	1✔
280	};	1✔
281		1✔
282	export const shaderModule64: ShaderModule<DataFilterModuleSettings> = {	1✔
283	name: 'data-filter-fp64',	1✔
284	vs,	1✔
285	fs,	1✔
286	inject,	1✔
287	getUniforms: getUniforms64	1✔
288	};	1✔

visgl / deck.gl / 8729593332

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