@itwin/core-frontend 4.1.0-dev.35 → 4.1.0-dev.40

package/lib/esm/render/webgl/glsl/Surface.js

@@ -29,129 +29,129 @@ import { addModelViewMatrix, addNormalMatrix, addProjectionMatrix } from "./Vert
 import { wantMaterials } from "../SurfaceGeometry";
 import { addWiremesh } from "./Wiremesh";
 import { Npc } from "@itwin/core-common";
-const constantLodTextureLookup = `
-vec4 constantLodTextureLookup(sampler2D textureSampler) {
-  float logDepth = log2(v_uvCustom.z);
-  float f = fract(logDepth);
-  float p = floor(logDepth);
-  // When p changes, both tc1 and tc2 jumped by a power of 2 at that transition (and f goes from ~1 to 0).
-  // This caused a line to show up with incorrect tex coords, we believe due to a problem with the derivative
-  // that is auto calculated on the tex coords for the mip-map.  The below approach attempts to "smooth"
-  // the transition of the coord in use at the transition by only changing the coord that is not in use
-  // (but by 2 powers of 2) and switching the mix selector to account for it.  It does this by using whether
-  // p is odd or even to select which way it is going, so it alternates at the boundaries.  This fixes the
-  // line problem.
-  float p1, p2;
-  if (0u == (uint(p) & 1u)) { // p is even
-    p1 = p;
-    p2 = p + 1.0;
-  } else { // p is odd
-    p1 = p + 1.0;
-    p2 = p;
-    f = 1.0 - f;
-  }
-
-  vec2 tc1 = v_uvCustom.xy / clamp(pow(2.0, p1), float(u_constantLodFParams.x), float(u_constantLodFParams.y)) * u_constantLodFParams.z;
-  vec2 tc2 = v_uvCustom.xy / clamp(pow(2.0, p2), float(u_constantLodFParams.x), float(u_constantLodFParams.y)) * u_constantLodFParams.z;
-  return mix(TEXTURE(textureSampler, tc1), TEXTURE(textureSampler, tc2), f);
-}
+const constantLodTextureLookup = `
+vec4 constantLodTextureLookup(sampler2D textureSampler) {
+  float logDepth = log2(v_uvCustom.z);
+  float f = fract(logDepth);
+  float p = floor(logDepth);
+  // When p changes, both tc1 and tc2 jumped by a power of 2 at that transition (and f goes from ~1 to 0).
+  // This caused a line to show up with incorrect tex coords, we believe due to a problem with the derivative
+  // that is auto calculated on the tex coords for the mip-map.  The below approach attempts to "smooth"
+  // the transition of the coord in use at the transition by only changing the coord that is not in use
+  // (but by 2 powers of 2) and switching the mix selector to account for it.  It does this by using whether
+  // p is odd or even to select which way it is going, so it alternates at the boundaries.  This fixes the
+  // line problem.
+  float p1, p2;
+  if (0u == (uint(p) & 1u)) { // p is even
+    p1 = p;
+    p2 = p + 1.0;
+  } else { // p is odd
+    p1 = p + 1.0;
+    p2 = p;
+    f = 1.0 - f;
+  }
+
+  vec2 tc1 = v_uvCustom.xy / clamp(pow(2.0, p1), float(u_constantLodFParams.x), float(u_constantLodFParams.y)) * u_constantLodFParams.z;
+  vec2 tc2 = v_uvCustom.xy / clamp(pow(2.0, p2), float(u_constantLodFParams.x), float(u_constantLodFParams.y)) * u_constantLodFParams.z;
+  return mix(TEXTURE(textureSampler, tc1), TEXTURE(textureSampler, tc2), f);
+}
 `;
 // NB: Textures do not contain pre-multiplied alpha.
-const sampleSurfaceTexture = `
-vec4 sampleSurfaceTexture() {
-  vec4 clr;
-  if (!isSurfaceBitSet(kSurfaceBit_HasTexture))
-    clr = vec4(1.0, 1.0, 1.0, 1.0);
-  else if (u_surfaceFlags[kSurfaceBitIndex_UseConstantLodTextureMapping])
-    clr = constantLodTextureLookup(s_texture);
-  else
-    clr =  TEXTURE(s_texture, v_texCoord);
-  return clr;
-}
+const sampleSurfaceTexture = `
+vec4 sampleSurfaceTexture() {
+  vec4 clr;
+  if (!isSurfaceBitSet(kSurfaceBit_HasTexture))
+    clr = vec4(1.0, 1.0, 1.0, 1.0);
+  else if (u_surfaceFlags[kSurfaceBitIndex_UseConstantLodTextureMapping])
+    clr = constantLodTextureLookup(s_texture);
+  else
+    clr =  TEXTURE(s_texture, v_texCoord);
+  return clr;
+}
 `;
