@itwin/core-frontend 3.2.0-dev.28 → 3.2.0-dev.30

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

@@ -166,9 +166,9 @@ class VariedTechnique {
         this._clippingPrograms[index] = (0, ClippingProgram_1.createClippingProgram)(builder);
         (0, core_bentley_1.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) {
@@ -229,38 +229,40 @@ class VariedTechnique {
     }
 }
 exports.VariedTechnique = 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_1.TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced-Hilite-Overrides"),
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
+            TechniqueFlags_1.TechniqueFlags.fromDescription("Unquantized-Opaque-Hilite-Overrides"),
+            TechniqueFlags_1.TechniqueFlags.fromDescription("Unquantized-Opaque-Instanced-Hilite-Overrides"),
+            TechniqueFlags_1.TechniqueFlags.fromDescription("Unquantized-Opaque-Hilite-Classified"),
         ];
         const flags = scratchTechniqueFlags;
-        for (let instanced = 0 /* No */; instanced <= 1 /* Yes */; instanced++) {
-            this.addHiliteShader(gl, instanced, 0 /* No */, Surface_1.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 = (0, Surface_1.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, Surface_1.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 = (0, Surface_1.createSurfaceBuilder)(flags);
+                                                this.addShader(builder, flags, gl);
+                                            }
                                         }
                                     }
                                 }
@@ -270,20 +272,23 @@ class SurfaceTechnique extends VariedTechnique {
                 }
             }
         }
-        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, Surface_1.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 = (0, Surface_1.createSurfaceBuilder)(flags);
-                        if (flags.isTranslucent)
-                            (0, Translucency_1.addTranslucency)(builder);
-                        this.addShader(builder, flags, gl);
+        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, "quantized", Surface_1.createSurfaceHiliter);
+        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, "unquantized", Surface_1.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 = (0, Surface_1.createSurfaceBuilder)(flags);
+                            if (flags.isTranslucent)
+                                (0, Translucency_1.addTranslucency)(builder);
+                            this.addShader(builder, flags, gl);
+                        }
                     }
                 }
             }
