@itwin/core-frontend 5.1.2 → 5.1.3-experimental.1

package/lib/esm/internal/render/webgl/glsl/FeatureSymbology.js

@@ -49,48 +49,48 @@ function computeFeatureIndex(vertex) {
     return vertex.usesVertexTable ? `g_featureIndex = ${computeLUTFeatureIndex};` : "";
 }
 function getFeatureIndex(vertex) {
-    return `
-float getFeatureIndex() {
-  ${computeFeatureIndex(vertex)}
-  return decodeUInt24(g_featureIndex);
-}
+    return `
+float getFeatureIndex() {
+  ${computeFeatureIndex(vertex)}
+  return decodeUInt24(g_featureIndex);
+}
 `;
 }
-const nthFeatureBitSet = `
-bool nthFeatureBitSet(float flags, uint n) {
-  return 0u == (u_globalOvrFlags & n) && nthBitSet(flags, n);
-}
+const nthFeatureBitSet = `
+bool nthFeatureBitSet(float flags, uint n) {
+  return 0u == (u_globalOvrFlags & n) && nthBitSet(flags, n);
+}
 `;
-const extractNthFeatureBit = `
-float extractNthFeatureBit(float flags, uint n) {
-  return 0u == (u_globalOvrFlags & n) && nthBitSet(flags, n) ? 1.0 : 0.0;
-}
+const extractNthFeatureBit = `
+float extractNthFeatureBit(float flags, uint n) {
+  return 0u == (u_globalOvrFlags & n) && nthBitSet(flags, n) ? 1.0 : 0.0;
+}
 `;
-const computeFeatureTextureCoords = `
-vec2 computeFeatureTextureCoords() { return compute_feature_coords(getFeatureIndex()); }
+const computeFeatureTextureCoords = `
+vec2 computeFeatureTextureCoords() { return compute_feature_coords(getFeatureIndex()); }
 `;
-const getFirstFeatureRgba = `
-vec4 getFirstFeatureRgba() {
-  feature_texCoord = computeFeatureTextureCoords();
-  return TEXTURE(u_featureLUT, feature_texCoord);
-}
+const getFirstFeatureRgba = `
+vec4 getFirstFeatureRgba() {
+  feature_texCoord = computeFeatureTextureCoords();
+  return TEXTURE(u_featureLUT, feature_texCoord);
+}
 `;
-const getSecondFeatureRgba = `
-vec4 getSecondFeatureRgba(bool isLinear) {
-  vec2 coord = feature_texCoord;
-  coord.x += g_feature_stepX * (isLinear ? 2.0 : 1.0);
-  return TEXTURE(u_featureLUT, coord);
-}
+const getSecondFeatureRgba = `
+vec4 getSecondFeatureRgba(bool isLinear) {
+  vec2 coord = feature_texCoord;
+  coord.x += g_feature_stepX * (isLinear ? 2.0 : 1.0);
+  return TEXTURE(u_featureLUT, coord);
+}
 `;
-const computeLineWeight = `
-float computeLineWeight() {
-  return linear_feature_overrides.x > 0.5 ? linear_feature_overrides.y : g_lineWeight;
-}
+const computeLineWeight = `
+float computeLineWeight() {
+  return linear_feature_overrides.x > 0.5 ? linear_feature_overrides.y : g_lineWeight;
+}
 `;
-const computeLineCode = `
-float computeLineCode() {
-  return linear_feature_overrides.z > 0.5 ? linear_feature_overrides.w : g_lineCode;
-}
+const computeLineCode = `
+float computeLineCode() {
+  return linear_feature_overrides.z > 0.5 ? linear_feature_overrides.w : g_lineCode;
+}
 `;
 export function addFeatureIndex(vert) {
     vert.addGlobal("g_featureIndex", 4 /* VariableType.Vec3 */);
@@ -99,30 +99,30 @@ export function addFeatureIndex(vert) {
 }
 // Discards vertex if feature is invisible; or rendering opaque during translucent pass or vice-versa
 // (The latter occurs when some translucent feature is overridden to be opaque, or vice-versa)
-const checkVertexDiscard = `
-  if (feature_invisible)
-    return true;
-
-  bool hasAlpha = 1.0 == u_hasAlpha;
-  if (feature_alpha > 0.0)
-    hasAlpha = feature_alpha <= s_maxAlpha;
-
-  int discardFlags = u_transparencyDiscardFlags;
-  bool discardViewIndependentDuringOpaque = discardFlags >= 4;
-  if (discardViewIndependentDuringOpaque)
-    discardFlags = discardFlags - 4;
-
-  bool isOpaquePass = (kRenderPass_OpaqueLinear <= u_renderPass && kRenderPass_OpaqueGeneral >= u_renderPass);
-  bool discardTranslucentDuringOpaquePass = 1 == discardFlags || 3 == discardFlags || (feature_viewIndependentTransparency && discardViewIndependentDuringOpaque);
-  if (isOpaquePass && !discardTranslucentDuringOpaquePass)
-    return false;
-
-  bool isTranslucentPass = kRenderPass_Translucent == u_renderPass;
-  bool discardOpaqueDuringTranslucentPass = 2 == discardFlags || 3 == discardFlags;
-  if (isTranslucentPass && !discardOpaqueDuringTranslucentPass)
-    return false;
-
-  return (isOpaquePass && hasAlpha) || (isTranslucentPass && !hasAlpha);
+const checkVertexDiscard = `
+  if (feature_invisible)
+    return true;
+
+  bool hasAlpha = 1.0 == u_hasAlpha;
+  if (feature_alpha > 0.0)
+    hasAlpha = feature_alpha <= s_maxAlpha;
+
+  int discardFlags = u_transparencyDiscardFlags;
+  bool discardViewIndependentDuringOpaque = discardFlags >= 4;
+  if (discardViewIndependentDuringOpaque)
+    discardFlags = discardFlags - 4;
+
+  bool isOpaquePass = (kRenderPass_OpaqueLinear <= u_renderPass && kRenderPass_OpaqueGeneral >= u_renderPass);
+  bool discardTranslucentDuringOpaquePass = 1 == discardFlags || 3 == discardFlags || (feature_viewIndependentTransparency && discardViewIndependentDuringOpaque);
+  if (isOpaquePass && !discardTranslucentDuringOpaquePass)
+    return false;
+
+  bool isTranslucentPass = kRenderPass_Translucent == u_renderPass;
+  bool discardOpaqueDuringTranslucentPass = 2 == discardFlags || 3 == discardFlags;
+  if (isTranslucentPass && !discardOpaqueDuringTranslucentPass)
+    return false;
+
+  return (isOpaquePass && hasAlpha) || (isTranslucentPass && !hasAlpha);
 `;
 function addTransparencyDiscardFlags(vert) {
     // Even when transparency view flag is off, we need to allow features to override transparency, because it
@@ -256,27 +256,27 @@ function addHiliteSettings(frag, wantFlashMode) {
 // If feature is not hilited, discard it.
 const checkVertexHiliteDiscard = "return 0.0 == v_feature_hilited;";
 // The result is a mask in which each pixel's r=1 if hilited and g=1 if emphasized (and not hilited).
-const computeHiliteColor = `
-  float flags = floor(v_feature_hilited + 0.5);
-  float hilited = extractNthBit(flags, kEmphBit_Hilite);
-  float emphasized = extractNthBit(flags, kEmphBit_Emphasize);
-  return vec4(hilited, emphasized, 0.0, 0.0);
+const computeHiliteColor = `
+  float flags = floor(v_feature_hilited + 0.5);
+  float hilited = extractNthBit(flags, kEmphBit_Hilite);
+  float emphasized = extractNthBit(flags, kEmphBit_Emphasize);
+  return vec4(hilited, emphasized, 0.0, 0.0);
 `;
-const computeSurfaceHiliteColor = `
-  if (isSurfaceBitSet(kSurfaceBit_HasTexture) && TEXTURE(s_texture, v_texCoord).a <= 0.15)
-    return vec4(0.0);
+const computeSurfaceHiliteColor = `
+  if (isSurfaceBitSet(kSurfaceBit_HasTexture) && TEXTURE(s_texture, v_texCoord).a <= 0.15)
+    return vec4(0.0);
 ${computeHiliteColor}`;
-const computeHiliteOverrides = `
-  vec4 value = getFirstFeatureRgba();
-  float emphFlags = value.g * 256.0;
-  v_feature_hilited = kEmphFlag_Hilite * extractNthBit(emphFlags, kOvrBit_Hilited) + kEmphFlag_Emphasize * extractNthBit(emphFlags, kOvrBit_Emphasized);
+const computeHiliteOverrides = `
+  vec4 value = getFirstFeatureRgba();
+  float emphFlags = value.g * 256.0;
+  v_feature_hilited = kEmphFlag_Hilite * extractNthBit(emphFlags, kOvrBit_Hilited) + kEmphFlag_Emphasize * extractNthBit(emphFlags, kOvrBit_Emphasized);
 `;
-const computeHiliteOverridesWithWeight = `${computeHiliteOverrides}
-  float flags = value.r * 256.0;
-  linear_feature_overrides = vec4(nthFeatureBitSet(flags, kOvrBit_Weight),
-  value.a * 256.0,
-  nthFeatureBitSet(flags, kOvrBit_LineCode),
-  value.b * 256.0);
+const computeHiliteOverridesWithWeight = `${computeHiliteOverrides}
+  float flags = value.r * 256.0;
+  linear_feature_overrides = vec4(nthFeatureBitSet(flags, kOvrBit_Weight),
+  value.a * 256.0,
+  nthFeatureBitSet(flags, kOvrBit_LineCode),
+  value.b * 256.0);
 `;
 /** @internal */
 export function addSurfaceHiliter(builder, wantWeight = false) {
@@ -314,78 +314,78 @@ function addSamplers(frag, testFeatureId) {
     }, 3 /* VariablePrecision.High */);
 }
 /** @internal */
-export const readDepthAndOrder = `
-vec2 readDepthAndOrder(vec2 tc) {
-  vec4 pdo = TEXTURE(u_pickDepthAndOrder, tc);
-  float order = floor(pdo.x * 16.0 + 0.5);
-  return vec2(order, decodeDepthRgb(pdo.yzw));
-}
+export const readDepthAndOrder = `
+vec2 readDepthAndOrder(vec2 tc) {
+  vec4 pdo = TEXTURE(u_pickDepthAndOrder, tc);
+  float order = floor(pdo.x * 16.0 + 0.5);
+  return vec2(order, decodeDepthRgb(pdo.yzw));
+}
 `;
-const checkForEarlySurfaceDiscard = `
-  float factor = float(u_renderPass <= kRenderPass_Translucent); // never discard during specific passes
-  float term = 0.0;
-
-  vec2 tc = windowCoordsToTexCoords(gl_FragCoord.xy);
-  vec2 depthAndOrder = readDepthAndOrder(tc);
-
-  float surfaceDepth = computeLinearDepth(v_eyeSpace.z);
-  term += float(depthAndOrder.x > u_renderOrder && abs(depthAndOrder.y - surfaceDepth) < 4.0e-5);
-  return factor * term > 0.0;
+const checkForEarlySurfaceDiscard = `
+  float factor = float(u_renderPass <= kRenderPass_Translucent); // never discard during specific passes
+  float term = 0.0;
+
+  vec2 tc = windowCoordsToTexCoords(gl_FragCoord.xy);
+  vec2 depthAndOrder = readDepthAndOrder(tc);
+
+  float surfaceDepth = computeLinearDepth(v_eyeSpace.z);
+  term += float(depthAndOrder.x > u_renderOrder && abs(depthAndOrder.y - surfaceDepth) < 4.0e-5);
+  return factor * term > 0.0;
 `;
-const checkForEarlySurfaceDiscardWithFeatureID = `
-  // No normals => unlt => reality model => no edges.
-  if (u_renderPass > kRenderPass_Translucent || u_renderPass == kRenderPass_Layers || !u_surfaceFlags[kSurfaceBitIndex_HasNormals])
-    return false;
-
-  vec2 tc = windowCoordsToTexCoords(gl_FragCoord.xy);
-  vec2 depthAndOrder = readDepthAndOrder(tc);
-
-  if (depthAndOrder.x <= u_renderOrder)
-    return false;
-
-  // Calculate depthTolerance for letting edges show through their own surfaces
-  float perspectiveFrustum = step(kFrustumType_Perspective, u_frustum.z);
-  vec4 eyeDirAndWidthFactor = mix(vec4(0.0, 0.0, 1.0, u_pixelWidthFactor), vec4(normalize(-v_eyeSpace.xyz), -v_eyeSpace.z * u_pixelWidthFactor), perspectiveFrustum);
-  vec3 eyeDir = eyeDirAndWidthFactor.xyz;
-  float dtWidthFactor = eyeDirAndWidthFactor.w;
-
-  // Compute depth tolerance based on angle of triangle to screen
-  float isSilhouette = float(depthAndOrder.x == kRenderOrder_Silhouette);
-  float dSq = dot(eyeDir, v_n);
-  dSq *= 0.5 + 0.4 * (1.0 - isSilhouette);
-  dSq = dSq * dSq;
-  dSq = max(dSq, 0.0001);
-  dSq = min(dSq, 0.999);
-
-  float depthTolerance = dtWidthFactor * v_lineWeight * sqrt((1.0 - dSq) / dSq);
-  depthTolerance *= 1.0 + .333 * isSilhouette;
-
-  // Make sure stuff behind camera doesn't get pushed in front of it
-  depthTolerance = max(depthTolerance, 0.0);
-
-  // Convert depthTolerance from eye space to linear depth
-  depthTolerance /= (u_frustum.y - u_frustum.x);
-
-  float surfaceDepth = computeLinearDepth(v_eyeSpace.z);
-  float depthDelta = abs(depthAndOrder.y - surfaceDepth);
-  if (depthDelta > depthTolerance)
-    return false;
-
-  // Does pick buffer contain same feature?
-  vec4 featId = TEXTURE(u_pickFeatureId, tc);
-
-  // Converting to ints to test since varying floats can be interpolated incorrectly
-  ivec4 featId_i = ivec4(featId * 255.0 + 0.5);
-  ivec4 feature_id_i = ivec4(feature_id * 255.0 + 0.5);
-  if (featId_i == feature_id_i)
-    return true;
-
-  // In 2d, display priority controls draw order of different elements.
-  if (!u_checkInterElementDiscard)
-    return false;
-
-  // Use a tighter tolerance for two different elements since we're only fighting roundoff error.
-  return depthDelta <= 4.0e-5;
+const checkForEarlySurfaceDiscardWithFeatureID = `
+  // No normals => unlt => reality model => no edges.
+  if (u_renderPass > kRenderPass_Translucent || u_renderPass == kRenderPass_Layers || !u_surfaceFlags[kSurfaceBitIndex_HasNormals])
+    return false;
+
+  vec2 tc = windowCoordsToTexCoords(gl_FragCoord.xy);
+  vec2 depthAndOrder = readDepthAndOrder(tc);
+
+  if (depthAndOrder.x <= u_renderOrder)
+    return false;
+
+  // Calculate depthTolerance for letting edges show through their own surfaces
+  float perspectiveFrustum = step(kFrustumType_Perspective, u_frustum.z);
+  vec4 eyeDirAndWidthFactor = mix(vec4(0.0, 0.0, 1.0, u_pixelWidthFactor), vec4(normalize(-v_eyeSpace.xyz), -v_eyeSpace.z * u_pixelWidthFactor), perspectiveFrustum);
+  vec3 eyeDir = eyeDirAndWidthFactor.xyz;
+  float dtWidthFactor = eyeDirAndWidthFactor.w;
+
+  // Compute depth tolerance based on angle of triangle to screen
+  float isSilhouette = float(depthAndOrder.x == kRenderOrder_Silhouette);
+  float dSq = dot(eyeDir, v_n);
+  dSq *= 0.5 + 0.4 * (1.0 - isSilhouette);
+  dSq = dSq * dSq;
+  dSq = max(dSq, 0.0001);
+  dSq = min(dSq, 0.999);
+
+  float depthTolerance = dtWidthFactor * v_lineWeight * sqrt((1.0 - dSq) / dSq);
+  depthTolerance *= 1.0 + .333 * isSilhouette;
+
+  // Make sure stuff behind camera doesn't get pushed in front of it
+  depthTolerance = max(depthTolerance, 0.0);
+
+  // Convert depthTolerance from eye space to linear depth
+  depthTolerance /= (u_frustum.y - u_frustum.x);
+
+  float surfaceDepth = computeLinearDepth(v_eyeSpace.z);
+  float depthDelta = abs(depthAndOrder.y - surfaceDepth);
+  if (depthDelta > depthTolerance)
+    return false;
+
+  // Does pick buffer contain same feature?
+  vec4 featId = TEXTURE(u_pickFeatureId, tc);
+
+  // Converting to ints to test since varying floats can be interpolated incorrectly
+  ivec4 featId_i = ivec4(featId * 255.0 + 0.5);
+  ivec4 feature_id_i = ivec4(feature_id * 255.0 + 0.5);
+  if (featId_i == feature_id_i)
+    return true;
+
+  // In 2d, display priority controls draw order of different elements.
+  if (!u_checkInterElementDiscard)
+    return false;
+
+  // Use a tighter tolerance for two different elements since we're only fighting roundoff error.
+  return depthDelta <= 4.0e-5;
 `;
 // This only adds the constants that are actually used in shader code.
 export function addRenderOrderConstants(builder) {
@@ -427,9 +427,9 @@ function addBatchId(builder) {
     }, 3 /* VariablePrecision.High */);
 }
 const computeIdVert = `v_feature_id = addUInt32s(u_batch_id, vec4(g_featureIndex, 0.0)) / 255.0;`;
-const computeIdFrag = `
-  vec4 featureIndex = vec4(floor(v_feature_index + 0.5), 0.0);
-  feature_id = addUInt32s(u_batch_id, featureIndex) / 255.0;
+const computeIdFrag = `
+  vec4 featureIndex = vec4(floor(v_feature_index + 0.5), 0.0);
+  feature_id = addUInt32s(u_batch_id, featureIndex) / 255.0;
 `;
 /** @internal */
 export function addFeatureId(builder, computeInFrag) {
@@ -452,8 +452,8 @@ export function addFeatureId(builder, computeInFrag) {
 // Discard vertex if transparency is less than the display style's transparency threshold, IFF the specific bit is set. The bit is set if:
 //  - Solid Fill or Hidden Line mode; or
 //  - Shaded mode and generating shadow map (sufficiently transparent surfaces receive but do not cast shadows).
-const isBelowTransparencyThreshold = `
-  return v_color.a < u_transparencyThreshold && u_surfaceFlags[kSurfaceBitIndex_TransparencyThreshold];
+const isBelowTransparencyThreshold = `
+  return v_color.a < u_transparencyThreshold && u_surfaceFlags[kSurfaceBitIndex_TransparencyThreshold];
 `;
 /** @internal */
 export function addSurfaceDiscard(builder, flags) {
@@ -513,102 +513,102 @@ export function addSurfaceDiscard(builder, flags) {
 // float feature_alpha // alpha if overridden, else < 0
 // varying float v_feature_emphasis // bitmask - see kEmph_* constants
 // vec4 linear_feature_overrides; // x: weight overridden y: weight z: line code overridden w: line code
-const computeFeatureOverrides = `
-  feature_rgb = vec3(-1.0);
-  feature_alpha = -1.0;
-  vec4 value = getFirstFeatureRgba();
-
-  float emphFlags = value.y * 256.0;
-  if (nthFeatureBitSet(emphFlags, kOvrBit_InvisibleDuringPick)) {
-    feature_invisible = true;
-    return;
-  }
-    
-  v_feature_emphasis = kEmphFlag_Hilite * extractNthBit(emphFlags, kOvrBit_Hilited) + kEmphFlag_Emphasize * extractNthBit(emphFlags, kOvrBit_Emphasized);
-
-  float flags = value.x * 256.0;
-  if (0.0 == flags && 0.0 == emphFlags)
-    return; // nothing overridden for this feature
-
-  bool nonLocatable = (u_shaderFlags[kShaderBit_IgnoreNonLocatable] ? nthFeatureBitSet(flags, kOvrBit_NonLocatable) : false);
-  v_feature_emphasis += kEmphFlag_NonLocatable * float(nthFeatureBitSet(flags, kOvrBit_NonLocatable));
-  bool invisible = nthFeatureBitSet(emphFlags, kOvrBit_Visibility);
-  feature_invisible = invisible || nonLocatable;
-  if (feature_invisible)
-    return;
-
-  bool isLinear = u_renderOrder == kRenderOrder_Linear || u_renderOrder == kRenderOrder_PlanarLinear || u_renderOrder == kRenderOrder_PlanarEdge;
-  bool rgbOverridden = isLinear ? nthFeatureBitSet(flags, kOvrBit_LineRgb) : nthFeatureBitSet(flags, kOvrBit_Rgb);
-  bool alphaOverridden = isLinear ? nthFeatureBitSet(flags, kOvrBit_LineAlpha) : nthFeatureBitSet(flags, kOvrBit_Alpha);
-  if (alphaOverridden || rgbOverridden) {
-    vec4 rgba = getSecondFeatureRgba(isLinear);
-    if (rgbOverridden)
-      feature_rgb = rgba.rgb;
-
-    if (alphaOverridden) {
-      feature_alpha = rgba.a;
-      feature_viewIndependentTransparency = nthFeatureBitSet(emphFlags, kOvrBit_ViewIndependentTransparency);
-    }
-  }
-
-  linear_feature_overrides = vec4(nthFeatureBitSet(flags, kOvrBit_Weight),
-                                  value.w * 256.0,
-                                  nthFeatureBitSet(flags, kOvrBit_LineCode),
-                                  value.z * 256.0);
-
-  feature_ignore_material = nthFeatureBitSet(emphFlags, kOvrBit_IgnoreMaterial);
-  use_material = use_material && !feature_ignore_material;
-
-  v_feature_emphasis += kEmphFlag_Flash * extractNthFeatureBit(flags, kOvrBit_Flashed);
+const computeFeatureOverrides = `
+  feature_rgb = vec3(-1.0);
+  feature_alpha = -1.0;
+  vec4 value = getFirstFeatureRgba();
+
+  float emphFlags = value.y * 256.0;
+  if (nthFeatureBitSet(emphFlags, kOvrBit_InvisibleDuringPick)) {
+    feature_invisible = true;
+    return;
+  }
+    
+  v_feature_emphasis = kEmphFlag_Hilite * extractNthBit(emphFlags, kOvrBit_Hilited) + kEmphFlag_Emphasize * extractNthBit(emphFlags, kOvrBit_Emphasized);
+
+  float flags = value.x * 256.0;
+  if (0.0 == flags && 0.0 == emphFlags)
+    return; // nothing overridden for this feature
+
+  bool nonLocatable = (u_shaderFlags[kShaderBit_IgnoreNonLocatable] ? nthFeatureBitSet(flags, kOvrBit_NonLocatable) : false);
+  v_feature_emphasis += kEmphFlag_NonLocatable * float(nthFeatureBitSet(flags, kOvrBit_NonLocatable));
+  bool invisible = nthFeatureBitSet(emphFlags, kOvrBit_Visibility);
+  feature_invisible = invisible || nonLocatable;
+  if (feature_invisible)
+    return;
+
+  bool isLinear = u_renderOrder == kRenderOrder_Linear || u_renderOrder == kRenderOrder_PlanarLinear || u_renderOrder == kRenderOrder_PlanarEdge;
+  bool rgbOverridden = isLinear ? nthFeatureBitSet(flags, kOvrBit_LineRgb) : nthFeatureBitSet(flags, kOvrBit_Rgb);
+  bool alphaOverridden = isLinear ? nthFeatureBitSet(flags, kOvrBit_LineAlpha) : nthFeatureBitSet(flags, kOvrBit_Alpha);
+  if (alphaOverridden || rgbOverridden) {
+    vec4 rgba = getSecondFeatureRgba(isLinear);
+    if (rgbOverridden)
+      feature_rgb = rgba.rgb;
+
+    if (alphaOverridden) {
+      feature_alpha = rgba.a;
+      feature_viewIndependentTransparency = nthFeatureBitSet(emphFlags, kOvrBit_ViewIndependentTransparency);
+    }
+  }
+
+  linear_feature_overrides = vec4(nthFeatureBitSet(flags, kOvrBit_Weight),
+                                  value.w * 256.0,
+                                  nthFeatureBitSet(flags, kOvrBit_LineCode),
+                                  value.z * 256.0);
+
+  feature_ignore_material = nthFeatureBitSet(emphFlags, kOvrBit_IgnoreMaterial);
+  use_material = use_material && !feature_ignore_material;
+
+  v_feature_emphasis += kEmphFlag_Flash * extractNthFeatureBit(flags, kOvrBit_Flashed);
 `;
 // feature_rgb.r = -1.0 if rgb color not overridden for feature.
 // feature_alpha = -1.0 if alpha not overridden for feature.
-const applyFeatureColor = `
-  vec3 rgb = mix(baseColor.rgb, feature_rgb.rgb, step(0.0, feature_rgb.r));
-  float alpha = mix(baseColor.a, feature_alpha, step(0.0, feature_alpha));
-  return vec4(rgb, alpha);
+const applyFeatureColor = `
+  vec3 rgb = mix(baseColor.rgb, feature_rgb.rgb, step(0.0, feature_rgb.r));
+  float alpha = mix(baseColor.a, feature_alpha, step(0.0, feature_alpha));
+  return vec4(rgb, alpha);
 `;
 // feature_rgb.r = -1.0 if rgb color not overridden for feature, else mix based on u_overrrideColorMix.
 // feature_alpha = -1.0 if alpha not overridden for feature.
-export const mixFeatureColor = `
-  vec3 rgb = mix(baseColor.rgb, mix(baseColor.rgb, feature_rgb.rgb, u_overrideColorMix), step(0.0, feature_rgb.r));
-  float alpha = mix(baseColor.a, feature_alpha, step(0.0, feature_alpha));
-  return vec4(rgb, alpha);
+export const mixFeatureColor = `
+  vec3 rgb = mix(baseColor.rgb, mix(baseColor.rgb, feature_rgb.rgb, u_overrideColorMix), step(0.0, feature_rgb.r));
+  float alpha = mix(baseColor.a, feature_alpha, step(0.0, feature_alpha));
+  return vec4(rgb, alpha);
   `;
-const applyFlash = `
-  float flashHilite = floor(v_feature_emphasis + 0.5);
-  return doApplyFlash(flashHilite, baseColor);
+const applyFlash = `
+  float flashHilite = floor(v_feature_emphasis + 0.5);
+  return doApplyFlash(flashHilite, baseColor);
 `;
-const doApplyFlash = `
-vec4 doApplyFlash(float flags, vec4 baseColor) {
-  bool isFlashed = nthBitSet(flags, kEmphBit_Flash);
-  bool isHilited = nthBitSet(flags, kEmphBit_Hilite);
-  bool isEmphasized = !isHilited && nthBitSet(flags, kEmphBit_Emphasize);
-  vec3 hiliteRgb = isEmphasized ? u_hilite_settings[1] : u_hilite_settings[0];
-
-  isHilited = isEmphasized || isHilited;
-  float hiliteRatio = isHilited ? (isEmphasized ? u_hilite_settings[2][1] : u_hilite_settings[2][0]) : 0.0;
-  baseColor.rgb = mix(baseColor.rgb, hiliteRgb, hiliteRatio);
-
-  const float maxBrighten = 0.2;
-  float brighten = isFlashed ? u_flash_intensity * maxBrighten : 0.0;
-  vec3 brightRgb = baseColor.rgb + brighten;
-
-  const float maxTween = 0.75;
-  float hiliteFraction = isFlashed ? u_flash_intensity * maxTween : 0.0;
-  vec3 tweenRgb = baseColor.rgb * (1.0 - hiliteFraction);
-  tweenRgb += u_hilite_settings[0] * hiliteFraction;
-
-  return vec4(mix(tweenRgb, brightRgb, u_flash_mode), baseColor.a);
-}
+const doApplyFlash = `
+vec4 doApplyFlash(float flags, vec4 baseColor) {
+  bool isFlashed = nthBitSet(flags, kEmphBit_Flash);
+  bool isHilited = nthBitSet(flags, kEmphBit_Hilite);
+  bool isEmphasized = !isHilited && nthBitSet(flags, kEmphBit_Emphasize);
+  vec3 hiliteRgb = isEmphasized ? u_hilite_settings[1] : u_hilite_settings[0];
+
+  isHilited = isEmphasized || isHilited;
+  float hiliteRatio = isHilited ? (isEmphasized ? u_hilite_settings[2][1] : u_hilite_settings[2][0]) : 0.0;
+  baseColor.rgb = mix(baseColor.rgb, hiliteRgb, hiliteRatio);
+
+  const float maxBrighten = 0.2;
+  float brighten = isFlashed ? u_flash_intensity * maxBrighten : 0.0;
+  vec3 brightRgb = baseColor.rgb + brighten;
+
+  const float maxTween = 0.75;
+  float hiliteFraction = isFlashed ? u_flash_intensity * maxTween : 0.0;
+  vec3 tweenRgb = baseColor.rgb * (1.0 - hiliteFraction);
+  tweenRgb += u_hilite_settings[0] * hiliteFraction;
+
+  return vec4(mix(tweenRgb, brightRgb, u_flash_mode), baseColor.a);
+}
 `;
-const doClassifierFlash = `
-vec4 applyClassifierFlash(vec4 baseColor) {
-  const float maxBrighten = 0.2;
-  float brighten = u_flash_intensity * maxBrighten;
-  vec3 brightRgb = baseColor.rgb + brighten;
-  return vec4(brightRgb, baseColor.a);
-}
+const doClassifierFlash = `
+vec4 applyClassifierFlash(vec4 baseColor) {
+  const float maxBrighten = 0.2;
+  float brighten = u_flash_intensity * maxBrighten;
+  vec3 brightRgb = baseColor.rgb + brighten;
+  return vec4(brightRgb, baseColor.a);
+}
 `;
 /** @internal */
 export function addClassifierFlash(frag) {