-const applyMaterialColor = `
-  float useMatColor = float(use_material);
-  vec3 rgb = mix(baseColor.rgb, mat_rgb.rgb, useMatColor * mat_rgb.a);
-  float a = mix(baseColor.a, mat_alpha.x, useMatColor * mat_alpha.y);
-  return vec4(rgb, a);
+const applyMaterialColor = `
+  float useMatColor = float(use_material);
+  vec3 rgb = mix(baseColor.rgb, mat_rgb.rgb, useMatColor * mat_rgb.a);
+  float a = mix(baseColor.a, mat_alpha.x, useMatColor * mat_alpha.y);
+  return vec4(rgb, a);
 `;
 // if this is a raster glyph, the sampled color has already been modified - do not modify further.
 // Mix diffuse color with texel based on texture weight.
 // Replace with diffuse RGB if RGB overridden.
 // Replace with diffuse alpha if alpha overridden.
 // Multiply texel alpha with diffuse alpha if specified.
-const applyTextureWeight = `
-  bool applyTexture = !u_applyGlyphTex && isSurfaceBitSet(kSurfaceBit_HasTexture);
-  float textureWeight = applyTexture ? mat_texture_weight : 0.0;
-  vec3 rgb = mix(baseColor.rgb, g_surfaceTexel.rgb, textureWeight);
-  rgb = chooseVec3WithBitFlag(rgb, baseColor.rgb, surfaceFlags, kSurfaceBit_OverrideRgb);
-
-  float a = applyTexture ? baseColor.a * g_surfaceTexel.a : baseColor.a;
-
-  return vec4(rgb, a);
+const applyTextureWeight = `
+  bool applyTexture = !u_applyGlyphTex && isSurfaceBitSet(kSurfaceBit_HasTexture);
+  float textureWeight = applyTexture ? mat_texture_weight : 0.0;
+  vec3 rgb = mix(baseColor.rgb, g_surfaceTexel.rgb, textureWeight);
+  rgb = chooseVec3WithBitFlag(rgb, baseColor.rgb, surfaceFlags, kSurfaceBit_OverrideRgb);
+
+  float a = applyTexture ? baseColor.a * g_surfaceTexel.a : baseColor.a;
+
+  return vec4(rgb, a);
 `;
-const decodeFragMaterialParams = `
-void decodeMaterialParams(vec4 params) {
-  mat_weights = unpackAndNormalize2Bytes(params.x);
-
-  vec2 texAndSpecR = unpackAndNormalize2Bytes(params.y);
-  mat_texture_weight = texAndSpecR.x;
-
-  vec2 specGB = unpackAndNormalize2Bytes(params.z);
-  mat_specular = vec4(texAndSpecR.y, specGB, params.w);
-}
+const decodeFragMaterialParams = `
+void decodeMaterialParams(vec4 params) {
+  mat_weights = unpackAndNormalize2Bytes(params.x);
+
+  vec2 texAndSpecR = unpackAndNormalize2Bytes(params.y);
+  mat_texture_weight = texAndSpecR.x;
+
+  vec2 specGB = unpackAndNormalize2Bytes(params.z);
+  mat_specular = vec4(texAndSpecR.y, specGB, params.w);
+}
 `;
-const decodeMaterialColor = `
-void decodeMaterialColor(vec4 rgba) {
-  mat_rgb = vec4(rgba.rgb, float(rgba.r >= 0.0));
-  mat_alpha = vec2(rgba.a, float(rgba.a >= 0.0));
-}
+const decodeMaterialColor = `
+void decodeMaterialColor(vec4 rgba) {
+  mat_rgb = vec4(rgba.rgb, float(rgba.r >= 0.0));
+  mat_alpha = vec2(rgba.a, float(rgba.a >= 0.0));
+}
 `;
 // defaults: (0x6699, 0xffff, 0xffff, 13.5)
