@itwin/core-frontend 4.10.0-dev.2 → 4.10.0-dev.22

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

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module WebGL
+ */
+import { ContourDisplay } from "@itwin/core-common";
+import { TextureUnit } from "../RenderFlags";
+import { addFeatureIndex } from "./FeatureSymbology";
+import { addInstancedRtcMatrix } from "./Vertex";
+const computeContourNdx = `
+  if (u_contourLUTWidth == 0u)
+      return 15.0;
+  uint lutIndex = uint(getFeatureIndex());
+  bool odd = bool(lutIndex & 1u);
+  lutIndex /= 2u;
+  uint byteSel = lutIndex & 0x3u;
+  lutIndex /= 4u;
+  ivec2 coords = ivec2(lutIndex % u_contourLUTWidth, lutIndex / u_contourLUTWidth);
+  uvec4 contourNdx4 = uvec4(texelFetch(u_contourLUT, coords, 0) * 255.0 + 0.5);
+  uvec2 contourNdx2 = bool(byteSel & 2u) ? contourNdx4.ba : contourNdx4.rg;
+  uint contourNdx = bool(byteSel & 1u) ? contourNdx2.g : contourNdx2.r;
+  return float(odd ? contourNdx >> 4u : contourNdx & 0xFu);
+`;
+const unpack2BytesVec4 = `
+vec4 unpack2BytesVec4(vec4 f, bool upper) {
+  f = floor(f + 0.5);
+  vec4 outUpper = floor(f / 256.0);
+  vec4 outLower = floor(f - outUpper * 256.0);
+  return upper ? outUpper : outLower;
+}
+`;
+const unpackAndNormalize2BytesVec4 = `
+vec4 unpackAndNormalize2BytesVec4(vec4 f, bool upper) {
+  return unpack2BytesVec4(f, upper) / 255.0;
+}
+`;
+const applyContours = `
+  int contourNdx = int(v_contourNdx + 0.5);
+  if (contourNdx > 14) // 15 => no contours
+    return baseColor;
+
+  const int maxDefs = ${ContourDisplay.maxContourGroups}; // max number of contour definitions allowed, have to change index arrays if this changes
+  int contourNdxC = clamp(contourNdx, 0, maxDefs - 1);
+
+  bool even = (contourNdxC & 1) == 0;
+  vec4 rgbfp = u_contourDefs[even ? contourNdxC * 3 / 2 : (contourNdxC - 1) * 3 / 2 + 2];
+  vec4 intervalsPair = u_contourDefs[(contourNdxC / 2) * 3 + 1];
+  // intervals.r => minor interval distance, intervals.g => major index count
+  vec2 intervals = even ? intervalsPair.rg : intervalsPair.ba;
+
+  float coord = v_height / intervals.r;
+  // determine if this is in the vicinity of a major contour line (1/2 an interval either way, which is one limit of drawing width)
+  bool maj = (fract((abs(coord) + 0.5) / intervals.g) < (1.0 / intervals.g));
+  vec4 rgbf = unpackAndNormalize2BytesVec4(rgbfp, maj);
+  // rgbf.a => (4-bit linecode / 4-bit weight) maj/min, where the 4-bit weight is a 3-bit weight value with one fraction bit and a 1.5 offset.
+  //    This gives a weight range of 1.5 to 9 in 0.5 increments.
+  //    NB: the showGeometry bit flag is stuck in at bit 16 of this, so the major line code has an extra bit in it that needs to be masked out
+  int lineCodeWt = int((rgbf.a * 255.0) + 0.5);
+  // first * 0.5 is for fractional part of width, then have to add 1.0 for offset, then another 1.0 for actual width bias
+  float lineRadius = (float(lineCodeWt & 0xf) * 0.5 + 2.0) * 0.5;
+
+  // abs(fract(coord - 0.5) - 0.5) will produce 0.0 at the contour line, and 0.5 at the mid-point between contour lines
+  // fwidth(coord) is sum of absolute diffs in coord in adjacent pixels
+  float line = abs(fract(coord - 0.5) - 0.5) / fwidth(coord);
+  // If line is 0 (like at contour line), contourAlpha = lineRadius, so will use draw in contour color
+	// If line >= lineRadius, contourAlpha = 0, so won't show contour
+  float contourAlpha = lineRadius - min(line, lineRadius);
+
+  // figure out which direction line is going, to know which screen pattern offset to use
+  float dx = dFdx(contourAlpha);
+  float dy = dFdy(contourAlpha);
+
+  const float patLength = 32.0;
+  uint patterns[10] = uint[](0xffffffffu, 0x80808080u, 0xf8f8f8f8u, 0xffe0ffe0u, 0xfe10fe10u, 0xe0e0e0e0u, 0xf888f888u, 0xff18ff18u, 0xccccccccu, 0x00000001u);
+
+  float offset = trunc((abs(dx) > abs(dy)) ? gl_FragCoord.y : gl_FragCoord.x);
+  offset = mod(offset, patLength);
+  uint msk = 1u << uint(offset);
+  contourAlpha *= (patterns[(lineCodeWt / 16) & 0xf] & msk) > 0u ? 1.0 : 0.0;
+  contourAlpha = min(contourAlpha, 1.0);
+  if (rgbfp.a / 65536.0 < 0.5) { // showGeometry == 0
+    if (contourAlpha < 0.5)
+      discard;
+    return vec4(rgbf.rgb, 1.0);
+  }
+  // set contour opaque even if base color is transparent
+  float alpha = contourAlpha >= 0.5 ? 1.0 : baseColor.a;
+  return vec4(mix(baseColor.rgb, rgbf.rgb, contourAlpha), alpha);
+`;
+/** @internal */
+export function addApplyContours(builder) {
+    const modelPos = builder.vert.usesInstancedGeometry ? "(g_instancedRtcMatrix * rawPosition)" : "rawPosition";
+    const computeWorldHeight = `
+float computeWorldHeight(vec4 rawPosition) {
+  float height = (u_modelToWorldC * ${modelPos}).z;
+  // TODO: apply ECEF correction to height
+  return height;
+}
+`;
+    addFeatureIndex(builder.vert);
+    builder.addFunctionComputedVarying("v_contourNdx", 2 /* VariableType.Float */, "computeContourNdx", computeContourNdx);
+    builder.addFunctionComputedVaryingWithArgs("v_height", 2 /* VariableType.Float */, "computeWorldHeight(rawPosition)", computeWorldHeight);
+    if (builder.vert.usesInstancedGeometry)
+        addInstancedRtcMatrix(builder.vert);
+    builder.vert.addUniform("u_contourLUT", 8 /* VariableType.Sampler2D */, (prog) => {
+        prog.addGraphicUniform("u_contourLUT", (uniform, params) => {
+            // set this uniform here so that it won't cause problems (e.g.: loopback) if it does not end up being set by bindContourLUT call
+            uniform.setUniform1i(TextureUnit.Contours - TextureUnit.Zero);
+            params.target.uniforms.batch.bindContourLUT(uniform);
+        });
+    });
+    builder.vert.addUniform("u_contourLUTWidth", 10 /* VariableType.Uint */, (prog) => {
+        prog.addGraphicUniform("u_contourLUTWidth", (uniform, params) => {
+            params.target.uniforms.batch.bindContourLUTWidth(uniform);
+        });
+    });
+    builder.vert.addUniform("u_modelToWorldC", 7 /* VariableType.Mat4 */, (prog) => {
+        prog.addGraphicUniform("u_modelToWorldC", (uniform, params) => {
+            params.target.uniforms.branch.bindModelToWorldTransform(uniform, params.geometry, false);
+        });
+    });
+    const contourDefsSize = 8;
+    builder.frag.addUniformArray("u_contourDefs", 5 /* VariableType.Vec4 */, contourDefsSize, (prog) => {
+        prog.addGraphicUniform("u_contourDefs", (uniform, params) => {
+            params.target.uniforms.contours.bindcontourDefs(uniform);
+        });
+    });
+    builder.frag.addFunction(unpack2BytesVec4);
+    builder.frag.addFunction(unpackAndNormalize2BytesVec4);
+    builder.frag.set(11 /* FragmentShaderComponent.ApplyContours */, applyContours);
+}
+//# sourceMappingURL=Contours.js.map

