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

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

@@ -38,6 +38,17 @@ import { ShaderProgramExecutor } from "./ShaderProgram";
 import { System } from "./System";
 import { TechniqueFlags, } from "./TechniqueFlags";
 import { computeCompositeTechniqueId } from "./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
  */
@@ -199,60 +210,31 @@ class SurfaceTechnique extends VariedTechnique {
         // Plus 1 hilite shader = 19
         super(SurfaceTechnique._kClassified + 19);
         this._earlyZFlags = [
-            TechniqueFlags.fromDescription("Opaque"),
-            TechniqueFlags.fromDescription("Opaque-Animated"),
-            TechniqueFlags.fromDescription("Opaque-Animated-Shadowable"),
-            TechniqueFlags.fromDescription("Opaque-Hilite-Classified"),
             TechniqueFlags.fromDescription("Opaque-Hilite-Overrides"),
-            TechniqueFlags.fromDescription("Opaque-Instanced"),
-            TechniqueFlags.fromDescription("Opaque-Instanced-Animated"),
-            TechniqueFlags.fromDescription("Opaque-Instanced-Animated-Shadowable"),
             TechniqueFlags.fromDescription("Opaque-Instanced-Hilite-Overrides"),
-            TechniqueFlags.fromDescription("Opaque-Instanced-Shadowable"),
-            TechniqueFlags.fromDescription("Opaque-Shadowable"),
-            TechniqueFlags.fromDescription("Translucent"),
-            TechniqueFlags.fromDescription("Translucent-Animated"),
-            TechniqueFlags.fromDescription("Translucent-Animated-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Animated-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Animated-Shadowable"),
-            TechniqueFlags.fromDescription("Translucent-Animated-Shadowable-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Animated-Shadowable-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Instanced"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Animated"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Shadowable"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Shadowable-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Animated-Shadowable-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Shadowable"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Shadowable-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Instanced-Shadowable-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Pick"),
-            TechniqueFlags.fromDescription("Translucent-Shadowable"),
-            TechniqueFlags.fromDescription("Translucent-Shadowable-Overrides"),
-            TechniqueFlags.fromDescription("Translucent-Shadowable-Pick"),
+            TechniqueFlags.fromDescription("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 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 = 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 = createSurfaceBuilder(flags);
+                                            this.addShader(builder, flags, gl);
+                                        }
                                     }
                                 }
                             }
@@ -313,6 +295,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
@@ -324,9 +307,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.
@@ -383,19 +367,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 = createEdgeBuilder(isSilhouette, flags.isInstanced, flags.isAnimated);
+                    const builder = createEdgeBuilder(type, flags.isInstanced, flags.isAnimated);
                     addUnlitMonochrome(builder.frag);
                     // The translucent shaders do not need the element IDs.
-                    const builderTrans = createEdgeBuilder(isSilhouette, flags.isInstanced, flags.isAnimated);
+                    const builderTrans = createEdgeBuilder(type, flags.isInstanced, flags.isAnimated);
                     addUnlitMonochrome(builderTrans.frag);
                     if (2 /* Overrides */ === featureMode) {
                         addFeatureSymbology(builderTrans, featureMode, 31 /* Linear */);
@@ -415,7 +399,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;
@@ -500,7 +484,7 @@ class PointCloudTechnique extends VariedTechnique {
                                 uniform.setUniform1f(params.geometry.asPointCloud.overrideColorMix);
                             });
                         });
-                        builder.vert.set(6 /* ApplyFeatureColor */, mixFeatureColor);
+                        builder.vert.set(7 /* ApplyFeatureColor */, mixFeatureColor);
                     }
                     this.addFeatureId(builder, featureMode);
                     this.addShader(builder, flags, gl);
@@ -539,19 +523,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 = createRealityMeshBuilder(flags);
-                            if (flags.isTranslucent) {
-                                addShaderFlags(builder);
-                                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 = createRealityMeshBuilder(flags);
+                                if (flags.isTranslucent) {
+                                    addShaderFlags(builder);
+                                    addTranslucency(builder);
+                                }
+                                else
+                                    this.addFeatureId(builder, featureMode);
+                                this.addShader(builder, flags, gl);
                             }