-const computeMaterialParams = `
-  const vec4 defaults = vec4(26265.0, 65535.0, 65535.0, 13.5);
-  return use_material ? g_materialParams : defaults;
+const computeMaterialParams = `
+  const vec4 defaults = vec4(26265.0, 65535.0, 65535.0, 13.5);
+  return use_material ? g_materialParams : defaults;
 `;
 // The 8-bit material index is stored with the 24-bit feature index, in the high byte.
-const readMaterialAtlas = `
-void readMaterialAtlas() {
-  float materialAtlasStart = u_vertParams.z * u_vertParams.w + u_numColors;
-  float materialIndex = g_featureAndMaterialIndex.w * 4.0 + materialAtlasStart;
-
-  vec2 tc = computeLUTCoords(materialIndex, u_vertParams.xy, g_vert_center, 1.0);
-  vec4 rgba = TEXTURE(u_vertLUT, tc);
-
-  tc = computeLUTCoords(materialIndex + 1.0, u_vertParams.xy, g_vert_center, 1.0);
-  vec4 weightsAndFlags = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5);
-
-  tc = computeLUTCoords(materialIndex + 2.0, u_vertParams.xy, g_vert_center, 1.0);
-  vec3 specularRgb = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5).rgb;
-
-  tc = computeLUTCoords(materialIndex + 3.0, u_vertParams.xy, g_vert_center, 1.0);
-  vec4 packedSpecularExponent = TEXTURE(u_vertLUT, tc);
-
-  float flags = weightsAndFlags.w;
-  mat_rgb = vec4(rgba.rgb, float(flags == 1.0 || flags == 3.0));
-  mat_alpha = vec2(rgba.a, float(flags == 2.0 || flags == 3.0));
-
-  float specularExponent = unpackFloat(packedSpecularExponent);
-  g_materialParams.x = weightsAndFlags.y + weightsAndFlags.z * 256.0;
-  g_materialParams.y = 255.0 + specularRgb.r * 256.0;
-  g_materialParams.z = specularRgb.g + specularRgb.b * 256.0;
-  g_materialParams.w = specularExponent;
-}
+const readMaterialAtlas = `
+void readMaterialAtlas() {
+  float materialAtlasStart = u_vertParams.z * u_vertParams.w + u_numColors;
+  float materialIndex = g_featureAndMaterialIndex.w * 4.0 + materialAtlasStart;
+
+  vec2 tc = computeLUTCoords(materialIndex, u_vertParams.xy, g_vert_center, 1.0);
+  vec4 rgba = TEXTURE(u_vertLUT, tc);
+
+  tc = computeLUTCoords(materialIndex + 1.0, u_vertParams.xy, g_vert_center, 1.0);
+  vec4 weightsAndFlags = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5);
+
+  tc = computeLUTCoords(materialIndex + 2.0, u_vertParams.xy, g_vert_center, 1.0);
+  vec3 specularRgb = floor(TEXTURE(u_vertLUT, tc) * 255.0 + 0.5).rgb;
+
+  tc = computeLUTCoords(materialIndex + 3.0, u_vertParams.xy, g_vert_center, 1.0);
+  vec4 packedSpecularExponent = TEXTURE(u_vertLUT, tc);
+
+  float flags = weightsAndFlags.w;
+  mat_rgb = vec4(rgba.rgb, float(flags == 1.0 || flags == 3.0));
+  mat_alpha = vec2(rgba.a, float(flags == 2.0 || flags == 3.0));
+
+  float specularExponent = unpackFloat(packedSpecularExponent);
+  g_materialParams.x = weightsAndFlags.y + weightsAndFlags.z * 256.0;
+  g_materialParams.y = 255.0 + specularRgb.r * 256.0;
+  g_materialParams.z = specularRgb.g + specularRgb.b * 256.0;
+  g_materialParams.w = specularExponent;
+}
 `;