package/lib/esm/render/webgl/glsl/Contours.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contours.js","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/Contours.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module WebGL\r\n */\r\nimport { ContourDisplay } from \"@itwin/core-common\";\r\nimport { TextureUnit } from \"../RenderFlags\";\r\nimport {\r\n  FragmentShaderComponent, ProgramBuilder, VariableType,\r\n} from \"../ShaderBuilder\";\r\nimport { addFeatureIndex } from \"./FeatureSymbology\";\r\nimport { addInstancedRtcMatrix } from \"./Vertex\";\r\n\r\nconst computeContourNdx = `\r\n  if (u_contourLUTWidth == 0u)\r\n      return 15.0;\r\n  uint lutIndex = uint(getFeatureIndex());\r\n  bool odd = bool(lutIndex & 1u);\r\n  lutIndex /= 2u;\r\n  uint byteSel = lutIndex & 0x3u;\r\n  lutIndex /= 4u;\r\n  ivec2 coords = ivec2(lutIndex % u_contourLUTWidth, lutIndex / u_contourLUTWidth);\r\n  uvec4 contourNdx4 = uvec4(texelFetch(u_contourLUT, coords, 0) * 255.0 + 0.5);\r\n  uvec2 contourNdx2 = bool(byteSel & 2u) ? contourNdx4.ba : contourNdx4.rg;\r\n  uint contourNdx = bool(byteSel & 1u) ? contourNdx2.g : contourNdx2.r;\r\n  return float(odd ? contourNdx >> 4u : contourNdx & 0xFu);\r\n`;\r\n\r\nconst unpack2BytesVec4 = `\r\nvec4 unpack2BytesVec4(vec4 f, bool upper) {\r\n  f = floor(f + 0.5);\r\n  vec4 outUpper = floor(f / 256.0);\r\n  vec4 outLower = floor(f - outUpper * 256.0);\r\n  return upper ? outUpper : outLower;\r\n}\r\n`;\r\n\r\nconst unpackAndNormalize2BytesVec4 = `\r\nvec4 unpackAndNormalize2BytesVec4(vec4 f, bool upper) {\r\n  return unpack2BytesVec4(f, upper) / 255.0;\r\n}\r\n`;\r\n\r\nconst applyContours = `\r\n  int contourNdx = int(v_contourNdx + 0.5);\r\n  if (contourNdx > 14) // 15 => no contours\r\n    return baseColor;\r\n\r\n  const int maxDefs = ${ContourDisplay.maxContourGroups}; // max number of contour definitions allowed, have to change index arrays if this changes\r\n  int contourNdxC = clamp(contourNdx, 0, maxDefs - 1);\r\n\r\n  bool even = (contourNdxC & 1) == 0;\r\n  vec4 rgbfp = u_contourDefs[even ? contourNdxC * 3 / 2 : (contourNdxC - 1) * 3 / 2 + 2];\r\n  vec4 intervalsPair = u_contourDefs[(contourNdxC / 2) * 3 + 1];\r\n  // intervals.r => minor interval distance, intervals.g => major index count\r\n  vec2 intervals = even ? intervalsPair.rg : intervalsPair.ba;\r\n\r\n  float coord = v_height / intervals.r;\r\n  // determine if this is in the vicinity of a major contour line (1/2 an interval either way, which is one limit of drawing width)\r\n  bool maj = (fract((abs(coord) + 0.5) / intervals.g) < (1.0 / intervals.g));\r\n  vec4 rgbf = unpackAndNormalize2BytesVec4(rgbfp, maj);\r\n  // rgbf.a => (4-bit linecode / 4-bit weight) maj/min, where the 4-bit weight is a 3-bit weight value with one fraction bit and a 1.5 offset.\r\n  //    This gives a weight range of 1.5 to 9 in 0.5 increments.\r\n  //    NB: the showGeometry bit flag is stuck in at bit 16 of this, so the major line code has an extra bit in it that needs to be masked out\r\n  int lineCodeWt = int((rgbf.a * 255.0) + 0.5);\r\n  // first * 0.5 is for fractional part of width, then have to add 1.0 for offset, then another 1.0 for actual width bias\r\n  float lineRadius = (float(lineCodeWt & 0xf) * 0.5 + 2.0) * 0.5;\r\n\r\n  // abs(fract(coord - 0.5) - 0.5) will produce 0.0 at the contour line, and 0.5 at the mid-point between contour lines\r\n  // fwidth(coord) is sum of absolute diffs in coord in adjacent pixels\r\n  float line = abs(fract(coord - 0.5) - 0.5) / fwidth(coord);\r\n  // If line is 0 (like at contour line), contourAlpha = lineRadius, so will use draw in contour color\r\n\t// If line >= lineRadius, contourAlpha = 0, so won't show contour\r\n  float contourAlpha = lineRadius - min(line, lineRadius);\r\n\r\n  // figure out which direction line is going, to know which screen pattern offset to use\r\n  float dx = dFdx(contourAlpha);\r\n  float dy = dFdy(contourAlpha);\r\n\r\n  const float patLength = 32.0;\r\n  uint patterns[10] = uint[](0xffffffffu, 0x80808080u, 0xf8f8f8f8u, 0xffe0ffe0u, 0xfe10fe10u, 0xe0e0e0e0u, 0xf888f888u, 0xff18ff18u, 0xccccccccu, 0x00000001u);\r\n\r\n  float offset = trunc((abs(dx) > abs(dy)) ? gl_FragCoord.y : gl_FragCoord.x);\r\n  offset = mod(offset, patLength);\r\n  uint msk = 1u << uint(offset);\r\n  contourAlpha *= (patterns[(lineCodeWt / 16) & 0xf] & msk) > 0u ? 1.0 : 0.0;\r\n  contourAlpha = min(contourAlpha, 1.0);\r\n  if (rgbfp.a / 65536.0 < 0.5) { // showGeometry == 0\r\n    if (contourAlpha < 0.5)\r\n      discard;\r\n    return vec4(rgbf.rgb, 1.0);\r\n  }\r\n  // set contour opaque even if base color is transparent\r\n  float alpha = contourAlpha >= 0.5 ? 1.0 : baseColor.a;\r\n  return vec4(mix(baseColor.rgb, rgbf.rgb, contourAlpha), alpha);\r\n`;\r\n\r\n/** @internal */\r\nexport function addApplyContours(builder: ProgramBuilder) {\r\n  const modelPos = builder.vert.usesInstancedGeometry ? \"(g_instancedRtcMatrix * rawPosition)\" : \"rawPosition\";\r\n\r\n  const computeWorldHeight = `\r\nfloat computeWorldHeight(vec4 rawPosition) {\r\n  float height = (u_modelToWorldC * ${modelPos}).z;\r\n  // TODO: apply ECEF correction to height\r\n  return height;\r\n}\r\n`;\r\n\r\n  addFeatureIndex(builder.vert);\r\n\r\n  builder.addFunctionComputedVarying(\"v_contourNdx\", VariableType.Float, \"computeContourNdx\", computeContourNdx);\r\n  builder.addFunctionComputedVaryingWithArgs(\"v_height\", VariableType.Float, \"computeWorldHeight(rawPosition)\", computeWorldHeight);\r\n\r\n  if (builder.vert.usesInstancedGeometry)\r\n    addInstancedRtcMatrix(builder.vert);\r\n\r\n  builder.vert.addUniform(\"u_contourLUT\", VariableType.Sampler2D, (prog) => {\r\n    prog.addGraphicUniform(\"u_contourLUT\", (uniform, params) => {\r\n      // set this uniform here so that it won't cause problems (e.g.: loopback) if it does not end up being set by bindContourLUT call\r\n      uniform.setUniform1i(TextureUnit.Contours - TextureUnit.Zero);\r\n      params.target.uniforms.batch.bindContourLUT(uniform);\r\n    });\r\n  });\r\n\r\n  builder.vert.addUniform(\"u_contourLUTWidth\", VariableType.Uint, (prog) => {\r\n    prog.addGraphicUniform(\"u_contourLUTWidth\", (uniform, params) => {\r\n      params.target.uniforms.batch.bindContourLUTWidth(uniform);\r\n    });\r\n  });\r\n\r\n  builder.vert.addUniform(\"u_modelToWorldC\", VariableType.Mat4, (prog) => {\r\n    prog.addGraphicUniform(\"u_modelToWorldC\", (uniform, params) => {\r\n      params.target.uniforms.branch.bindModelToWorldTransform(uniform, params.geometry, false);\r\n    });\r\n  });\r\n\r\n  const contourDefsSize = 8;\r\n  builder.frag.addUniformArray(\"u_contourDefs\", VariableType.Vec4, contourDefsSize, (prog) => {\r\n    prog.addGraphicUniform(\"u_contourDefs\", (uniform, params) => {\r\n      params.target.uniforms.contours.bindcontourDefs(uniform);\r\n    });\r\n  });\r\n\r\n  builder.frag.addFunction(unpack2BytesVec4);\r\n  builder.frag.addFunction(unpackAndNormalize2BytesVec4);\r\n  builder.frag.set(FragmentShaderComponent.ApplyContours, applyContours);\r\n}\r\n"]}

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