@@ -293,13 +298,14 @@ class SurfaceTechnique extends VariedTechnique {
     get _debugDescription() { return "Surface"; }
     computeShaderIndex(flags) {
         (0, core_bentley_1.assert)(!(flags.isThematic && flags.isShadowable));
+        const idxOffset = flags.positionType === "unquantized" ? SurfaceTechnique._kUnquantized : 0;
         if (flags.isClassified) {
             (0, core_bentley_1.assert)(!flags.isAnimated);
             (0, core_bentley_1.assert)(!flags.isInstanced);
             (0, core_bentley_1.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;
@@ -310,11 +316,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) {
             (0, core_bentley_1.assert)(flags.hasFeatures);
-            return SurfaceTechnique._kHilite + flags.isInstanced;
+            return SurfaceTechnique._kHilite + flags.isInstanced + idxOffset;
         }
         (0, core_bentley_1.assert)(flags.hasFeatures || flags.isEdgeTestNeeded === 0 /* No */);
         let index = flags.isTranslucent ? SurfaceTechnique._kTranslucent : SurfaceTechnique._kOpaque;
@@ -327,7 +333,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;
@@ -343,49 +349,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_1.TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced-Hilite-Overrides"),
+            TechniqueFlags_1.TechniqueFlags.fromDescription("Unquantized-Opaque-Hilite-Overrides"),
+            TechniqueFlags_1.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 */, Polyline_1.createPolylineHiliter);
-            for (const featureMode of featureModes) {
-                flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                const builder = (0, Polyline_1.createPolylineBuilder)(instanced);
-                (0, Monochrome_1.addUnlitMonochrome)(builder.frag);
-                // The translucent shaders do not need the element IDs.
-                const builderTrans = (0, Polyline_1.createPolylineBuilder)(instanced);
-                (0, Monochrome_1.addUnlitMonochrome)(builderTrans.frag);
-                if (2 /* Overrides */ === featureMode) {
-                    (0, FeatureSymbology_1.addFeatureSymbology)(builderTrans, featureMode, 31 /* Linear */);
-                    (0, FeatureSymbology_1.addFeatureSymbology)(builder, featureMode, 31 /* Linear */);
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                }
-                else {
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                    (0, FeatureSymbology_1.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) => (0, Polyline_1.createPolylineHiliter)(inst, pos));
+                for (const featureMode of featureModes) {
+                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                    const builder = (0, Polyline_1.createPolylineBuilder)(instanced, posType);
+                    (0, Monochrome_1.addUnlitMonochrome)(builder.frag);
+                    // The translucent shaders do not need the element IDs.
+                    const builderTrans = (0, Polyline_1.createPolylineBuilder)(instanced, posType);
+                    (0, Monochrome_1.addUnlitMonochrome)(builderTrans.frag);
+                    if (2 /* Overrides */ === featureMode) {
+                        (0, FeatureSymbology_1.addFeatureSymbology)(builderTrans, featureMode, 31 /* Linear */);
+                        (0, FeatureSymbology_1.addFeatureSymbology)(builder, featureMode, 31 /* Linear */);
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                    }
+                    else {
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                        (0, FeatureSymbology_1.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) {
             (0, core_bentley_1.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;
@@ -393,34 +409,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 = (0, Edge_1.createEdgeBuilder)(type, flags.isInstanced, flags.isAnimated);
-                    (0, Monochrome_1.addUnlitMonochrome)(builder.frag);
-                    // The translucent shaders do not need the element IDs.
-                    const builderTrans = (0, Edge_1.createEdgeBuilder)(type, flags.isInstanced, flags.isAnimated);
-                    (0, Monochrome_1.addUnlitMonochrome)(builderTrans.frag);
-                    if (2 /* Overrides */ === featureMode) {
-                        (0, FeatureSymbology_1.addFeatureSymbology)(builderTrans, featureMode, 31 /* Linear */);
-                        (0, FeatureSymbology_1.addFeatureSymbology)(builder, featureMode, 31 /* Linear */);
-                        this.addTranslucentShader(builderTrans, flags, gl);
-                    }
-                    else {
-                        this.addTranslucentShader(builderTrans, flags, gl);
-                        (0, FeatureSymbology_1.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 = (0, Edge_1.createEdgeBuilder)(type, flags.isInstanced, flags.isAnimated, posType);
+                        (0, Monochrome_1.addUnlitMonochrome)(builder.frag);
+                        // The translucent shaders do not need the element IDs.
+                        const builderTrans = (0, Edge_1.createEdgeBuilder)(type, flags.isInstanced, flags.isAnimated, posType);
+                        (0, Monochrome_1.addUnlitMonochrome)(builderTrans.frag);
+                        if (2 /* Overrides */ === featureMode) {
+                            (0, FeatureSymbology_1.addFeatureSymbology)(builderTrans, featureMode, 31 /* Linear */);
+                            (0, FeatureSymbology_1.addFeatureSymbology)(builder, featureMode, 31 /* Linear */);
+                            this.addTranslucentShader(builderTrans, flags, gl);
+                        }
+                        else {
+                            this.addTranslucentShader(builderTrans, flags, gl);
+                            (0, FeatureSymbology_1.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);
                 }
             }
         }
@@ -434,6 +453,8 @@ class EdgeTechnique extends VariedTechnique {
             index += EdgeTechnique._kAnimated;
         if (flags.isInstanced)
             index += EdgeTechnique._kInstanced;
+        if ("unquantized" === flags.positionType)
+            index += EdgeTechnique._kUnquantized;
         return index;
     }
 }
@@ -442,45 +463,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 */, PointString_1.createPointStringHiliter);
-            for (const featureMode of featureModes) {
-                flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */);
-                const builder = (0, PointString_1.createPointStringBuilder)(instanced);
-                (0, Monochrome_1.addUnlitMonochrome)(builder.frag);
-                // The translucent shaders do not need the element IDs.
-                const builderTrans = (0, PointString_1.createPointStringBuilder)(instanced);
-                (0, Monochrome_1.addUnlitMonochrome)(builderTrans.frag);
-                if (2 /* Overrides */ === featureMode) {
-                    (0, FeatureSymbology_1.addFeatureSymbology)(builderTrans, featureMode, 29 /* Point */);
-                    (0, FeatureSymbology_1.addFeatureSymbology)(builder, featureMode, 29 /* Point */);
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                }
-                else {
-                    this.addTranslucentShader(builderTrans, flags, gl);
-                    (0, FeatureSymbology_1.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) => (0, PointString_1.createPointStringHiliter)(inst, pos));
+                for (const featureMode of featureModes) {
+                    flags.reset(featureMode, instanced, 0 /* No */, 0 /* No */, posType);
+                    const builder = (0, PointString_1.createPointStringBuilder)(instanced, posType);
+                    (0, Monochrome_1.addUnlitMonochrome)(builder.frag);
+                    // The translucent shaders do not need the element IDs.
+                    const builderTrans = (0, PointString_1.createPointStringBuilder)(instanced, posType);
+                    (0, Monochrome_1.addUnlitMonochrome)(builderTrans.frag);
+                    if (2 /* Overrides */ === featureMode) {
+                        (0, FeatureSymbology_1.addFeatureSymbology)(builderTrans, featureMode, 29 /* Point */);
+                        (0, FeatureSymbology_1.addFeatureSymbology)(builder, featureMode, 29 /* Point */);
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                    }
+                    else {
+                        this.addTranslucentShader(builderTrans, flags, gl);
+                        (0, FeatureSymbology_1.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) {
             (0, core_bentley_1.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;
@@ -488,6 +513,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);
@@ -496,12 +522,12 @@ class PointCloudTechnique extends VariedTechnique {
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
         ];
         for (let iClassified = 0 /* No */; iClassified <= 1 /* Yes */; iClassified++) {
-            this.addHiliteShader(gl, 0 /* No */, iClassified, () => (0, PointCloud_1.createPointCloudHiliter)(iClassified));
+            this.addHiliteShader(gl, 0 /* No */, iClassified, "quantized", (_inst, classified) => (0, PointCloud_1.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 = (0, PointCloud_1.createPointCloudBuilder)(flags.isClassified, featureMode, thematic);
                     if (2 /* Overrides */ === featureMode) {
@@ -522,6 +548,7 @@ class PointCloudTechnique extends VariedTechnique {
     }
     get _debugDescription() { return "PointCloud"; }
     computeShaderIndex(flags) {
+        (0, core_bentley_1.assert)(flags.positionType === "quantized", "Unquantized point cloud positions not currently supported");
         if (flags.isHilite)
             return PointCloudTechnique._kHilite + flags.isClassified;
         else {
@@ -544,8 +571,8 @@ class RealityMeshTechnique extends VariedTechnique {
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
         ];
-        this.addHiliteShader(gl, 0 /* No */, 0 /* No */, RealityMesh_1.createRealityMeshHiliter);
-        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, RealityMesh_1.createClassifierRealityMeshHiliter);
+        this.addHiliteShader(gl, 0 /* No */, 0 /* No */, "quantized", RealityMesh_1.createRealityMeshHiliter);
+        this.addHiliteShader(gl, 0 /* No */, 1 /* Yes */, "quantized", RealityMesh_1.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++) {
@@ -553,7 +580,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;
@@ -575,6 +602,7 @@ class RealityMeshTechnique extends VariedTechnique {
     }
     get _debugDescription() { return "RealityMesh"; }
     computeShaderIndex(flags) {
+        (0, core_bentley_1.assert)("quantized" === flags.positionType, "Unquantized reality mesh positions not currently supported.");
         if (flags.isHilite)
             return flags.isClassified ? 1 : 0;
         let ndx = 2;
@@ -731,7 +759,7 @@ 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);