-const computeMaterial = `
-  if (u_surfaceFlags[kSurfaceBitIndex_HasMaterialAtlas]) {
-    readMaterialAtlas();
-  } else {
-    decodeMaterialColor(u_materialColor);
-    g_materialParams = u_materialParams;
-  }
+const computeMaterial = `
+  if (u_surfaceFlags[kSurfaceBitIndex_HasMaterialAtlas]) {
+    readMaterialAtlas();
+  } else {
+    decodeMaterialColor(u_materialColor);
+    g_materialParams = u_materialParams;
+  }
 `;
-const computeMaterialInstanced = `
-  decodeMaterialColor(u_materialColor);
-  g_materialParams = u_materialParams;
+const computeMaterialInstanced = `
+  decodeMaterialColor(u_materialColor);
+  g_materialParams = u_materialParams;
 `;
 function addMaterial(builder, instanced) {
     const frag = builder.frag;
@@ -202,26 +202,26 @@ function addMaterial(builder, instanced) {
     vert.set(6 /* VertexShaderComponent.ApplyMaterialColor */, applyMaterialColor);
     builder.addFunctionComputedVarying("v_materialParams", 5 /* VariableType.Vec4 */, "computeMaterialParams", computeMaterialParams);
 }
-const computePositionPrelude = `
-  vec4 pos = MAT_MV * rawPos;
+const computePositionPrelude = `
+  vec4 pos = MAT_MV * rawPos;
 `;
 // We used to use gl.polygonOffset() for blanking regions, but that doesn't work with logarithmic depth buffer which overwrites the
 // computed Z. Instead we must manually offset in vertex shader. We do this even if log depth is not enabled/supported.
 // NOTE: If log depth is *not* supported, then the hilite surface vertex shaders previously would still include this logic, but the
 // fragment shaders would not use v_eyeSpace. Some Ubuntu 20.04 graphics drivers cleverly and correctly optimized out the varying and the uniform,
 // causing an exception when gl.getProgramLocation() failed. So, omit this bit in that case.
-const adjustEyeSpace = `
-  v_eyeSpace = pos.xyz;
-  const float blankingRegionOffset = 2.0 / 65536.0;
-  if (kRenderOrder_BlankingRegion == u_renderOrder)
-    v_eyeSpace.z -= blankingRegionOffset * (u_frustum.y - u_frustum.x);
+const adjustEyeSpace = `
+  v_eyeSpace = pos.xyz;
+  const float blankingRegionOffset = 2.0 / 65536.0;
+  if (kRenderOrder_BlankingRegion == u_renderOrder)
+    v_eyeSpace.z -= blankingRegionOffset * (u_frustum.y - u_frustum.x);
 `;
-const computeConstantLodUvCustom = `
-  vec2 worldpos = (u_modelToWorld * vec4(rawPos.xyz, 0.0)).xy;
-  v_uvCustom = vec3((u_constantLodVParams.xy + worldpos) * vec2(1.0, -1.0), kFrustumType_Perspective == u_frustum.z ? -v_eyeSpace.z : u_constantLodVParams.z);
+const computeConstantLodUvCustom = `
+  vec2 worldpos = (u_modelToWorld * vec4(rawPos.xyz, 0.0)).xy;
+  v_uvCustom = vec3((u_constantLodVParams.xy + worldpos) * vec2(1.0, -1.0), kFrustumType_Perspective == u_frustum.z ? -v_eyeSpace.z : u_constantLodVParams.z);
 `;
-const computePositionPostlude = `
-  return u_proj * pos;
+const computePositionPostlude = `
+  return u_proj * pos;
 `;
 function createCommon(isInstanced, animated, shadowable, isHiliter, positionType) {
     const instanced = 1 /* IsInstanced.Yes */ === isInstanced;
@@ -263,8 +263,8 @@ export function createSurfaceHiliter(instanced, classified, posType) {
     }
     return builder;
 }
-const isSurfaceBitSet = `
-bool isSurfaceBitSet(uint flag) { return 0u != (surfaceFlags & flag); }
+const isSurfaceBitSet = `
+bool isSurfaceBitSet(uint flag) { return 0u != (surfaceFlags & flag); }
 `;
 /** @internal */
 function addSurfaceFlagsLookup(builder) {
@@ -297,140 +297,140 @@ function addSurfaceFlagsLookup(builder) {
     builder.addFunction(isSurfaceBitSet);
     builder.addGlobal("surfaceFlags", 10 /* VariableType.Uint */);
 }
-const initSurfaceFlags = `
-  surfaceFlags = u_surfaceFlags[kSurfaceBitIndex_HasTexture] ? kSurfaceMask_HasTexture : 0u;
-  surfaceFlags += u_surfaceFlags[kSurfaceBitIndex_IgnoreMaterial] ? kSurfaceMask_IgnoreMaterial : 0u;
-  surfaceFlags += u_surfaceFlags[kSurfaceBitIndex_OverrideRgb] ? kSurfaceMask_OverrideRgb : 0u;
-  surfaceFlags += u_surfaceFlags[kSurfaceBitIndex_HasNormalMap] ? kSurfaceMask_HasNormalMap : 0u;
+const initSurfaceFlags = `
+  surfaceFlags = u_surfaceFlags[kSurfaceBitIndex_HasTexture] ? kSurfaceMask_HasTexture : 0u;
+  surfaceFlags += u_surfaceFlags[kSurfaceBitIndex_IgnoreMaterial] ? kSurfaceMask_IgnoreMaterial : 0u;
+  surfaceFlags += u_surfaceFlags[kSurfaceBitIndex_OverrideRgb] ? kSurfaceMask_OverrideRgb : 0u;
+  surfaceFlags += u_surfaceFlags[kSurfaceBitIndex_HasNormalMap] ? kSurfaceMask_HasNormalMap : 0u;
 `;
-const computeBaseSurfaceFlags = `
-  if (feature_ignore_material) {
-    if (u_surfaceFlags[kSurfaceBitIndex_HasTexture])
-      surfaceFlags -= kSurfaceMask_HasTexture;
-    if (u_surfaceFlags[kSurfaceBitIndex_HasNormalMap])
-      surfaceFlags -= kSurfaceMask_HasNormalMap;
-
-    surfaceFlags += kSurfaceMask_IgnoreMaterial;
-  }
+const computeBaseSurfaceFlags = `
+  if (feature_ignore_material) {
+    if (u_surfaceFlags[kSurfaceBitIndex_HasTexture])
+      surfaceFlags -= kSurfaceMask_HasTexture;
+    if (u_surfaceFlags[kSurfaceBitIndex_HasNormalMap])
+      surfaceFlags -= kSurfaceMask_HasNormalMap;
+
+    surfaceFlags += kSurfaceMask_IgnoreMaterial;
+  }
 `;
 // Textured surfaces (including raster glyphs) always *multiply* the sampled alpha by the alpha override.
-const computeColorSurfaceFlags = `
-  if (feature_rgb.r >= 0.0)
-    surfaceFlags += kSurfaceMask_OverrideRgb;
+const computeColorSurfaceFlags = `
+  if (feature_rgb.r >= 0.0)
+    surfaceFlags += kSurfaceMask_OverrideRgb;
 `;
 const returnSurfaceFlags = "  return float(surfaceFlags);\n";
 const computeSurfaceFlags = computeBaseSurfaceFlags;
 const computeSurfaceFlagsWithColor = computeBaseSurfaceFlags + computeColorSurfaceFlags;
 /** @internal */
-export const octDecodeNormal = `
-vec3 octDecodeNormal(vec2 e) {
-  e = e / 255.0 * 2.0 - 1.0;
-  vec3 n = vec3(e.x, e.y, 1.0 - abs(e.x) - abs(e.y));
-  if (n.z < 0.0) {
-    vec2 signNotZero = vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);
-    n.xy = (1.0 - abs(n.yx)) * signNotZero;
-  }
-
-  return normalize(n);
-}
+export const octDecodeNormal = `
+vec3 octDecodeNormal(vec2 e) {
+  e = e / 255.0 * 2.0 - 1.0;
+  vec3 n = vec3(e.x, e.y, 1.0 - abs(e.x) - abs(e.y));
+  if (n.z < 0.0) {
+    vec2 signNotZero = vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);
+    n.xy = (1.0 - abs(n.yx)) * signNotZero;
+  }
+
+  return normalize(n);
+}
 `;
 function getComputeNormal(quantized) {
     const a = quantized ? "g_vertLutData3.xy" : "g_vertLutData4.zw";
     const b = quantized ? "g_vertLutData1.zw" : "g_vertLutData5.xy";
-    return `
-  if (!u_surfaceFlags[kSurfaceBitIndex_HasNormals])
-    return vec3(0.0);
-
-  vec2 normal = (u_surfaceFlags[kSurfaceBitIndex_HasColorAndNormal]) ? ${a} : ${b};
-  return normalize(MAT_NORM * octDecodeNormal(normal));
+    return `
+  if (!u_surfaceFlags[kSurfaceBitIndex_HasNormals])
+    return vec3(0.0);
+
+  vec2 normal = (u_surfaceFlags[kSurfaceBitIndex_HasColorAndNormal]) ? ${a} : ${b};
+  return normalize(MAT_NORM * octDecodeNormal(normal));
 `;
 }