@@ -24,7 +24,7 @@ export function createCopyColorProgram(context, copyAlpha = true) {
     const builder = createViewportQuadBuilder(true);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, copyAlpha ? computeColor : computeColorNoAlpha);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_color", 8 /* VariableType.Sampler2D */, (prog) => {
         prog.addGraphicUniform("u_color", (uniform, params) => {
             const geom = params.geometry;

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

@@ -29,7 +29,7 @@ export function createCopyPickBuffersProgram(context) {
         });
     }, 3 /* VariablePrecision.High */);
     frag.addDrawBuffersExtension(2);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragData);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragData);
     builder.vert.headerComment = "//!V! CopyPickBuffers";
     builder.frag.headerComment = "//!F! CopyPickBuffers";
     return builder.buildProgram(context);

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

@@ -52,7 +52,7 @@ export function createVolClassColorUsingStencilProgram(context) {
     const builder = createViewportQuadBuilder(false);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computehiliteColor);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_hilite_color", 5 /* VariableType.Vec4 */, (prog) => {
         prog.addGraphicUniform("u_hilite_color", (uniform, params) => {
             const useLighting = params.geometry.getFlashMode(params);
@@ -75,7 +75,7 @@ export function createVolClassCopyZProgram(context) {
     builder.addInlineComputedVarying("v_texCoord", 3 /* VariableType.Vec2 */, computeTexCoord); // TODO: I think this is not necessary because it's already added from the create above
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeSetBlendColor);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_blend_color", 5 /* VariableType.Vec4 */, (prog) => {
         prog.addGraphicUniform("u_blend_color", (uniform, _params) => {
             scratchColor.set(0.0, 0.0, 0.0, 0.0);
@@ -88,7 +88,7 @@ export function createVolClassCopyZProgram(context) {
             Texture2DHandle.bindSampler(uniform, geom.texture, TextureUnit.Zero);
         });
     });
-    frag.set(18 /* FragmentShaderComponent.FinalizeDepth */, depthFromTexture);
+    frag.set(19 /* FragmentShaderComponent.FinalizeDepth */, depthFromTexture);
     builder.vert.headerComment = "//!V! VolClassCopyZ";
     builder.frag.headerComment = "//!F! VolClassCopyZ";
     return builder.buildProgram(context);
@@ -101,7 +101,7 @@ export function createVolClassSetBlendProgram(context) {
     addBoundaryTypeConstants(frag);
     frag.set(0 /* FragmentShaderComponent.CheckForEarlyDiscard */, checkDiscardBackgroundByZ);
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeSetBlendColor);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_boundaryType", 1 /* VariableType.Int */, (prog) => {
         prog.addGraphicUniform("u_boundaryType", (uniform, params) => {
             const geom = params.geometry;
@@ -144,7 +144,7 @@ export function createVolClassBlendProgram(context) {
     builder.addInlineComputedVarying("v_texCoord", 3 /* VariableType.Vec2 */, computeTexCoord);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeBlendTextureColor);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_blendTexture", 8 /* VariableType.Sampler2D */, (prog) => {
         prog.addGraphicUniform("u_blendTexture", (uniform, params) => {
             const geom = params.geometry;

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

@@ -45,7 +45,7 @@ export function createEDLCalcBasicProgram(context) {
     const builder = createViewportQuadBuilder(true);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, calcBasicEDL);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_texInfo", 4 /* VariableType.Vec3 */, (prog) => {
         prog.addGraphicUniform("u_texInfo", (uniform, params) => {
             const geom = params.geometry;
@@ -111,7 +111,7 @@ export function createEDLCalcFullProgram(context) {
     const builder = createViewportQuadBuilder(true);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, calcFullEDL);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_texInfo", 4 /* VariableType.Vec3 */, (prog) => {
         prog.addGraphicUniform("u_texInfo", (uniform, params) => {
             const geom = params.geometry;
@@ -182,7 +182,7 @@ export function createEDLFilterProgram(context) {
     const builder = createViewportQuadBuilder(true);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, filterEDL);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_texInfo", 4 /* VariableType.Vec3 */, (prog) => {
         prog.addGraphicUniform("u_texInfo", (uniform, params) => {
             const geom = params.geometry;
@@ -221,7 +221,7 @@ export function createEDLMixProgram(context) {
     const builder = createViewportQuadBuilder(true);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, mixEDL);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     frag.addUniform("u_colorTexture1", 8 /* VariableType.Sampler2D */, (prog) => {
         prog.addGraphicUniform("u_colorTexture1", (uniform, params) => {
             const geom = params.geometry;

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

@@ -63,7 +63,7 @@ export function createEVSMProgram(context) {
     addEvsmExponent(frag);
     frag.addFunction(warpDepth);
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeEVSM);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
     builder.vert.headerComment = "//!V! EVSMFromDepth";
     builder.frag.headerComment = "//!F! EVSMFromDepth";
     return builder.buildProgram(context);

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

@@ -237,7 +237,7 @@ function createBase(type, instanced, isAnimated, positionType) {
         addRenderOrder(vert);
         addRenderOrderConstants(vert);
         builder.addInlineComputedVarying("v_renderOrder", 2 /* VariableType.Float */, computeIndexedRenderOrder);
-        builder.frag.set(20 /* FragmentShaderComponent.OverrideRenderOrder */, "return v_renderOrder;");
+        builder.frag.set(21 /* FragmentShaderComponent.OverrideRenderOrder */, "return v_renderOrder;");
     }
     else {
         vert.addInitializer(decodeEndPointAndQuadIndices);

package/lib/esm/render/webgl/glsl/FeatureSymbology.d.ts

@@ -1,7 +1,7 @@
 /** @packageDocumentation
  * @module WebGL
  */
-import { FragmentShaderBuilder, ProgramBuilder, ShaderBuilder } from "../ShaderBuilder";
+import { FragmentShaderBuilder, ProgramBuilder, ShaderBuilder, VertexShaderBuilder } from "../ShaderBuilder";
 import { FeatureMode, TechniqueFlags } from "../TechniqueFlags";
 /** @internal */
 export declare const enum FeatureSymbologyOptions {
@@ -17,6 +17,7 @@ export declare const enum FeatureSymbologyOptions {
 }
 /** @internal */
 export declare function addOvrFlagConstants(builder: ShaderBuilder): void;
+export declare function addFeatureIndex(vert: VertexShaderBuilder): void;
 export declare function addMaxAlpha(builder: ShaderBuilder): void;
 /** @internal */
 export declare function addSurfaceHiliter(builder: ProgramBuilder, wantWeight?: boolean): void;

package/lib/esm/render/webgl/glsl/FeatureSymbology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FeatureSymbology.d.ts","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/FeatureSymbology.ts"],"names":[],"mappings":"AAIA;;GAEG;AAIH,OAAO,EACL,qBAAqB,EAA2B,cAAc,EAAE,aAAa,EAE9E,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAUhE,gBAAgB;AAChB,0BAAkB,uBAAuB;IACvC,IAAI,IAAI;IACR,MAAM,IAAS;IACf,QAAQ,IAAS;IACjB,YAAY,IAAS;IACrB,KAAK,IAAS;IACd,KAAK,KAAS;IAEd,OAAO,KAA+B;IACtC,KAAK,KAAwC;IAC7C,MAAM,KAAmD;CAC1D;AAED,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAehE;AAmOD,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAIxD;AA6DD,gBAAgB;AAChB,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,UAAU,GAAE,OAAe,GAAG,IAAI,CAG5F;AAED,gBAAgB;AAChB,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,EAAE,UAAU,GAAE,OAAe,GAAG,IAAI,CAkBrF;AAkBD,gBAAgB;AAChB,eAAO,MAAM,iBAAiB,yLAM7B,CAAC;AAuEF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,aAAa,QAa7D;AAED,gBAAgB;AAChB,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,QAOpD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,QAMzD;AAgBD,gBAAgB;AAChB,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,OAAO,QAiB3E;AASD,gBAAgB;AAChB,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,QA4D/E;AA4DD,eAAO,MAAM,eAAe,sOAIzB,CAAC;AAwCJ,gBAAgB;AAChB,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAIpE;AAoBD,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAoBnH;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAW/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI,CA0ClG"}
+{"version":3,"file":"FeatureSymbology.d.ts","sourceRoot":"","sources":["../../../../../src/render/webgl/glsl/FeatureSymbology.ts"],"names":[],"mappings":"AAIA;;GAEG;AAIH,OAAO,EACL,qBAAqB,EAA2B,cAAc,EAAE,aAAa,EAAmC,mBAAmB,EAEpI,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAWhE,gBAAgB;AAChB,0BAAkB,uBAAuB;IACvC,IAAI,IAAI;IACR,MAAM,IAAS;IACf,QAAQ,IAAS;IACjB,YAAY,IAAS;IACrB,KAAK,IAAS;IACd,KAAK,KAAS;IAEd,OAAO,KAA+B;IACtC,KAAK,KAAwC;IAC7C,MAAM,KAAmD;CAC1D;AAED,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAkBhE;AAwED,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAK/D;AAsJD,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAIxD;AA6DD,gBAAgB;AAChB,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,UAAU,GAAE,OAAe,GAAG,IAAI,CAG5F;AAED,gBAAgB;AAChB,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,EAAE,UAAU,GAAE,OAAe,GAAG,IAAI,CAkBrF;AAkBD,gBAAgB;AAChB,eAAO,MAAM,iBAAiB,yLAM7B,CAAC;AAuEF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,aAAa,QAc7D;AAED,gBAAgB;AAChB,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,QAOpD;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,QAMzD;AAgBD,gBAAgB;AAChB,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,OAAO,QAiB3E;AASD,gBAAgB;AAChB,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,QA4D/E;AAkED,eAAO,MAAM,eAAe,sOAIzB,CAAC;AAwCJ,gBAAgB;AAChB,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAIpE;AAoBD,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAsBnH;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAW/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI,CA0ClG"}

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

@@ -16,10 +16,10 @@ import { addAlpha, addLineWeight, replaceLineCode, replaceLineWeight } from "./V
 /** @internal */
 export function addOvrFlagConstants(builder) {
     // NB: These are the bit positions of each flag in OvrFlags enum - not the flag values
-    builder.addBitFlagConstant("kOvrBit_Visibility", 0);
+    builder.addBitFlagConstant("kOvrBit_LineRgb", 0);
     builder.addBitFlagConstant("kOvrBit_Rgb", 1);
     builder.addBitFlagConstant("kOvrBit_Alpha", 2);
-    builder.addBitFlagConstant("kOvrBit_IgnoreMaterial", 3);
+    builder.addBitFlagConstant("kOvrBit_LineAlpha", 3);
     builder.addBitFlagConstant("kOvrBit_Flashed", 4);
     builder.addBitFlagConstant("kOvrBit_NonLocatable", 5);
     builder.addBitFlagConstant("kOvrBit_LineCode", 6);
@@ -28,6 +28,9 @@ export function addOvrFlagConstants(builder) {
     builder.addBitFlagConstant("kOvrBit_Hilited", 0);
     builder.addBitFlagConstant("kOvrBit_Emphasized", 1);
     builder.addBitFlagConstant("kOvrBit_ViewIndependentTransparency", 2);
+    builder.addBitFlagConstant("kOvrBit_InvisibleDuringPick", 3);
+    builder.addBitFlagConstant("kOvrBit_Visibility", 4);
+    builder.addBitFlagConstant("kOvrBit_IgnoreMaterial", 5);
 }
 const computeLUTFeatureIndex = `g_featureAndMaterialIndex.xyz`;
 const computeInstanceFeatureIndex = `g_isAreaPattern ? u_patternFeatureId : a_featureId`;
@@ -73,9 +76,9 @@ vec4 getFirstFeatureRgba() {
 }
 `;
 const getSecondFeatureRgba = `
-vec4 getSecondFeatureRgba() {
+vec4 getSecondFeatureRgba(bool isLinear) {
   vec2 coord = feature_texCoord;
-  coord.x += g_feature_stepX;
+  coord.x += g_feature_stepX * (isLinear ? 2.0 : 1.0);
   return TEXTURE(u_featureLUT, coord);
 }
 `;
@@ -89,7 +92,7 @@ float computeLineCode() {
   return linear_feature_overrides.z > 0.5 ? linear_feature_overrides.w : g_lineCode;
 }
 `;
-function addFeatureIndex(vert) {
+export function addFeatureIndex(vert) {
     vert.addGlobal("g_featureIndex", 4 /* VariableType.Vec3 */);
     vert.addFunction(decodeUint24);
     vert.addFunction(getFeatureIndex(vert));
@@ -193,7 +196,7 @@ function addCommon(builder, mode, opts, wantGlobalOvrFlags = true) {
             });
         });
     }
-    addLookupTable(vert, "feature", "2.0");
+    addLookupTable(vert, "feature", "3.0");
     vert.addGlobal("feature_texCoord", 3 /* VariableType.Vec2 */);
     vert.addFunction(computeFeatureTextureCoords);
     vert.addFunction(getFirstFeatureRgba);
@@ -294,7 +297,7 @@ export function addHiliter(builder, wantWeight = false) {
     addEmphasisFlags(builder.frag);
     addExtractNthBit(builder.frag);
     builder.frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeHiliteColor);
-    builder.frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    builder.frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
 }
 function addSamplers(frag, testFeatureId) {
     if (testFeatureId) {
@@ -388,6 +391,7 @@ const checkForEarlySurfaceDiscardWithFeatureID = `
 export function addRenderOrderConstants(builder) {
     builder.addConstant("kRenderOrder_BlankingRegion", 2 /* VariableType.Float */, 2 /* RenderOrder.BlankingRegion */.toFixed(1));
     builder.addConstant("kRenderOrder_Linear", 2 /* VariableType.Float */, 5 /* RenderOrder.Linear */.toFixed(1));
+    builder.addConstant("kRenderOrder_PlanarLinear", 2 /* VariableType.Float */, 13 /* RenderOrder.PlanarLinear */.toFixed(1));
     builder.addConstant("kRenderOrder_Edge", 2 /* VariableType.Float */, 6 /* RenderOrder.Edge */.toFixed(1));
     builder.addConstant("kRenderOrder_PlanarEdge", 2 /* VariableType.Float */, 14 /* RenderOrder.PlanarEdge */.toFixed(1));
     builder.addConstant("kRenderOrder_Silhouette", 2 /* VariableType.Float */, 7 /* RenderOrder.Silhouette */.toFixed(1));
@@ -515,23 +519,29 @@ const computeFeatureOverrides = `
   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)
+  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(flags, kOvrBit_Visibility);
+  bool invisible = nthFeatureBitSet(emphFlags, kOvrBit_Visibility);
   feature_invisible = invisible || nonLocatable;
   if (feature_invisible)
     return;
 
-  bool rgbOverridden = nthFeatureBitSet(flags, kOvrBit_Rgb);
-  bool alphaOverridden = nthFeatureBitSet(flags, kOvrBit_Alpha);
+  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();
+    vec4 rgba = getSecondFeatureRgba(isLinear);
     if (rgbOverridden)
       feature_rgb = rgba.rgb;
 
@@ -546,7 +556,7 @@ const computeFeatureOverrides = `
                                   nthFeatureBitSet(flags, kOvrBit_LineCode),
                                   value.z * 256.0);
 
-  feature_ignore_material = nthFeatureBitSet(flags, kOvrBit_IgnoreMaterial);
+  feature_ignore_material = nthFeatureBitSet(emphFlags, kOvrBit_IgnoreMaterial);
   use_material = use_material && !feature_ignore_material;
 
   v_feature_emphasis += kEmphFlag_Flash * extractNthFeatureBit(flags, kOvrBit_Flashed);
@@ -618,7 +628,7 @@ function addApplyFlash(frag) {
     addEmphasisFlags(frag);
     addExtractNthBit(frag);
     frag.addFunction(doApplyFlash);
-    frag.set(11 /* FragmentShaderComponent.ApplyFlash */, applyFlash);
+    frag.set(12 /* FragmentShaderComponent.ApplyFlash */, applyFlash);
     addFlashIntensity(frag);
 }
 /** @internal */
@@ -634,6 +644,8 @@ export function addFeatureSymbology(builder, feat, opts) {
     vert.addGlobal("feature_viewIndependentTransparency", 0 /* VariableType.Boolean */, "false");
     addEmphasisFlags(vert);
     vert.addGlobal("use_material", 0 /* VariableType.Boolean */, "true");
+    addRenderOrder(vert);
+    addRenderOrderConstants(vert);
     vert.set(3 /* VertexShaderComponent.ComputeFeatureOverrides */, computeFeatureOverrides);
     vert.set(7 /* VertexShaderComponent.ApplyFeatureColor */, applyFeatureColor);
     addApplyFlash(builder.frag);
@@ -651,7 +663,7 @@ export function addUniformHiliter(builder) {
     addEmphasisFlags(builder.frag);
     addExtractNthBit(builder.frag);
     builder.frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeHiliteColor);
-    builder.frag.set(16 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
+    builder.frag.set(17 /* FragmentShaderComponent.AssignFragData */, assignFragColor);
 }
 /** For a uniform feature table, the feature ID output to pick buffers is equal to the batch ID.
  * The following symbology overrides are supported: