7059221807

Committed 01 Dec 2023 11:08AM UTC coverage: 76.409% (+0.1%) from 76.294%

Build # 7059221807

Build Type

Pull #1856

github

Committed by

web-flow

Commit Message

Merge b1d1898ee into f516c2c56

Pull Request Pull Request #1856: Implement picking.useNormalizedColors

Run Details

1824 of 2427 branches covered (0.0%)

Branch coverage included in aggregate %.

65 of 65 new or added lines in 2 files covered. (100.0%)

18 existing lines in 2 files now uncovered.

34650 of 45308 relevant lines covered (76.48%)

43.41 hits per line

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

99.15

/modules/shadertools/src/modules/engine/picking/picking.ts

// luma.gl, MIT license
// Copyright (c) vis.gl contributors

import {NumberArray} from '../../../types';
import {glsl} from '../../../lib/glsl-utils/highlight';
import {ShaderModule} from '../../../lib/shader-module/shader-module';

// cyan color
const DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);

/** 
 * Uniforms for the picking module, which renders picking colors and highlighted item. 
 * When active, renders picking colors, assumed to be rendered to off-screen "picking" buffer. 
 * When inactive, renders normal colors, with the exception of selected object which is rendered with highlight 
 */
export type PickingUniforms = {
  /** 
   * When true, renders picking colors. Set when rendering to off-screen "picking" buffer. 
   * When false, renders normal colors, with the exception of selected object which is rendered with highlight 
   */
  isActive?: boolean;
  /** Set to true when picking an attribute value instead of object index */
  isAttribute: boolean;
  /** Color range 0-1 or 0-255 */
  useNormalizedColors?: boolean;
  /** Do we have a highlighted item? */
  isHighlightActive?: boolean;
  /** Set to a picking color to visually highlight that item */
  highlightedObjectColor?: NumberArray; 
  /** Color of visual highlight of "selected" item */
  highlightColor?: NumberArray;
};

const vs = glsl`\
uniform pickingUniforms {
  float isActive;
  float isAttribute;
  float isHighlightActive;
  float useNormalizedColors;
  vec3 highlightedObjectColor;
  vec4 highlightColor;
} picking;

out vec4 picking_vRGBcolor_Avalid;

// Normalize unsigned byte color to 0-1 range
vec3 picking_normalizeColor(vec3 color) {
  return picking.useNormalizedColors > 0.5 ? color : color / 255.0;
}

// Normalize unsigned byte color to 0-1 range
vec4 picking_normalizeColor(vec4 color) {
  return picking.useNormalizedColors > 0.5 ? color : color / 255.0;
}

bool picking_isColorZero(vec3 color) {
  return dot(color, vec3(1.0)) < 0.00001;
}

bool picking_isColorValid(vec3 color) {
  return dot(color, vec3(1.0)) > 0.00001;
}

// Check if this vertex is highlighted 
bool isVertexHighlighted(vec3 vertexColor) {
  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
  return
    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
}

// Set the current picking color
void picking_setPickingColor(vec3 pickingColor) {
  pickingColor = picking_normalizeColor(pickingColor);

  if (bool(picking.isActive)) {
    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));

    // if (!bool(picking.isAttribute)) {
    // Stores the picking color so that the fragment shader can render it during picking
    picking_vRGBcolor_Avalid.rgb = pickingColor;
    // }
  } else {
    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
  }
}

void picking_setPickingAttribute(float value) {
  if (bool(picking.isAttribute)) {
    picking_vRGBcolor_Avalid.r = value;
  }
}

void picking_setPickingAttribute(vec2 value) {
  if (bool(picking.isAttribute)) {
    picking_vRGBcolor_Avalid.rg = value;
  }
}

void picking_setPickingAttribute(vec3 value) {
  if (bool(picking.isAttribute)) {
    picking_vRGBcolor_Avalid.rgb = value;
  }
}
`;

