@itwin/core-frontend 3.2.0-dev.9 → 3.3.0-dev.2

package/lib/esm/render/webgl/Technique.js

@@ -6,6 +6,7 @@
  * @module WebGL
  */
 import { assert, dispose, using } from "@itwin/core-bentley";
+import { BlurType } from "./CachedGeometry";
 import { createClippingProgram } from "./ClippingProgram";
 import { createAmbientOcclusionProgram } from "./glsl/AmbientOcclusion";
 import { createBlurProgram } from "./glsl/Blur";
@@ -140,9 +141,9 @@ export class VariedTechnique {
         this._clippingPrograms[index] = createClippingProgram(builder);
         assert(this._clippingPrograms[index] !== undefined);
     }
-    addHiliteShader(gl, instanced, classified, create) {
-        const builder = create(instanced, classified);
-        scratchHiliteFlags.initForHilite(0, instanced, classified);
+    addHiliteShader(gl, instanced, classified, posType, create) {
+        const builder = create(instanced, classified, posType);
+        scratchHiliteFlags.initForHilite(0, instanced, classified, posType);
         this.addShader(builder, scratchHiliteFlags, gl);
     }
     addTranslucentShader(builder, flags, gl) {
@@ -202,38 +203,40 @@ export class VariedTechnique {
         }
     }
 }