-const finalizeNormalPrelude = `
-  vec3 normal = normalize(v_n) * (2.0 * float(gl_FrontFacing) - 1.0);
+const finalizeNormalPrelude = `
+  vec3 normal = normalize(v_n) * (2.0 * float(gl_FrontFacing) - 1.0);
 `;
-const finalizeNormalNormalMap = `
-  if (isSurfaceBitSet(kSurfaceBit_HasNormalMap)) {
-    // Modify the normal with the normal map texture.
-    // First calculate the tangent.
-    vec3 dp1 = dFdx(v_eyeSpace);
-    vec3 dp2 = dFdy(v_eyeSpace);
-    vec2 duv1 = dFdx(v_texCoord);
-    vec2 duv2 = dFdy(v_texCoord);
-    vec3 tangent = normalize(duv2.y * dp1 - duv1.y * dp2);
-    tangent = normalize (tangent - normal * dot (normal, tangent));  // re-orthogonalize with normal
-    bool flip = (duv1.x * duv2.y - duv2.x * duv1.y) < 0.0;
-    if (flip)
-      tangent = -tangent;
-    vec3 biTangent = cross (normal, tangent);
-    if (flip)
-      biTangent = -biTangent;
-    vec3 normM;
-    if (u_surfaceFlags[kSurfaceBitIndex_UseConstantLodNormalMapMapping])
-      normM = constantLodTextureLookup(s_normalMap).xyz;
-    else
-      normM = TEXTURE(s_normalMap, v_texCoord).xyz;
-    if (length (normM) > 0.0001) { // check for empty normal texture
-      normM = (normM - 0.5) * 2.0;
-      normM = normalize (normM);
-      normM.x *= abs(u_normalMapScale);
-      normM.y *= u_normalMapScale;
-      normM = normalize (normM);
-      normal = normalize (normM.x * tangent + normM.y * biTangent + normM.z * normal);
-    }
-  }
+const finalizeNormalNormalMap = `
+  if (isSurfaceBitSet(kSurfaceBit_HasNormalMap)) {
+    // Modify the normal with the normal map texture.
+    // First calculate the tangent.
+    vec3 dp1 = dFdx(v_eyeSpace);
+    vec3 dp2 = dFdy(v_eyeSpace);
+    vec2 duv1 = dFdx(v_texCoord);
+    vec2 duv2 = dFdy(v_texCoord);
+    vec3 tangent = normalize(duv2.y * dp1 - duv1.y * dp2);
+    tangent = normalize (tangent - normal * dot (normal, tangent));  // re-orthogonalize with normal
+    bool flip = (duv1.x * duv2.y - duv2.x * duv1.y) < 0.0;
+    if (flip)
+      tangent = -tangent;
+    vec3 biTangent = cross (normal, tangent);
+    if (flip)
+      biTangent = -biTangent;
+    vec3 normM;
+    if (u_surfaceFlags[kSurfaceBitIndex_UseConstantLodNormalMapMapping])
+      normM = constantLodTextureLookup(s_normalMap).xyz;
+    else
+      normM = TEXTURE(s_normalMap, v_texCoord).xyz;
+    if (length (normM) > 0.0001) { // check for empty normal texture
+      normM = (normM - 0.5) * 2.0;
+      normM = normalize (normM);
+      normM.x *= abs(u_normalMapScale);
+      normM.y *= u_normalMapScale;
+      normM = normalize (normM);
+      normal = normalize (normM.x * tangent + normM.y * biTangent + normM.z * normal);
+    }
+  }
 `;