const fs = glsl`\
uniform pickingUniforms {
  float isActive;
  float isAttribute;
  float isHighlightActive;
  float useNormalizedColors;
  vec3 highlightedObjectColor;
  vec4 highlightColor;
} picking;

in vec4 picking_vRGBcolor_Avalid;

/*
 * Returns highlight color if this item is selected.
 */
vec4 picking_filterHighlightColor(vec4 color) {
  // If we are still picking, we don't highlight
  if (picking.isActive > 0.5) {
    return color;
  }

  bool selected = bool(picking_vRGBcolor_Avalid.a);

  if (selected) {
    // Blend in highlight color based on its alpha value
    float highLightAlpha = picking.highlightColor.a;
    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
    float highLightRatio = highLightAlpha / blendedAlpha;

    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
    return vec4(blendedRGB, blendedAlpha);
  } else {
    return color;
  }
}

/*
 * Returns picking color if picking enabled else unmodified argument.
 */
vec4 picking_filterPickingColor(vec4 color) {
  if (bool(picking.isActive)) {
    if (picking_vRGBcolor_Avalid.a == 0.0) {
      discard;
    }
    return picking_vRGBcolor_Avalid;
  }
  return color;
}

/*
 * Returns picking color if picking is enabled if not
 * highlight color if this item is selected, otherwise unmodified argument.
 */
vec4 picking_filterColor(vec4 color) {
  vec4 highlightColor = picking_filterHighlightColor(color);
  return picking_filterPickingColor(highlightColor);
}
`;

/**
 * Provides support for color-coding-based picking and highlighting.
 * In particular, supports picking a specific instance in an instanced
 * draw call and highlighting an instance based on its picking color,
 * and correspondingly, supports picking and highlighting groups of
 * primitives with the same picking color in non-instanced draw-calls
 */
export const picking: ShaderModule<PickingUniforms> = {
  name: 'picking',
  vs,
  fs,
  uniformTypes: {
    isActive: 'f32',
    isAttribute: 'f32',
    useNormalizedColors: 'f32',
    isHighlightActive: 'f32',
    highlightedObjectColor: 'vec3<f32>',
    highlightColor: 'vec4<f32>'
  },
  defaultUniforms: {
    isActive: false,
    isAttribute: false,
    useNormalizedColors: true,
    isHighlightActive: false,
    highlightedObjectColor: new Float32Array([0, 0, 0]),
    highlightColor: DEFAULT_HIGHLIGHT_COLOR
  },
  getUniforms
};

function getUniforms(opts: Partial<PickingUniforms> = {}, prevUniforms?: PickingUniforms): PickingUniforms {
  const uniforms = {...picking.defaultUniforms};

  if (opts.highlightedObjectColor !== undefined) {
    if (!opts.highlightedObjectColor) {
      uniforms.isHighlightActive = false;
    } else {
      uniforms.isHighlightActive = true;
      const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
      uniforms.highlightedObjectColor = highlightedObjectColor;
    }
  }

  if (opts.highlightColor) {
    const color = Array.from(opts.highlightColor, (x) => x / 255);
    if (!Number.isFinite(color[3])) {
      color[3] = 1;
    }
    uniforms.highlightColor = color;
  }

  if (opts.isActive !== undefined) {
    uniforms.isActive = Boolean(opts.isActive);
    uniforms.isAttribute = Boolean(opts.isAttribute);
  }

  if (opts.useNormalizedColors !== undefined) {
    uniforms.useNormalizedColors = Boolean(opts.useNormalizedColors);
  }

  return uniforms;
}