-                            else
-                                this.addFeatureId(builder, featureMode);
-                            this.addShader(builder, flags, gl);
                         }
                     }
                 }
@@ -573,10 +560,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 } },
@@ -597,33 +586,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.
@@ -654,11 +643,11 @@ export 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) {
@@ -745,39 +734,43 @@ export class Techniques {
                 technique.forEachProgram(func);
     }
     initializeBuiltIns(gl) {
-        this._list[15 /* OITClearTranslucent */] = new SingularTechnique(createClearTranslucentProgram(gl));
-        this._list[20 /* ClearPickAndColor */] = new SingularTechnique(createClearPickAndColorProgram(gl));
-        this._list[17 /* CopyColor */] = new SingularTechnique(createCopyColorProgram(gl));
-        this._list[18 /* CopyColorNoAlpha */] = new SingularTechnique(createCopyColorProgram(gl, false));
-        this._list[16 /* CopyPickBuffers */] = new SingularTechnique(createCopyPickBuffersProgram(gl));
-        this._list[21 /* EVSMFromDepth */] = new SingularTechnique(createEVSMProgram(gl));
-        this._list[22 /* SkyBox */] = new SingularTechnique(createSkyBoxProgram(gl));
-        this._list[23 /* SkySphereGradient */] = new SingularTechnique(createSkySphereProgram(gl, true));
-        this._list[24 /* SkySphereTexture */] = new SingularTechnique(createSkySphereProgram(gl, false));
-        this._list[25 /* AmbientOcclusion */] = new SingularTechnique(createAmbientOcclusionProgram(gl));
-        this._list[26 /* Blur */] = new SingularTechnique(createBlurProgram(gl));
-        this._list[27 /* CombineTextures */] = new SingularTechnique(createCombineTexturesProgram(gl));
-        this._list[28 /* Combine3Textures */] = new SingularTechnique(createCombine3TexturesProgram(gl));
+        this._list[16 /* OITClearTranslucent */] = new SingularTechnique(createClearTranslucentProgram(gl));
+        this._list[21 /* ClearPickAndColor */] = new SingularTechnique(createClearPickAndColorProgram(gl));
+        this._list[18 /* CopyColor */] = new SingularTechnique(createCopyColorProgram(gl));
+        this._list[19 /* CopyColorNoAlpha */] = new SingularTechnique(createCopyColorProgram(gl, false));
+        this._list[17 /* CopyPickBuffers */] = new SingularTechnique(createCopyPickBuffersProgram(gl));
+        this._list[22 /* EVSMFromDepth */] = new SingularTechnique(createEVSMProgram(gl));
+        this._list[23 /* SkyBox */] = new SingularTechnique(createSkyBoxProgram(gl));
+        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[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(createPlanarGridProgram(gl));
+        this._list[7 /* RealityMesh */] = new RealityMeshTechnique(gl);
+        this._list[8 /* PlanarGrid */] = new SingularTechnique(createPlanarGridProgram(gl));
+        if (System.instance.supportsIndexedEdges)
+            this._list[6 /* IndexedEdge */] = new EdgeTechnique(gl, "IndexedEdge");
+        else
+            this._list[6 /* IndexedEdge */] = unsupportedTechnique;
         if (System.instance.capabilities.supportsFragDepth)
-            this._list[29 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZProgram(gl));
+            this._list[30 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZProgram(gl));
         else
-            this._list[29 /* VolClassCopyZ */] = new SingularTechnique(createVolClassCopyZUsingPointsProgram(gl));
-        this._list[30 /* VolClassSetBlend */] = new SingularTechnique(createVolClassSetBlendProgram(gl));
-        this._list[31 /* VolClassBlend */] = new SingularTechnique(createVolClassBlendProgram(gl));
-        this._list[19 /* VolClassColorUsingStencil */] = new SingularTechnique(createVolClassColorUsingStencilProgram(gl));
+            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[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 === 32 /* NumBuiltIn */, "unexpected number of built-in techniques");
+        assert(this._list.length === 33 /* NumBuiltIn */, "unexpected number of built-in techniques");
     }
 }
 //# sourceMappingURL=Technique.js.map