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

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addApplyContours = void 0;
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+const core_common_1 = require("@itwin/core-common");
+const RenderFlags_1 = require("../RenderFlags");
+const FeatureSymbology_1 = require("./FeatureSymbology");
+const Vertex_1 = require("./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 = ${core_common_1.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 */
+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;
+}
+`;
+    (0, FeatureSymbology_1.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)
+        (0, Vertex_1.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(RenderFlags_1.TextureUnit.Contours - RenderFlags_1.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);
+}
+exports.addApplyContours = addApplyContours;
+//# sourceMappingURL=Contours.js.map

package/lib/cjs/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/cjs/render/webgl/glsl/CopyColor.js

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

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

@@ -32,7 +32,7 @@ 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/cjs/render/webgl/glsl/CopyStencil.js

@@ -55,7 +55,7 @@ function createVolClassColorUsingStencilProgram(context) {
     const builder = (0, ViewportQuad_1.createViewportQuadBuilder)(false);
     const frag = builder.frag;
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computehiliteColor);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
     frag.addUniform("u_hilite_color", 5 /* VariableType.Vec4 */, (prog) => {
         prog.addGraphicUniform("u_hilite_color", (uniform, params) => {
             const useLighting = params.geometry.getFlashMode(params);
@@ -79,7 +79,7 @@ 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 */, Fragment_1.assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, Fragment_1.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);
@@ -92,7 +92,7 @@ function createVolClassCopyZProgram(context) {
             Texture_1.Texture2DHandle.bindSampler(uniform, geom.texture, RenderFlags_1.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);
@@ -106,7 +106,7 @@ function createVolClassSetBlendProgram(context) {
     addBoundaryTypeConstants(frag);
     frag.set(0 /* FragmentShaderComponent.CheckForEarlyDiscard */, checkDiscardBackgroundByZ);
     frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeSetBlendColor);
-    frag.set(16 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
     frag.addUniform("u_boundaryType", 1 /* VariableType.Int */, (prog) => {
         prog.addGraphicUniform("u_boundaryType", (uniform, params) => {
             const geom = params.geometry;
@@ -150,7 +150,7 @@ 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 */, Fragment_1.assignFragColor);
+    frag.set(17 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
     frag.addUniform("u_blendTexture", 8 /* VariableType.Sampler2D */, (prog) => {
         prog.addGraphicUniform("u_blendTexture", (uniform, params) => {
             const geom = params.geometry;

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

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

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

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

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

@@ -241,7 +241,7 @@ function createBase(type, instanced, isAnimated, positionType) {
         (0, FeatureSymbology_1.addRenderOrder)(vert);
         (0, FeatureSymbology_1.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/cjs/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/cjs/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/cjs/render/webgl/glsl/FeatureSymbology.js

@@ -7,7 +7,7 @@
  * @module WebGL
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addUniformFeatureSymbology = exports.addUniformHiliter = exports.addFeatureSymbology = exports.addClassifierFlash = exports.mixFeatureColor = exports.addSurfaceDiscard = exports.addFeatureId = exports.addPixelWidthFactor = exports.addRenderOrder = exports.addRenderOrderConstants = exports.readDepthAndOrder = exports.addHiliter = exports.addSurfaceHiliter = exports.addMaxAlpha = exports.addOvrFlagConstants = void 0;
+exports.addUniformFeatureSymbology = exports.addUniformHiliter = exports.addFeatureSymbology = exports.addClassifierFlash = exports.mixFeatureColor = exports.addSurfaceDiscard = exports.addFeatureId = exports.addPixelWidthFactor = exports.addRenderOrder = exports.addRenderOrderConstants = exports.readDepthAndOrder = exports.addHiliter = exports.addSurfaceHiliter = exports.addMaxAlpha = exports.addFeatureIndex = exports.addOvrFlagConstants = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const RenderFlags_1 = require("../RenderFlags");
 const Common_1 = require("./Common");
@@ -19,10 +19,10 @@ const Vertex_1 = require("./Vertex");
 /** @internal */
 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);
@@ -31,6 +31,9 @@ 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);
 }
 exports.addOvrFlagConstants = addOvrFlagConstants;
 const computeLUTFeatureIndex = `g_featureAndMaterialIndex.xyz`;
@@ -77,9 +80,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);
 }
 `;
@@ -98,6 +101,7 @@ function addFeatureIndex(vert) {
     vert.addFunction(Decode_1.decodeUint24);
     vert.addFunction(getFeatureIndex(vert));
 }
+exports.addFeatureIndex = addFeatureIndex;
 // 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 = `
@@ -197,7 +201,7 @@ function addCommon(builder, mode, opts, wantGlobalOvrFlags = true) {
             });
         });
     }
-    (0, LookupTable_1.addLookupTable)(vert, "feature", "2.0");
+    (0, LookupTable_1.addLookupTable)(vert, "feature", "3.0");
     vert.addGlobal("feature_texCoord", 3 /* VariableType.Vec2 */);
     vert.addFunction(computeFeatureTextureCoords);
     vert.addFunction(getFirstFeatureRgba);
@@ -300,7 +304,7 @@ function addHiliter(builder, wantWeight = false) {
     addEmphasisFlags(builder.frag);
     (0, Common_1.addExtractNthBit)(builder.frag);
     builder.frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeHiliteColor);
-    builder.frag.set(16 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
+    builder.frag.set(17 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
 }
 exports.addHiliter = addHiliter;
 function addSamplers(frag, testFeatureId) {
@@ -395,6 +399,7 @@ const checkForEarlySurfaceDiscardWithFeatureID = `
 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));
@@ -527,23 +532,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;
 
@@ -558,7 +569,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);
@@ -631,7 +642,7 @@ function addApplyFlash(frag) {
     addEmphasisFlags(frag);
     (0, Common_1.addExtractNthBit)(frag);
     frag.addFunction(doApplyFlash);
-    frag.set(11 /* FragmentShaderComponent.ApplyFlash */, applyFlash);
+    frag.set(12 /* FragmentShaderComponent.ApplyFlash */, applyFlash);
     addFlashIntensity(frag);
 }
 /** @internal */
@@ -647,6 +658,8 @@ 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);
@@ -665,7 +678,7 @@ function addUniformHiliter(builder) {
     addEmphasisFlags(builder.frag);
     (0, Common_1.addExtractNthBit)(builder.frag);
     builder.frag.set(1 /* FragmentShaderComponent.ComputeBaseColor */, computeHiliteColor);
-    builder.frag.set(16 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
+    builder.frag.set(17 /* FragmentShaderComponent.AssignFragData */, Fragment_1.assignFragColor);
 }
 exports.addUniformHiliter = addUniformHiliter;
 /** For a uniform feature table, the feature ID output to pick buffers is equal to the batch ID.