1	// luma.gl, MIT license	1✔
2	// Copyright (c) vis.gl contributors	1✔
3		1✔
4	import {NumberArray} from '../../../types';	1✔
5	import {glsl} from '../../../lib/glsl-utils/highlight';	1✔
6	import {ShaderModule} from '../../../lib/shader-module/shader-module';	1✔
7		1✔
8	// cyan color	1✔
9	const DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);	1✔
10		1✔
11	/**	1✔
12	* Uniforms for the picking module, which renders picking colors and highlighted item.	1✔
13	* When active, renders picking colors, assumed to be rendered to off-screen "picking" buffer.	1✔
14	* When inactive, renders normal colors, with the exception of selected object which is rendered with highlight	1✔
15	*/	1✔
16	export type PickingUniforms = {	1✔
17	/**	1✔
18	* When true, renders picking colors. Set when rendering to off-screen "picking" buffer.	1✔
19	* When false, renders normal colors, with the exception of selected object which is rendered with highlight	1✔
20	*/	1✔
21	isActive?: boolean;	1✔
22	/** Set to true when picking an attribute value instead of object index */	1✔
23	isAttribute: boolean;	1✔
24	/** Color range 0-1 or 0-255 */	1✔
25	useNormalizedColors?: boolean;	1✔
26	/** Do we have a highlighted item? */	1✔
27	isHighlightActive?: boolean;	1✔
28	/** Set to a picking color to visually highlight that item */	1✔
29	highlightedObjectColor?: NumberArray;	1✔
30	/** Color of visual highlight of "selected" item */	1✔
31	highlightColor?: NumberArray;	1✔
32	};	1✔
33		1✔
34	const vs = glsl`\	1✔
35	uniform pickingUniforms {	1✔
36	float isActive;	1✔
37	float isAttribute;	1✔
38	float isHighlightActive;	1✔
39	float useNormalizedColors;	1✔
40	vec3 highlightedObjectColor;	1✔
41	vec4 highlightColor;	1✔
42	} picking;	1✔
43		1✔
44	out vec4 picking_vRGBcolor_Avalid;	1✔
45		1✔
46	// Normalize unsigned byte color to 0-1 range	1✔
47	vec3 picking_normalizeColor(vec3 color) {	1✔
48	return picking.useNormalizedColors > 0.5 ? color : color / 255.0;	1✔
49	}	1✔
50		1✔
51	// Normalize unsigned byte color to 0-1 range	1✔
52	vec4 picking_normalizeColor(vec4 color) {	1✔
53	return picking.useNormalizedColors > 0.5 ? color : color / 255.0;	1✔
54	}	1✔
55		1✔
56	bool picking_isColorZero(vec3 color) {	1✔
57	return dot(color, vec3(1.0)) < 0.00001;	1✔
58	}	1✔
59		1✔
60	bool picking_isColorValid(vec3 color) {	1✔
61	return dot(color, vec3(1.0)) > 0.00001;	1✔
62	}	1✔
63		1✔
64	// Check if this vertex is highlighted	1✔
65	bool isVertexHighlighted(vec3 vertexColor) {	1✔
66	vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);	1✔
67	return	1✔
68	bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));	1✔
69	}	1✔
70		1✔
71	// Set the current picking color	1✔
72	void picking_setPickingColor(vec3 pickingColor) {	1✔
73	pickingColor = picking_normalizeColor(pickingColor);	1✔
74		1✔
75	if (bool(picking.isActive)) {	1✔
76	// Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable	1✔
77	picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));	1✔
78		1✔
79	// if (!bool(picking.isAttribute)) {	1✔
80	// Stores the picking color so that the fragment shader can render it during picking	1✔
81	picking_vRGBcolor_Avalid.rgb = pickingColor;	1✔
82	// }	1✔
83	} else {	1✔
84	// Do the comparison with selected item color in vertex shader as it should mean fewer compares	1✔
85	picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));	1✔
86	}	1✔
87	}	1✔
88		1✔
89	void picking_setPickingAttribute(float value) {	1✔
90	if (bool(picking.isAttribute)) {	1✔
91	picking_vRGBcolor_Avalid.r = value;	1✔
92	}	1✔
93	}	1✔
94		1✔
95	void picking_setPickingAttribute(vec2 value) {	1✔
96	if (bool(picking.isAttribute)) {	1✔
97	picking_vRGBcolor_Avalid.rg = value;	1✔
98	}	1✔
99	}	1✔
100		1✔
101	void picking_setPickingAttribute(vec3 value) {	1✔
102	if (bool(picking.isAttribute)) {	1✔
103	picking_vRGBcolor_Avalid.rgb = value;	1✔
104	}	1✔
105	}	1✔
106	`;	1✔
107		1✔
108	const fs = glsl`\	1✔
109	uniform pickingUniforms {	1✔
110	float isActive;	1✔
111	float isAttribute;	1✔
112	float isHighlightActive;	1✔
113	float useNormalizedColors;	1✔
114	vec3 highlightedObjectColor;	1✔
115	vec4 highlightColor;	1✔
116	} picking;	1✔
117		1✔
118	in vec4 picking_vRGBcolor_Avalid;	1✔
119		1✔
120	/*	1✔
121	* Returns highlight color if this item is selected.	1✔
122	*/	1✔
123	vec4 picking_filterHighlightColor(vec4 color) {	1✔
124	// If we are still picking, we don't highlight	1✔
125	if (picking.isActive > 0.5) {	1✔
126	return color;	1✔
127	}	1✔
128		1✔
129	bool selected = bool(picking_vRGBcolor_Avalid.a);	1✔
130		1✔
131	if (selected) {	1✔
132	// Blend in highlight color based on its alpha value	1✔
133	float highLightAlpha = picking.highlightColor.a;	1✔
134	float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);	1✔
135	float highLightRatio = highLightAlpha / blendedAlpha;	1✔
136		1✔
137	vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);	1✔
138	return vec4(blendedRGB, blendedAlpha);	1✔
139	} else {	1✔
140	return color;	1✔
141	}	1✔
142	}	1✔
143		1✔
144	/*	1✔
145	* Returns picking color if picking enabled else unmodified argument.	1✔
146	*/	1✔
147	vec4 picking_filterPickingColor(vec4 color) {	1✔
148	if (bool(picking.isActive)) {	1✔
149	if (picking_vRGBcolor_Avalid.a == 0.0) {	1✔
150	discard;	1✔
151	}	1✔
152	return picking_vRGBcolor_Avalid;	1✔
153	}	1✔
154	return color;	1✔
155	}	1✔
156		1✔
157	/*	1✔
158	* Returns picking color if picking is enabled if not	1✔
159	* highlight color if this item is selected, otherwise unmodified argument.	1✔
160	*/	1✔
161	vec4 picking_filterColor(vec4 color) {	1✔
162	vec4 highlightColor = picking_filterHighlightColor(color);	1✔
163	return picking_filterPickingColor(highlightColor);	1✔
164	}	1✔
165	`;	1✔
166		1✔
167	/**	1✔
168	* Provides support for color-coding-based picking and highlighting.	1✔
169	* In particular, supports picking a specific instance in an instanced	1✔
170	* draw call and highlighting an instance based on its picking color,	1✔
171	* and correspondingly, supports picking and highlighting groups of	1✔
172	* primitives with the same picking color in non-instanced draw-calls	1✔
173	*/	1✔
174	export const picking: ShaderModule<PickingUniforms> = {	1✔
175	name: 'picking',	1✔
176	vs,	1✔
177	fs,	1✔
178	uniformTypes: {	1✔
179	isActive: 'f32',	1✔
180	isAttribute: 'f32',	1✔
181	useNormalizedColors: 'f32',	1✔
182	isHighlightActive: 'f32',	1✔
183	highlightedObjectColor: 'vec3<f32>',	1✔
184	highlightColor: 'vec4<f32>'	1✔
185	},	1✔
186	defaultUniforms: {	1✔
187	isActive: false,	1✔
188	isAttribute: false,	1✔
189	useNormalizedColors: true,	1✔
190	isHighlightActive: false,	1✔
191	highlightedObjectColor: new Float32Array([0, 0, 0]),	1✔
192	highlightColor: DEFAULT_HIGHLIGHT_COLOR	1✔
193	},	1✔
194	getUniforms	1✔
195	};	1✔
196		1✔
197	function getUniforms(opts: Partial<PickingUniforms> = {}, prevUniforms?: PickingUniforms): PickingUniforms {	5✔
198	const uniforms = {...picking.defaultUniforms};	5✔
199		5✔
200	if (opts.highlightedObjectColor !== undefined) {	5✔
201	if (!opts.highlightedObjectColor) {	2!
UNCOV 202	uniforms.isHighlightActive = false;	×
203	} else {	2✔
204	uniforms.isHighlightActive = true;	2✔
205	const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);	2✔
206	uniforms.highlightedObjectColor = highlightedObjectColor;	2✔
207	}	2✔
208	}	2✔
209		5✔
210	if (opts.highlightColor) {	5✔
211	const color = Array.from(opts.highlightColor, (x) => x / 255);	3✔
212	if (!Number.isFinite(color[3])) {	3✔
213	color[3] = 1;	1✔
214	}	1✔
215	uniforms.highlightColor = color;	3✔
216	}	3✔
217		5✔
218	if (opts.isActive !== undefined) {	5✔
219	uniforms.isActive = Boolean(opts.isActive);	1✔
220	uniforms.isAttribute = Boolean(opts.isAttribute);	1✔
221	}	1✔
222		5✔
223	if (opts.useNormalizedColors !== undefined) {	5✔
224	uniforms.useNormalizedColors = Boolean(opts.useNormalizedColors);	1✔
225	}	1✔
226		5✔
227	return uniforms;	5✔
228	}	5✔

visgl / luma.gl / 7059221807

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