-const finalizeNormalPostlude = `
-  return normal;
+const finalizeNormalPostlude = `
+  return normal;
 `;
 function getComputeAnimatedNormal(quantized) {
-    return `
-  if (u_animNormalParams.x >= 0.0)
-    return normalize(MAT_NORM * computeAnimationNormal(u_animNormalParams.x, u_animNormalParams.y, u_animNormalParams.z));
-
+    return `
+  if (u_animNormalParams.x >= 0.0)
+    return normalize(MAT_NORM * computeAnimationNormal(u_animNormalParams.x, u_animNormalParams.y, u_animNormalParams.z));
+
   ${getComputeNormal(quantized)}`;
 }
-const applyBackgroundColor = `
-  return u_surfaceFlags[kSurfaceBitIndex_BackgroundFill] ? vec4(u_bgColor.rgb, baseColor.a) : baseColor;
+const applyBackgroundColor = `
+  return u_surfaceFlags[kSurfaceBitIndex_BackgroundFill] ? vec4(u_bgColor.rgb, baseColor.a) : baseColor;
 `;
 function getComputeTexCoord(quantized) {
     const vertData = quantized ? "g_vertLutData3" : "g_vertLutData4";
-    return `
-  vec4 rgba = ${vertData};
-  vec2 qcoords = vec2(decodeUInt16(rgba.xy), decodeUInt16(rgba.zw));
-  return chooseVec2With2BitFlags(vec2(0.0), unquantize2d(qcoords, u_qTexCoordParams), surfaceFlags, kSurfaceBit_HasTexture, kSurfaceBit_HasNormalMap);
+    return `
+  vec4 rgba = ${vertData};
+  vec2 qcoords = vec2(decodeUInt16(rgba.xy), decodeUInt16(rgba.zw));
+  return chooseVec2With2BitFlags(vec2(0.0), unquantize2d(qcoords, u_qTexCoordParams), surfaceFlags, kSurfaceBit_HasTexture, kSurfaceBit_HasNormalMap);
 `;
 }
 function getComputeAnimatedTexCoord(quantized) {
-    return `
-  if (u_animScalarQParams.x >= 0.0)
-    return computeAnimationParam(u_animScalarParams.x, u_animScalarParams.y, u_animScalarParams.z, u_animScalarQParams.x, u_animScalarQParams.y);
-
-  ${getComputeTexCoord(quantized)}
+    return `
+  if (u_animScalarQParams.x >= 0.0)
+    return computeAnimationParam(u_animScalarParams.x, u_animScalarParams.y, u_animScalarParams.z, u_animScalarQParams.x, u_animScalarQParams.y);
+
+  ${getComputeTexCoord(quantized)}
 `;
 }
-const getSurfaceColor = `
-vec4 getSurfaceColor() { return v_color; }
+const getSurfaceColor = `
+vec4 getSurfaceColor() { return v_color; }
 `;
 // If we have texture weight < 1.0 we must compute the element/material color first then mix with texture color
 // in ApplyMaterialOverrides(). Do the sample once, here, and store in a global variable for possible later use.
 // If a glyph texture, must mix getSurfaceColor() with texture color so texture color alpha is applied 100% and
 // surface color rgb is scaled by texture color rgb (latter is full white originally but stretched via mipmapping).
-const computeBaseColor = `
-  g_surfaceTexel = sampleSurfaceTexture();
-  vec4 surfaceColor = getSurfaceColor();
-
-  if (!u_applyGlyphTex)
-    return surfaceColor;
-
-  // Compute color for raster glyph.
-  const vec3 white = vec3(1.0);
-  const vec3 epsilon = vec3(0.0001);
-  const vec3 almostWhite = white - epsilon;
-
-  // set to black if almost white and reverse white-on-white is on
-  bvec3 isAlmostWhite = greaterThan(surfaceColor.rgb, almostWhite);
-  surfaceColor.rgb = (u_reverseWhiteOnWhite && isAlmostWhite.r && isAlmostWhite.g && isAlmostWhite.b ? vec3(0.0, 0.0, 0.0) : surfaceColor.rgb);
-  return vec4(surfaceColor.rgb * g_surfaceTexel.rgb, g_surfaceTexel.a);
+const computeBaseColor = `
+  g_surfaceTexel = sampleSurfaceTexture();
+  vec4 surfaceColor = getSurfaceColor();
+
+  if (!u_applyGlyphTex)
+    return surfaceColor;
+
+  // Compute color for raster glyph.
+  const vec3 white = vec3(1.0);
+  const vec3 epsilon = vec3(0.0001);
+  const vec3 almostWhite = white - epsilon;
+
+  // set to black if almost white and reverse white-on-white is on
+  bvec3 isAlmostWhite = greaterThan(surfaceColor.rgb, almostWhite);
+  surfaceColor.rgb = (u_reverseWhiteOnWhite && isAlmostWhite.r && isAlmostWhite.g && isAlmostWhite.b ? vec3(0.0, 0.0, 0.0) : surfaceColor.rgb);
+  return vec4(surfaceColor.rgb * g_surfaceTexel.rgb, g_surfaceTexel.a);
 `;
 const surfaceFlagArray = new Int32Array(12 /* SurfaceBitIndex.Count */);
 /** @internal */
@@ -542,25 +542,25 @@ export function addTexture(builder, animated, isThematic, isPointCloud, isHilite
         });
     }
 }
-export const discardClassifiedByAlpha = `
-  if (u_no_classifier_discard)
-    return false;
-
-  bool hasAlpha = alpha <= s_maxAlpha;
-  bool isOpaquePass = (kRenderPass_OpaqueLinear <= u_renderPass && kRenderPass_OpaqueGeneral >= u_renderPass);
-  bool isTranslucentPass = kRenderPass_Translucent == u_renderPass;
-  return (isOpaquePass && hasAlpha) || (isTranslucentPass && !hasAlpha);
+export const discardClassifiedByAlpha = `
+  if (u_no_classifier_discard)
+    return false;
+
+  bool hasAlpha = alpha <= s_maxAlpha;
+  bool isOpaquePass = (kRenderPass_OpaqueLinear <= u_renderPass && kRenderPass_OpaqueGeneral >= u_renderPass);
+  bool isTranslucentPass = kRenderPass_Translucent == u_renderPass;
+  return (isOpaquePass && hasAlpha) || (isTranslucentPass && !hasAlpha);
 `;
-const discardByTextureAlpha = `
-  if (isSurfaceBitSet(kSurfaceBit_HasTexture)) {
-    float cutoff = abs(u_alphaCutoff);
-    if (kRenderPass_Translucent == u_renderPass)
-      return u_alphaCutoff > 0.0 && alpha >= cutoff;
-    else
-      return alpha < cutoff;
-  }
-
-  return false;
+const discardByTextureAlpha = `
+  if (isSurfaceBitSet(kSurfaceBit_HasTexture)) {
+    float cutoff = abs(u_alphaCutoff);
+    if (kRenderPass_Translucent == u_renderPass)
+      return u_alphaCutoff > 0.0 && alpha >= cutoff;
+    else
+      return alpha < cutoff;
+  }
+
+  return false;
 `;
 function addTransparencyDiscard(frag) {
     addRenderPass(frag);