@itwin/core-frontend 3.0.0-dev.98 → 3.0.0

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

@@ -63,6 +63,17 @@ const ShaderProgram_1 = require("./ShaderProgram");
 const System_1 = require("./System");
 const TechniqueFlags_1 = require("./TechniqueFlags");
 const TechniqueId_1 = require("./TechniqueId");
+/* Placeholder technique used for techniques not supported by particular client.
+ * e.g., IndexedEdgeTechnique only supported on WebGL 2.
+ */
+const unsupportedTechnique = {
+    getShader: () => { throw new Error("Unsupported technique"); },
+    getShaderByIndex: () => { throw new Error("Unsupported technique"); },
+    getShaderCount: () => 0,
+    compileShaders: () => true,
+    isDisposed: true,
+    dispose: () => undefined,
+};
 /** A rendering technique implemented using a single shader program, typically for some specialized purpose.
  * @internal
  */
@@ -226,60 +237,31 @@ class SurfaceTechnique extends VariedTechnique {
         // Plus 1 hilite shader = 19
         super(SurfaceTechnique._kClassified + 19);
         this._earlyZFlags = [
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Animated"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Animated-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced-Animated"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced-Animated-Shadowable"),
             TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced-Hilite-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Instanced-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Opaque-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Animated"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Animated-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Animated-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Animated-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Animated-Shadowable-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Animated-Shadowable-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Animated"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Shadowable-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Shadowable-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Shadowable-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Instanced-Shadowable-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Pick"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Shadowable"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Shadowable-Overrides"),
-            TechniqueFlags_1.TechniqueFlags.fromDescription("Translucent-Shadowable-Pick"),
+            TechniqueFlags_1.TechniqueFlags.fromDescription("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 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;
-                                        const builder = (0, Surface_1.createSurfaceBuilder)(flags);
-                                        this.addShader(builder, flags, gl);
+                    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);
+                                        }
                                     }
                                 }
                             }
@@ -340,6 +322,7 @@ class SurfaceTechnique extends VariedTechnique {
         index += SurfaceTechnique._kAnimated * flags.isAnimated;
         index += SurfaceTechnique._kShadowable * flags.isShadowable;
         index += SurfaceTechnique._kThematic * flags.isThematic;
+        index += SurfaceTechnique._kWiremesh * flags.isWiremesh;
         if (flags.isEdgeTestNeeded)
             index += SurfaceTechnique._kEdgeTestNeeded + (flags.featureMode - 1) * SurfaceTechnique._kFeature;
         else
@@ -351,9 +334,10 @@ SurfaceTechnique._kOpaque = 0;
 SurfaceTechnique._kTranslucent = 1;
 SurfaceTechnique._kInstanced = 2;
 SurfaceTechnique._kAnimated = 4;
-SurfaceTechnique._kShadowable = 8;
-SurfaceTechnique._kThematic = 16;
-SurfaceTechnique._kFeature = 24;
+SurfaceTechnique._kWiremesh = 8;
+SurfaceTechnique._kShadowable = 16;
+SurfaceTechnique._kThematic = 32;
+SurfaceTechnique._kFeature = 48;
 SurfaceTechnique._kEdgeTestNeeded = SurfaceTechnique._kFeature * 3; // only when hasFeatures
 SurfaceTechnique._kHilite = SurfaceTechnique._kEdgeTestNeeded + SurfaceTechnique._kFeature * 2;
 // Classifiers are never animated or instanced. They do support shadows, thematic display, and translucency.
@@ -410,19 +394,19 @@ PolylineTechnique._kInstanced = 2;
 PolylineTechnique._kFeature = 4;
 PolylineTechnique._kHilite = numFeatureVariants(PolylineTechnique._kFeature);
 class EdgeTechnique extends VariedTechnique {
-    constructor(gl, isSilhouette = false) {
+    constructor(gl, type) {
         super(numFeatureVariants(EdgeTechnique._kFeature));
-        this._isSilhouette = isSilhouette;
+        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)(isSilhouette, flags.isInstanced, flags.isAnimated);
+                    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)(isSilhouette, flags.isInstanced, flags.isAnimated);
+                    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 */);
@@ -442,7 +426,7 @@ class EdgeTechnique extends VariedTechnique {
         }
         this.finishConstruction();
     }
-    get _debugDescription() { return this._isSilhouette ? "Silhouette" : "Edge"; }
+    get _debugDescription() { return this._type; }
     computeShaderIndex(flags) {
         let index = flags.isTranslucent ? EdgeTechnique._kTranslucent : EdgeTechnique._kOpaque;
         index += EdgeTechnique._kFeature * flags.featureMode;
@@ -527,7 +511,7 @@ class PointCloudTechnique extends VariedTechnique {
                                 uniform.setUniform1f(params.geometry.asPointCloud.overrideColorMix);
                             });
                         });