+const positionTypes = ["quantized", "unquantized"];
 class SurfaceTechnique extends VariedTechnique {
     constructor(gl) {
-        // 3 base classified variations - 1 per feature mode.
-        // Plus thematic variant of each and shadowable variant of each = 9
-        // Plus translucent variant of each of those = 18
-        // Plus 1 hilite shader = 19
-        super(SurfaceTechnique._kClassified + 19);
+        super(SurfaceTechnique._kUnquantized * 2);
         this._earlyZFlags = [
             TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
             TechniqueFlags.fromDescription("Opaque-Instanced-Hilite-Overrides"),
             TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
+            TechniqueFlags.fromDescription("Unquantized-Opaque-Hilite-Overrides"),
+            TechniqueFlags.fromDescription("Unquantized-Opaque-Instanced-Hilite-Overrides"),
+            TechniqueFlags.fromDescription("Unquantized-Opaque-Hilite-Classified"),
         ];
         const flags = scratchTechniqueFlags;
-        for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
-            this.addHiliteShader(gl, instanced, 0 /* No */, createSurfaceHiliter);
-            for (let iAnimate = 0 /* No */; iAnimate <= 1 /* Yes */; iAnimate++) {
-                for (let shadowable = 0 /* No */; shadowable <= 1 /* Yes */; shadowable++) {
-                    for (let wiremesh = 0 /* No */; wiremesh <= 1 /* Yes */; wiremesh++) {
-                        for (let thematic = 0 /* No */; thematic <= 1 /* Yes */; thematic++) {
-                            for (let edgeTestNeeded = 0 /* No */; edgeTestNeeded <= 1 /* Yes */; edgeTestNeeded++) {
-                                for (const featureMode of featureModes) {
-                                    for (let iTranslucent = 0; iTranslucent <= 1; iTranslucent++) {
-                                        if (0 /* None */ !== featureMode || 0 /* No */ === edgeTestNeeded) {
-                                            if (1 /* Yes */ === thematic && 1 /* Yes */ === shadowable)
-                                                continue; // currently this combination is disallowed.
-                                            flags.reset(featureMode, instanced, shadowable, thematic);
-                                            flags.isAnimated = iAnimate;
-                                            flags.isEdgeTestNeeded = edgeTestNeeded;
-                                            flags.isTranslucent = 1 === iTranslucent;
-                                            flags.isWiremesh = wiremesh;
-                                            const builder = createSurfaceBuilder(flags);
-                                            this.addShader(builder, flags, gl);
+        for (const posType of positionTypes) {
+            for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
+                this.addHiliteShader(gl, instanced, 0 /* No */, posType, createSurfaceHiliter);
+                for (let iAnimate = 0 /* No */; iAnimate <= 1 /* Yes */; iAnimate++) {
+                    for (let shadowable = 0 /* No */; shadowable <= 1 /* Yes */; shadowable++) {
+                        for (let wiremesh = 0 /* No */; wiremesh <= 1 /* Yes */; wiremesh++) {
+                            for (let thematic = 0 /* No */; thematic <= 1 /* Yes */; thematic++) {
+                                for (let edgeTestNeeded = 0 /* No */; edgeTestNeeded <= 1 /* Yes */; edgeTestNeeded++) {
+                                    for (const featureMode of featureModes) {
+                                        for (let iTranslucent = 0; iTranslucent <= 1; iTranslucent++) {
+                                            if (0 /* None */ !== featureMode || 0 /* No */ === edgeTestNeeded) {
+                                                if (1 /* Yes */ === thematic && 1 /* Yes */ === shadowable)
+                                                    continue; // currently this combination is disallowed.
+                                                flags.reset(featureMode, instanced, shadowable, thematic, posType);
+                                                flags.isAnimated = iAnimate;
+                                                flags.isEdgeTestNeeded = edgeTestNeeded;
+                                                flags.isTranslucent = 1 === iTranslucent;
+                                                flags.isWiremesh = wiremesh;
+                                                const builder = createSurfaceBuilder(flags);
+                                                this.addShader(builder, flags, gl);
+                                            }
                                         }
                                     }
                                 }
@@ -243,20 +246,23 @@ class SurfaceTechnique extends VariedTechnique {
                 }
             }
         }
-        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, createSurfaceHiliter);
-        for (let translucent = 0; translucent < 2; translucent++) {
-            for (let shadowable = 0 /* No */; shadowable <= 1 /* Yes */; shadowable++) {
-                for (let thematic = 0 /* No */; thematic <= 1 /* Yes */; thematic++) {
-                    for (const featureMode of featureModes) {
-                        if (1 /* Yes */ === thematic && 1 /* Yes */ === shadowable)
-                            continue; // currently this combination is disallowed.
-                        flags.reset(featureMode, 0 /* No */, shadowable, thematic);
-                        flags.isClassified = 1 /* Yes */;
-                        flags.isTranslucent = (0 !== translucent);
-                        const builder = createSurfaceBuilder(flags);
-                        if (flags.isTranslucent)
-                            addTranslucency(builder);
-                        this.addShader(builder, flags, gl);
+        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, "quantized", createSurfaceHiliter);
+        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, "unquantized", createSurfaceHiliter);
+        for (const posType of positionTypes) {
+            for (let translucent = 0; translucent < 2; translucent++) {
+                for (let shadowable = 0 /* No */; shadowable <= 1 /* Yes */; shadowable++) {
+                    for (let thematic = 0 /* No */; thematic <= 1 /* Yes */; thematic++) {
+                        for (const featureMode of featureModes) {
+                            if (1 /* Yes */ === thematic && 1 /* Yes */ === shadowable)
+                                continue; // currently this combination is disallowed.
+                            flags.reset(featureMode, 0 /* No */, shadowable, thematic, posType);
+                            flags.isClassified = 1 /* Yes */;
+                            flags.isTranslucent = (0 !== translucent);
+                            const builder = createSurfaceBuilder(flags);
+                            if (flags.isTranslucent)
+                                addTranslucency(builder);
+                            this.addShader(builder, flags, gl);
+                        }
                     }
                 }
             }
@@ -266,13 +272,14 @@ class SurfaceTechnique extends VariedTechnique {
     get _debugDescription() { return "Surface"; }
     computeShaderIndex(flags) {
         assert(!(flags.isThematic && flags.isShadowable));
+        const idxOffset = flags.positionType === "unquantized" ? SurfaceTechnique._kUnquantized : 0;
         if (flags.isClassified) {
             assert(!flags.isAnimated);
             assert(!flags.isInstanced);
             assert(!flags.isEdgeTestNeeded);
             // First classified shader is for hilite
             if (flags.isHilite)
-                return SurfaceTechnique._kClassified;
+                return SurfaceTechnique._kClassified + idxOffset;
             // The rest are organized in 3 groups of 6 - one group per feature mode.
             // Each group contains opaque, translucent, opaque+thematic, translucent+thematic, opaque+shadowable, and translucent+shadowable variants.
             let baseIndex = SurfaceTechnique._kClassified + 1;
@@ -283,11 +290,11 @@ class SurfaceTechnique extends VariedTechnique {
             if (flags.isThematic)
                 baseIndex += 4;
             const featureOffset = 6 * flags.featureMode;
-            return baseIndex + featureOffset;
+            return baseIndex + featureOffset + idxOffset;
         }
         else if (flags.isHilite) {
             assert(flags.hasFeatures);
-            return SurfaceTechnique._kHilite + flags.isInstanced;
+            return SurfaceTechnique._kHilite + flags.isInstanced + idxOffset;
         }
         assert(flags.hasFeatures || flags.isEdgeTestNeeded === 0 /* No */);
         let index = flags.isTranslucent ? SurfaceTechnique._kTranslucent : SurfaceTechnique._kOpaque;
@@ -300,7 +307,7 @@ class SurfaceTechnique extends VariedTechnique {
             index += SurfaceTechnique._kEdgeTestNeeded + (flags.featureMode - 1) * SurfaceTechnique._kFeature;
         else
             index += SurfaceTechnique._kFeature * flags.featureMode;
-        return index;
+        return index + idxOffset;
     }
 }
 SurfaceTechnique._kOpaque = 0;
@@ -316,49 +323,59 @@ SurfaceTechnique._kHilite = SurfaceTechnique._kEdgeTestNeeded + SurfaceTechnique
 // Classifiers are never animated or instanced. They do support shadows, thematic display, and translucency.
 // There are 3 base variations - 1 per feature mode - each with translucent/shadowed/thematic variants; plus 1 for hilite.
 SurfaceTechnique._kClassified = SurfaceTechnique._kHilite + numHiliteVariants;
+// 3 base classified variations - 1 per feature mode.
+// Plus thematic variant of each and shadowable variant of each = 9
+// Plus translucent variant of each of those = 18
+// Plus 1 hilite shader = 19
+SurfaceTechnique._kUnquantized = SurfaceTechnique._kClassified + 19;
 class PolylineTechnique extends VariedTechnique {
     constructor(gl) {
-        super(PolylineTechnique._kHilite + numHiliteVariants);
+        super(PolylineTechnique._kUnquantized * 2);
         this._earlyZFlags = [
             TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
             TechniqueFlags.fromDescription("Opaque-Instanced-Hilite-Overrides"),
+            TechniqueFlags.fromDescription("Unquantized-Opaque-Hilite-Overrides"),
+            TechniqueFlags.fromDescription("Unquantized-Opaque-Instanced-Hilite-Overrides"),
         ];
         const flags = scratchTechniqueFlags;
-        for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
-            this.addHiliteShader(gl, instanced, 0 /* No */, createPolylineHiliter);
-            for (const featureMode of featureModes) {
-                flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                const builder = createPolylineBuilder(instanced);
-                addUnlitMonochrome(builder.frag);
-                // The translucent shaders do not need the element IDs.
-                const builderTrans = createPolylineBuilder(instanced);
-                addUnlitMonochrome(builderTrans.frag);
-                if (2 /* Overrides */ === featureMode) {
-                    addFeatureSymbology(builderTrans, featureMode, 31 /* Linear */);
-                    addFeatureSymbology(builder, featureMode, 31 /* Linear */);
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                }
-                else {
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                    addFeatureSymbology(builder, featureMode, 0 /* None */);
+        for (const posType of positionTypes) {
+            for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
+                this.addHiliteShader(gl, instanced, 0 /* No */, posType, (inst, _class, pos) => createPolylineHiliter(inst, pos));
+                for (const featureMode of featureModes) {
+                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                    const builder = createPolylineBuilder(instanced, posType);
+                    addUnlitMonochrome(builder.frag);
+                    // The translucent shaders do not need the element IDs.
+                    const builderTrans = createPolylineBuilder(instanced, posType);
+                    addUnlitMonochrome(builderTrans.frag);
+                    if (2 /* Overrides */ === featureMode) {
+                        addFeatureSymbology(builderTrans, featureMode, 31 /* Linear */);
+                        addFeatureSymbology(builder, featureMode, 31 /* Linear */);
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                    }
+                    else {
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                        addFeatureSymbology(builder, featureMode, 0 /* None */);
+                    }
+                    this.addFeatureId(builder, featureMode);
+                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                    this.addShader(builder, flags, gl);
                 }
-                this.addFeatureId(builder, featureMode);
-                flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                this.addShader(builder, flags, gl);
             }
         }
         this.finishConstruction();
     }
     get _debugDescription() { return "Polyline"; }
     computeShaderIndex(flags) {
+        const idxOffset = flags.positionType === "unquantized" ? PolylineTechnique._kUnquantized : 0;
         if (flags.isHilite) {
             assert(flags.hasFeatures);
-            return PolylineTechnique._kHilite + flags.isInstanced;
+            return PolylineTechnique._kHilite + flags.isInstanced + idxOffset;
         }
         let index = flags.isTranslucent ? PolylineTechnique._kTranslucent : PolylineTechnique._kOpaque;
         index += PolylineTechnique._kFeature * flags.featureMode;
         index += PolylineTechnique._kInstanced * flags.isInstanced;
-        return index;
+        return index + idxOffset;
     }
 }
 PolylineTechnique._kOpaque = 0;
@@ -366,34 +383,37 @@ PolylineTechnique._kTranslucent = 1;
 PolylineTechnique._kInstanced = 2;
 PolylineTechnique._kFeature = 4;
 PolylineTechnique._kHilite = numFeatureVariants(PolylineTechnique._kFeature);
+PolylineTechnique._kUnquantized = PolylineTechnique._kHilite + numHiliteVariants;
 class EdgeTechnique extends VariedTechnique {
     constructor(gl, type) {
-        super(numFeatureVariants(EdgeTechnique._kFeature));
+        super(EdgeTechnique._kUnquantized * 2);
         this._type = type;
         const flags = scratchTechniqueFlags;
-        for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
-            for (let iAnimate = 0 /* No */; iAnimate <= 1 /* Yes */; iAnimate++) {
-                for (const featureMode of featureModes) {
-                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                    flags.isAnimated = iAnimate;
-                    const builder = createEdgeBuilder(type, flags.isInstanced, flags.isAnimated);
-                    addUnlitMonochrome(builder.frag);
-                    // The translucent shaders do not need the element IDs.
-                    const builderTrans = createEdgeBuilder(type, flags.isInstanced, flags.isAnimated);
-                    addUnlitMonochrome(builderTrans.frag);
-                    if (2 /* Overrides */ === featureMode) {
-                        addFeatureSymbology(builderTrans, featureMode, 31 /* Linear */);
-                        addFeatureSymbology(builder, featureMode, 31 /* Linear */);
-                        this.addTranslucentShader(builderTrans, flags, gl);
-                    }
-                    else {
-                        this.addTranslucentShader(builderTrans, flags, gl);
-                        addFeatureSymbology(builder, featureMode, 0 /* None */);
+        for (const posType of positionTypes) {
+            for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
+                for (let iAnimate = 0 /* No */; iAnimate <= 1 /* Yes */; iAnimate++) {
+                    for (const featureMode of featureModes) {
+                        flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                        flags.isAnimated = iAnimate;
+                        const builder = createEdgeBuilder(type, flags.isInstanced, flags.isAnimated, posType);
+                        addUnlitMonochrome(builder.frag);
+                        // The translucent shaders do not need the element IDs.
+                        const builderTrans = createEdgeBuilder(type, flags.isInstanced, flags.isAnimated, posType);
+                        addUnlitMonochrome(builderTrans.frag);
+                        if (2 /* Overrides */ === featureMode) {
+                            addFeatureSymbology(builderTrans, featureMode, 31 /* Linear */);
+                            addFeatureSymbology(builder, featureMode, 31 /* Linear */);
+                            this.addTranslucentShader(builderTrans, flags, gl);
+                        }
+                        else {
+                            this.addTranslucentShader(builderTrans, flags, gl);
+                            addFeatureSymbology(builder, featureMode, 0 /* None */);
+                        }
+                        this.addFeatureId(builder, featureMode);
+                        flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                        flags.isAnimated = iAnimate;
+                        this.addShader(builder, flags, gl);
                     }
-                    this.addFeatureId(builder, featureMode);
-                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                    flags.isAnimated = iAnimate;
-                    this.addShader(builder, flags, gl);
                 }
             }
         }
@@ -407,6 +427,8 @@ class EdgeTechnique extends VariedTechnique {
             index += EdgeTechnique._kAnimated;
         if (flags.isInstanced)
             index += EdgeTechnique._kInstanced;
+        if ("unquantized" === flags.positionType)
+            index += EdgeTechnique._kUnquantized;
         return index;
     }
 }
@@ -415,45 +437,49 @@ EdgeTechnique._kTranslucent = 1;
 EdgeTechnique._kAnimated = 2;
 EdgeTechnique._kInstanced = 4;
 EdgeTechnique._kFeature = 8;
+EdgeTechnique._kUnquantized = numFeatureVariants(EdgeTechnique._kFeature);
 class PointStringTechnique extends VariedTechnique {
     constructor(gl) {
-        super((PointStringTechnique._kHilite + numHiliteVariants));
+        super(PointStringTechnique._kUnquantized * 2);
         const flags = scratchTechniqueFlags;
-        for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
-            this.addHiliteShader(gl, instanced, 0 /* No */, createPointStringHiliter);
-            for (const featureMode of featureModes) {
-                flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                const builder = createPointStringBuilder(instanced);
-                addUnlitMonochrome(builder.frag);
-                // The translucent shaders do not need the element IDs.
-                const builderTrans = createPointStringBuilder(instanced);
-                addUnlitMonochrome(builderTrans.frag);
-                if (2 /* Overrides */ === featureMode) {
-                    addFeatureSymbology(builderTrans, featureMode, 29 /* Point */);
-                    addFeatureSymbology(builder, featureMode, 29 /* Point */);
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                }
-                else {
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                    addFeatureSymbology(builder, featureMode, 0 /* None */);
+        for (const posType of positionTypes) {
+            for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
+                this.addHiliteShader(gl, instanced, 0 /* No */, posType, (inst, _class, pos) => createPointStringHiliter(inst, pos));
+                for (const featureMode of featureModes) {
+                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                    const builder = createPointStringBuilder(instanced, posType);
+                    addUnlitMonochrome(builder.frag);
+                    // The translucent shaders do not need the element IDs.
+                    const builderTrans = createPointStringBuilder(instanced, posType);
+                    addUnlitMonochrome(builderTrans.frag);
+                    if (2 /* Overrides */ === featureMode) {
+                        addFeatureSymbology(builderTrans, featureMode, 29 /* Point */);
+                        addFeatureSymbology(builder, featureMode, 29 /* Point */);
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                    }
+                    else {
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                        addFeatureSymbology(builder, featureMode, 0 /* None */);
+                    }
+                    this.addFeatureId(builder, featureMode);
+                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                    this.addShader(builder, flags, gl);
                 }
-                this.addFeatureId(builder, featureMode);
-                flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                this.addShader(builder, flags, gl);
             }
         }
         this.finishConstruction();
     }
     get _debugDescription() { return "PointString"; }
     computeShaderIndex(flags) {
+        const idxOffset = "quantized" === flags.positionType ? 0 : PointStringTechnique._kUnquantized;
         if (flags.isHilite) {
             assert(flags.hasFeatures);
-            return PointStringTechnique._kHilite + flags.isInstanced;
+            return PointStringTechnique._kHilite + flags.isInstanced + idxOffset;
         }
         let index = flags.isTranslucent ? PointStringTechnique._kTranslucent : PointStringTechnique._kOpaque;
         index += PointStringTechnique._kFeature * flags.featureMode;
         index += PointStringTechnique._kInstanced * flags.isInstanced;
-        return index;
+        return index + idxOffset;
     }
 }
 PointStringTechnique._kOpaque = 0;
@@ -461,6 +487,7 @@ PointStringTechnique._kTranslucent = 1;
 PointStringTechnique._kInstanced = 2;
 PointStringTechnique._kFeature = 4;
 PointStringTechnique._kHilite = numFeatureVariants(PointStringTechnique._kFeature);
+PointStringTechnique._kUnquantized = PointStringTechnique._kHilite + numHiliteVariants;
 class PointCloudTechnique extends VariedTechnique {
     constructor(gl) {
         super(PointCloudTechnique._kHilite + 2);
@@ -469,12 +496,12 @@ class PointCloudTechnique extends VariedTechnique {
             TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
         ];
         for (let iClassified = 0 /* No */; iClassified <= 1 /* Yes */; iClassified++) {
-            this.addHiliteShader(gl, 0 /* No */, iClassified, () => createPointCloudHiliter(iClassified));
+            this.addHiliteShader(gl, 0 /* No */, iClassified, "quantized", (_inst, classified) => createPointCloudHiliter(classified));
             const flags = scratchTechniqueFlags;
             for (let thematic = 0 /* No */; thematic <= 1 /* Yes */; thematic++) {
                 const pointCloudFeatureModes = [0 /* None */, 2 /* Overrides */];
                 for (const featureMode of pointCloudFeatureModes) {
-                    flags.reset(featureMode, 0 /* No */, 0 /* No */, thematic);
+                    flags.reset(featureMode, 0 /* No */, 0 /* No */, thematic, "quantized");
                     flags.isClassified = iClassified;
                     const builder = createPointCloudBuilder(flags.isClassified, featureMode, thematic);
                     if (2 /* Overrides */ === featureMode) {
@@ -495,6 +522,7 @@ class PointCloudTechnique extends VariedTechnique {
     }
     get _debugDescription() { return "PointCloud"; }
     computeShaderIndex(flags) {
+        assert(flags.positionType === "quantized", "Unquantized point cloud positions not currently supported");
         if (flags.isHilite)
             return PointCloudTechnique._kHilite + flags.isClassified;
         else {
@@ -517,8 +545,8 @@ class RealityMeshTechnique extends VariedTechnique {
             TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
             TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
         ];
-        this.addHiliteShader(gl, 0 /* No */, 0 /* No */, createRealityMeshHiliter);
-        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, createClassifierRealityMeshHiliter);
+        this.addHiliteShader(gl, 0 /* No */, 0 /* No */, "quantized", createRealityMeshHiliter);
+        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, "quantized", createClassifierRealityMeshHiliter);
         for (let iClassified = 0 /* No */; iClassified <= 1 /* Yes */; iClassified++) {
             for (let iTranslucent = 0; iTranslucent <= 1; iTranslucent++) {
                 for (let shadowable = 0 /* No */; shadowable <= 1 /* Yes */; shadowable++) {
@@ -526,7 +554,7 @@ class RealityMeshTechnique extends VariedTechnique {
                         for (let wiremesh = 0 /* No */; wiremesh <= 1 /* Yes */; wiremesh++) {
                             const flags = scratchTechniqueFlags;
                             for (const featureMode of featureModes) {
-                                flags.reset(featureMode, 0 /* No */, shadowable, thematic);
+                                flags.reset(featureMode, 0 /* No */, shadowable, thematic, "quantized");
                                 flags.isClassified = iClassified;
                                 flags.isWiremesh = wiremesh;
                                 flags.isTranslucent = 1 === iTranslucent;
@@ -548,6 +576,7 @@ class RealityMeshTechnique extends VariedTechnique {
     }
     get _debugDescription() { return "RealityMesh"; }
     computeShaderIndex(flags) {
+        assert("quantized" === flags.positionType, "Unquantized reality mesh positions not currently supported.");
         if (flags.isHilite)
             return flags.isClassified ? 1 : 0;
         let ndx = 2;
@@ -607,11 +636,12 @@ const techniquesByPriority = [
     { techniqueId: 25 /* SkySphereTexture */ },
     { techniqueId: 26 /* AmbientOcclusion */ },
     { techniqueId: 27 /* Blur */ },
-    { techniqueId: 28 /* CombineTextures */ },
-    { techniqueId: 30 /* VolClassCopyZ */ },
-    { techniqueId: 31 /* VolClassSetBlend */ },
-    { techniqueId: 32 /* VolClassBlend */ },
-    { techniqueId: 29 /* Combine3Textures */ },
+    { techniqueId: 28 /* BlurTestOrder */ },
+    { techniqueId: 29 /* CombineTextures */ },
+    { techniqueId: 31 /* VolClassCopyZ */ },
+    { techniqueId: 32 /* VolClassSetBlend */ },
+    { techniqueId: 33 /* VolClassBlend */ },
+    { techniqueId: 30 /* Combine3Textures */ },
     { techniqueId: 8 /* PlanarGrid */ },
 ];
 const numTechniquesByPriority = techniquesByPriority.length;
@@ -643,11 +673,11 @@ export class Techniques {
             return id;
         this._dynamicTechniqueIds.push(name);
         this._list.push(technique);
-        return 33 /* NumBuiltIn */ + this._dynamicTechniqueIds.length - 1;
+        return 34 /* NumBuiltIn */ + this._dynamicTechniqueIds.length - 1;
     }
     getDynamicTechniqueId(name) {
         const index = this._dynamicTechniqueIds.indexOf(name);
-        return -1 !== index ? index + 33 /* NumBuiltIn */ + index : undefined;
+        return -1 !== index ? index + 34 /* NumBuiltIn */ + index : undefined;
     }
     /** Execute each command in the list */
     execute(target, commands, renderPass) {
@@ -704,7 +734,7 @@ export class Techniques {
             const tech = this._list[pTech.techniqueId];
             if (pTech.specificShader !== undefined) { // if this entry consists of a specific shader, just compile that
                 const flags = scratchTechniqueFlags;
-                flags.reset(pTech.specificShader.featureMode, pTech.specificShader.isInstanced, pTech.specificShader.isShadowable, 0 /* No */);
+                flags.reset(pTech.specificShader.featureMode, pTech.specificShader.isInstanced, pTech.specificShader.isShadowable, 0 /* No */, "quantized");
                 flags.isEdgeTestNeeded = pTech.specificShader.isEdgeTestedNeeded;
                 flags.isTranslucent = pTech.specificShader.isTranslucent;
                 shader = tech.getShader(flags);
@@ -744,9 +774,10 @@ export class Techniques {
         this._list[24 /* SkySphereGradient */] = new SingularTechnique(createSkySphereProgram(gl, true));
         this._list[25 /* SkySphereTexture */] = new SingularTechnique(createSkySphereProgram(gl, false));
         this._list[26 /* AmbientOcclusion */] = new SingularTechnique(createAmbientOcclusionProgram(gl));
-        this._list[27 /* Blur */] = new SingularTechnique(createBlurProgram(gl));
-        this._list[28 /* CombineTextures */] = new SingularTechnique(createCombineTexturesProgram(gl));
-        this._list[29 /* Combine3Textures */] = new SingularTechnique(createCombine3TexturesProgram(gl));
+        this._list[27 /* Blur */] = new SingularTechnique(createBlurProgram(gl, BlurType.NoTest));
+        this._list[28 /* BlurTestOrder */] = new SingularTechnique(createBlurProgram(gl, BlurType.TestOrder));
+        this._list[29 /* CombineTextures */] = new SingularTechnique(createCombineTexturesProgram(gl));
+        this._list[30 /* Combine3Textures */] = new SingularTechnique(createCombine3TexturesProgram(gl));
         this._list[0 /* Surface */] = new SurfaceTechnique(gl);
         this._list[4 /* Edge */] = new EdgeTechnique(gl, "SegmentEdge");
         this._list[5 /* SilhouetteEdge */] = new EdgeTechnique(gl, "Silhouette");
@@ -760,17 +791,17 @@ export class Techniques {
         else
             this._list[6 /* IndexedEdge */] = unsupportedTechnique;
         if (System.instance.capabilities.supportsFragDepth)
-            this._list[30 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZProgram(gl));
+            this._list[31 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZProgram(gl));
         else
-            this._list[30 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZUsingPointsProgram(gl));
-        this._list[31 /* VolClassSetBlend */] = new SingularTechnique(createVolClassSetBlendProgram(gl));
-        this._list[32 /* VolClassBlend */] = new SingularTechnique(createVolClassBlendProgram(gl));
+            this._list[31 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZUsingPointsProgram(gl));
+        this._list[32 /* VolClassSetBlend */] = new SingularTechnique(createVolClassSetBlendProgram(gl));
+        this._list[33 /* VolClassBlend */] = new SingularTechnique(createVolClassBlendProgram(gl));
         this._list[20 /* VolClassColorUsingStencil */] = new SingularTechnique(createVolClassColorUsingStencilProgram(gl));
         for (let compositeFlags = 1; compositeFlags <= 7; compositeFlags++) {
             const techId = computeCompositeTechniqueId(compositeFlags);
             this._list[techId] = new SingularTechnique(createCompositeProgram(compositeFlags, gl));
         }
-        assert(this._list.length === 33 /* NumBuiltIn */, "unexpected number of built-in techniques");
+        assert(this._list.length === 34 /* NumBuiltIn */, "unexpected number of built-in techniques");
     }
 }
 //# sourceMappingURL=Technique.js.map