-                        builder.vert.set(6 /* ApplyFeatureColor */, FeatureSymbology_1.mixFeatureColor);
+                        builder.vert.set(7 /* ApplyFeatureColor */, FeatureSymbology_1.mixFeatureColor);
                     }
                     this.addFeatureId(builder, featureMode);
                     this.addShader(builder, flags, gl);
@@ -566,19 +550,22 @@ class RealityMeshTechnique extends VariedTechnique {
             for (let iTranslucent = 0; iTranslucent <= 1; iTranslucent++) {
                 for (let shadowable = 0 /* No */; shadowable <= 1 /* Yes */; shadowable++) {
                     for (let thematic = 0 /* No */; thematic <= 1 /* Yes */; thematic++) {
-                        const flags = scratchTechniqueFlags;
-                        for (const featureMode of featureModes) {
-                            flags.reset(featureMode, 0 /* No */, shadowable, thematic);
-                            flags.isClassified = iClassified;
-                            flags.isTranslucent = 1 === iTranslucent;
-                            const builder = (0, RealityMesh_1.default)(flags);
-                            if (flags.isTranslucent) {
-                                (0, Common_1.addShaderFlags)(builder);
-                                (0, Translucency_1.addTranslucency)(builder);
+                        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.isClassified = iClassified;
+                                flags.isWiremesh = wiremesh;
+                                flags.isTranslucent = 1 === iTranslucent;
+                                const builder = (0, RealityMesh_1.default)(flags);
+                                if (flags.isTranslucent) {
+                                    (0, Common_1.addShaderFlags)(builder);
+                                    (0, Translucency_1.addTranslucency)(builder);
+                                }
+                                else
+                                    this.addFeatureId(builder, featureMode);
+                                this.addShader(builder, flags, gl);
                             }
-                            else
-                                this.addFeatureId(builder, featureMode);
-                            this.addShader(builder, flags, gl);
                         }
                     }
                 }
@@ -600,10 +587,12 @@ class RealityMeshTechnique extends VariedTechnique {
         ndx += 8 * flags.featureMode;
         if (flags.isThematic)
             ndx += 24;
+        if (flags.isWiremesh)
+            ndx += 48;
         return ndx;
     }
 }
-RealityMeshTechnique._numVariants = 50;
+RealityMeshTechnique._numVariants = 98;
 const techniquesByPriority = [
     // Compile these specific shader variations first because they seem most likely to be used immediately upon opening a file.
     { techniqueId: 0 /* Surface */, specificShader: { featureMode: 0 /* None */, isInstanced: 0 /* No */, isShadowable: 0 /* No */, isEdgeTestedNeeded: 0 /* No */, isTranslucent: false } },
@@ -624,33 +613,33 @@ const techniquesByPriority = [
     { techniqueId: 1 /* Polyline */ },
     { techniqueId: 3 /* PointString */ },
     { techniqueId: 2 /* PointCloud */ },
-    { techniqueId: 6 /* RealityMesh */ },
+    { techniqueId: 7 /* RealityMesh */ },
     // The following techniques take a trivial amount of time to compile - do them last
-    { techniqueId: 15 /* OITClearTranslucent */ },
-    { techniqueId: 16 /* CopyPickBuffers */ },
-    { techniqueId: 17 /* CopyColor */ },
-    { techniqueId: 18 /* CopyColorNoAlpha */ },
-    { techniqueId: 20 /* ClearPickAndColor */ },
-    { techniqueId: 9 /* CompositeTranslucent */ },
-    { techniqueId: 8 /* CompositeHilite */ },
-    { techniqueId: 10 /* CompositeHiliteAndTranslucent */ },
-    { techniqueId: 11 /* CompositeOcclusion */ },
-    { techniqueId: 12 /* CompositeTranslucentAndOcclusion */ },
-    { techniqueId: 13 /* CompositeHiliteAndOcclusion */ },
-    { techniqueId: 14 /* CompositeAll */ },
-    { techniqueId: 19 /* VolClassColorUsingStencil */ },
-    { techniqueId: 21 /* EVSMFromDepth */ },
-    { techniqueId: 22 /* SkyBox */ },
-    { techniqueId: 23 /* SkySphereGradient */ },
-    { techniqueId: 24 /* SkySphereTexture */ },
-    { techniqueId: 25 /* AmbientOcclusion */ },
-    { techniqueId: 26 /* Blur */ },
-    { techniqueId: 27 /* CombineTextures */ },
-    { techniqueId: 29 /* VolClassCopyZ */ },
-    { techniqueId: 30 /* VolClassSetBlend */ },
-    { techniqueId: 31 /* VolClassBlend */ },
-    { techniqueId: 28 /* Combine3Textures */ },
-    { techniqueId: 7 /* PlanarGrid */ },
+    { techniqueId: 16 /* OITClearTranslucent */ },
+    { techniqueId: 17 /* CopyPickBuffers */ },
+    { techniqueId: 18 /* CopyColor */ },
+    { techniqueId: 19 /* CopyColorNoAlpha */ },
+    { techniqueId: 21 /* ClearPickAndColor */ },
+    { techniqueId: 10 /* CompositeTranslucent */ },
+    { techniqueId: 9 /* CompositeHilite */ },
+    { techniqueId: 11 /* CompositeHiliteAndTranslucent */ },
+    { techniqueId: 12 /* CompositeOcclusion */ },
+    { techniqueId: 13 /* CompositeTranslucentAndOcclusion */ },
+    { techniqueId: 14 /* CompositeHiliteAndOcclusion */ },
+    { techniqueId: 15 /* CompositeAll */ },
+    { techniqueId: 20 /* VolClassColorUsingStencil */ },
+    { techniqueId: 22 /* EVSMFromDepth */ },
+    { techniqueId: 23 /* SkyBox */ },
+    { techniqueId: 24 /* SkySphereGradient */ },
+    { 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: 8 /* PlanarGrid */ },
 ];
 const numTechniquesByPriority = techniquesByPriority.length;
 /** A collection of rendering techniques accessed by ID.
@@ -681,11 +670,11 @@ class Techniques {
             return id;
         this._dynamicTechniqueIds.push(name);
         this._list.push(technique);
-        return 32 /* NumBuiltIn */ + this._dynamicTechniqueIds.length - 1;
+        return 33 /* NumBuiltIn */ + this._dynamicTechniqueIds.length - 1;
     }
     getDynamicTechniqueId(name) {
         const index = this._dynamicTechniqueIds.indexOf(name);
-        return -1 !== index ? index + 32 /* NumBuiltIn */ + index : undefined;
+        return -1 !== index ? index + 33 /* NumBuiltIn */ + index : undefined;
     }
     /** Execute each command in the list */
     execute(target, commands, renderPass) {
@@ -772,39 +761,43 @@ class Techniques {
                 technique.forEachProgram(func);
     }
     initializeBuiltIns(gl) {
-        this._list[15 /* OITClearTranslucent */] = new SingularTechnique((0, ClearTranslucent_1.createClearTranslucentProgram)(gl));
-        this._list[20 /* ClearPickAndColor */] = new SingularTechnique((0, ClearPickAndColor_1.createClearPickAndColorProgram)(gl));
-        this._list[17 /* CopyColor */] = new SingularTechnique((0, CopyColor_1.createCopyColorProgram)(gl));
-        this._list[18 /* CopyColorNoAlpha */] = new SingularTechnique((0, CopyColor_1.createCopyColorProgram)(gl, false));
-        this._list[16 /* CopyPickBuffers */] = new SingularTechnique((0, CopyPickBuffers_1.createCopyPickBuffersProgram)(gl));
-        this._list[21 /* EVSMFromDepth */] = new SingularTechnique((0, EVSMFromDepth_1.createEVSMProgram)(gl));
-        this._list[22 /* SkyBox */] = new SingularTechnique((0, SkyBox_1.createSkyBoxProgram)(gl));
-        this._list[23 /* SkySphereGradient */] = new SingularTechnique((0, SkySphere_1.createSkySphereProgram)(gl, true));
-        this._list[24 /* SkySphereTexture */] = new SingularTechnique((0, SkySphere_1.createSkySphereProgram)(gl, false));
-        this._list[25 /* AmbientOcclusion */] = new SingularTechnique((0, AmbientOcclusion_1.createAmbientOcclusionProgram)(gl));
-        this._list[26 /* Blur */] = new SingularTechnique((0, Blur_1.createBlurProgram)(gl));
-        this._list[27 /* CombineTextures */] = new SingularTechnique((0, CombineTextures_1.createCombineTexturesProgram)(gl));
-        this._list[28 /* Combine3Textures */] = new SingularTechnique((0, Combine3Textures_1.createCombine3TexturesProgram)(gl));
+        this._list[16 /* OITClearTranslucent */] = new SingularTechnique((0, ClearTranslucent_1.createClearTranslucentProgram)(gl));
+        this._list[21 /* ClearPickAndColor */] = new SingularTechnique((0, ClearPickAndColor_1.createClearPickAndColorProgram)(gl));
+        this._list[18 /* CopyColor */] = new SingularTechnique((0, CopyColor_1.createCopyColorProgram)(gl));
+        this._list[19 /* CopyColorNoAlpha */] = new SingularTechnique((0, CopyColor_1.createCopyColorProgram)(gl, false));
+        this._list[17 /* CopyPickBuffers */] = new SingularTechnique((0, CopyPickBuffers_1.createCopyPickBuffersProgram)(gl));
+        this._list[22 /* EVSMFromDepth */] = new SingularTechnique((0, EVSMFromDepth_1.createEVSMProgram)(gl));
+        this._list[23 /* SkyBox */] = new SingularTechnique((0, SkyBox_1.createSkyBoxProgram)(gl));
+        this._list[24 /* SkySphereGradient */] = new SingularTechnique((0, SkySphere_1.createSkySphereProgram)(gl, true));
+        this._list[25 /* SkySphereTexture */] = new SingularTechnique((0, SkySphere_1.createSkySphereProgram)(gl, false));
+        this._list[26 /* AmbientOcclusion */] = new SingularTechnique((0, AmbientOcclusion_1.createAmbientOcclusionProgram)(gl));
+        this._list[27 /* Blur */] = new SingularTechnique((0, Blur_1.createBlurProgram)(gl));
+        this._list[28 /* CombineTextures */] = new SingularTechnique((0, CombineTextures_1.createCombineTexturesProgram)(gl));
+        this._list[29 /* Combine3Textures */] = new SingularTechnique((0, Combine3Textures_1.createCombine3TexturesProgram)(gl));
         this._list[0 /* Surface */] = new SurfaceTechnique(gl);
-        this._list[4 /* Edge */] = new EdgeTechnique(gl, false);
-        this._list[5 /* SilhouetteEdge */] = new EdgeTechnique(gl, true);
+        this._list[4 /* Edge */] = new EdgeTechnique(gl, "SegmentEdge");
+        this._list[5 /* SilhouetteEdge */] = new EdgeTechnique(gl, "Silhouette");
         this._list[1 /* Polyline */] = new PolylineTechnique(gl);
         this._list[3 /* PointString */] = new PointStringTechnique(gl);
         this._list[2 /* PointCloud */] = new PointCloudTechnique(gl);
-        this._list[6 /* RealityMesh */] = new RealityMeshTechnique(gl);
-        this._list[7 /* PlanarGrid */] = new SingularTechnique((0, PlanarGrid_1.default)(gl));
+        this._list[7 /* RealityMesh */] = new RealityMeshTechnique(gl);
+        this._list[8 /* PlanarGrid */] = new SingularTechnique((0, PlanarGrid_1.default)(gl));
+        if (System_1.System.instance.supportsIndexedEdges)
+            this._list[6 /* IndexedEdge */] = new EdgeTechnique(gl, "IndexedEdge");
+        else
+            this._list[6 /* IndexedEdge */] = unsupportedTechnique;
         if (System_1.System.instance.capabilities.supportsFragDepth)
-            this._list[29 /* VolClassCopyZ */] = new SingularTechnique((0, CopyStencil_1.createVolClassCopyZProgram)(gl));
+            this._list[30 /* VolClassCopyZ */] = new SingularTechnique((0, CopyStencil_1.createVolClassCopyZProgram)(gl));
         else
-            this._list[29 /* VolClassCopyZ */] = new SingularTechnique((0, CopyStencil_1.createVolClassCopyZUsingPointsProgram)(gl));
-        this._list[30 /* VolClassSetBlend */] = new SingularTechnique((0, CopyStencil_1.createVolClassSetBlendProgram)(gl));
-        this._list[31 /* VolClassBlend */] = new SingularTechnique((0, CopyStencil_1.createVolClassBlendProgram)(gl));
-        this._list[19 /* VolClassColorUsingStencil */] = new SingularTechnique((0, CopyStencil_1.createVolClassColorUsingStencilProgram)(gl));
+            this._list[30 /* VolClassCopyZ */] = new SingularTechnique((0, CopyStencil_1.createVolClassCopyZUsingPointsProgram)(gl));
+        this._list[31 /* VolClassSetBlend */] = new SingularTechnique((0, CopyStencil_1.createVolClassSetBlendProgram)(gl));
+        this._list[32 /* VolClassBlend */] = new SingularTechnique((0, CopyStencil_1.createVolClassBlendProgram)(gl));
+        this._list[20 /* VolClassColorUsingStencil */] = new SingularTechnique((0, CopyStencil_1.createVolClassColorUsingStencilProgram)(gl));
         for (let compositeFlags = 1; compositeFlags <= 7; compositeFlags++) {
             const techId = (0, TechniqueId_1.computeCompositeTechniqueId)(compositeFlags);
             this._list[techId] = new SingularTechnique((0, Composite_1.createCompositeProgram)(compositeFlags, gl));
         }
-        (0, core_bentley_1.assert)(this._list.length === 32 /* NumBuiltIn */, "unexpected number of built-in techniques");
+        (0, core_bentley_1.assert)(this._list.length === 33 /* NumBuiltIn */, "unexpected number of built-in techniques");
     }
 }
 exports.Techniques = Techniques;