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

package/lib/esm/internal/render/webgl/SceneCompositor.js

@@ -42,6 +42,8 @@ class Textures {
     featureId;
     depthAndOrder;
     depthAndOrderHidden; // only used if AO and multisampling
+    contours;
+    contoursMsBuff;
     hilite;
     occlusion;
     occlusionBlur;
@@ -59,6 +61,8 @@ class Textures {
             && undefined === this.color
             && undefined === this.featureId
             && undefined === this.depthAndOrder
+            && undefined === this.contours
+            && undefined === this.contoursMsBuff
             && undefined === this.depthAndOrderHidden
             && undefined === this.hilite
             && undefined === this.occlusion
@@ -78,6 +82,8 @@ class Textures {
         this.color = dispose(this.color);
         this.featureId = dispose(this.featureId);
         this.depthAndOrder = dispose(this.depthAndOrder);
+        this.contours = dispose(this.contours);
+        this.contoursMsBuff = dispose(this.contoursMsBuff);
         this.depthAndOrderHidden = dispose(this.depthAndOrderHidden);
         this.hilite = dispose(this.hilite);
         this.occlusion = dispose(this.occlusion);
@@ -97,6 +103,8 @@ class Textures {
         collectTextureStatistics(this.color, stats);
         collectTextureStatistics(this.featureId, stats);
         collectTextureStatistics(this.depthAndOrder, stats);
+        collectTextureStatistics(this.contours, stats);
+        collectMsBufferStatistics(this.contoursMsBuff, stats);
         collectTextureStatistics(this.depthAndOrderHidden, stats);
         collectTextureStatistics(this.hilite, stats);
         collectTextureStatistics(this.occlusion, stats);
@@ -135,11 +143,13 @@ class Textures {
         this.color = TextureHandle.createForAttachment(width, height, GL.Texture.Format.Rgba, GL.Texture.DataType.UnsignedByte);
         this.featureId = TextureHandle.createForAttachment(width, height, GL.Texture.Format.Rgba, GL.Texture.DataType.UnsignedByte);
         this.depthAndOrder = TextureHandle.createForAttachment(width, height, GL.Texture.Format.Rgba, GL.Texture.DataType.UnsignedByte);
+        this.contours = TextureHandle.createForAttachment(width, height, GL.Texture.Format.Rgba, GL.Texture.DataType.UnsignedByte);
         let rVal = undefined !== this.accumulation
             && undefined !== this.revealage
             && undefined !== this.color
             && undefined !== this.featureId
             && undefined !== this.depthAndOrder
+            && undefined !== this.contours
             && undefined !== this.hilite;
         if (rVal && numSamples > 1) {
             rVal = this.enableMultiSampling(width, height, numSamples);
@@ -184,12 +194,14 @@ class Textures {
         this.featureIdMsBuffHidden = RenderBufferMultiSample.create(width, height, WebGL2RenderingContext.RGBA8, numSamples);
         this.depthAndOrderMsBuff = RenderBufferMultiSample.create(width, height, WebGL2RenderingContext.RGBA8, numSamples);
         this.depthAndOrderMsBuffHidden = RenderBufferMultiSample.create(width, height, WebGL2RenderingContext.RGBA8, numSamples);
+        this.contoursMsBuff = RenderBufferMultiSample.create(width, height, WebGL2RenderingContext.RGBA8, numSamples);
         this.hiliteMsBuff = RenderBufferMultiSample.create(width, height, WebGL2RenderingContext.RGBA8, numSamples);
         return undefined !== this.colorMsBuff
             && undefined !== this.featureIdMsBuff
             && undefined !== this.featureIdMsBuffHidden
             && undefined !== this.depthAndOrderMsBuff
             && undefined !== this.depthAndOrderMsBuffHidden
+            && undefined !== this.contoursMsBuff
             && undefined !== this.hiliteMsBuff;
     }
     disableMultiSampling() {
@@ -198,6 +210,7 @@ class Textures {
         this.featureIdMsBuffHidden = dispose(this.featureIdMsBuffHidden);
         this.depthAndOrderMsBuff = dispose(this.depthAndOrderMsBuff);
         this.depthAndOrderMsBuffHidden = dispose(this.depthAndOrderMsBuffHidden);
+        this.contoursMsBuff = dispose(this.contoursMsBuff);
         this.hiliteMsBuff = dispose(this.hiliteMsBuff);
         return true;
     }
@@ -207,6 +220,7 @@ class FrameBuffers {
     opaqueColor;
     opaqueAndCompositeColor;
     depthAndOrder;
+    contours;
     hilite;
     hiliteUsingStencil;
     stencilSet;
@@ -231,9 +245,10 @@ class FrameBuffers {
         if (!this.initPotentialMSFbos(textures, depth, depthMS))
             return false;
         this.depthAndOrder = FrameBuffer.create([textures.depthAndOrder], depth);
+        this.contours = FrameBuffer.create([textures.contours], depth);
         this.hilite = FrameBuffer.create([textures.hilite], depth);
         this.hiliteUsingStencil = FrameBuffer.create([textures.hilite], depth);
-        if (!this.depthAndOrder || !this.hilite || !this.hiliteUsingStencil)
+        if (!this.depthAndOrder || !this.contours || !this.hilite || !this.hiliteUsingStencil)
             return false;
         assert(undefined === this.opaqueAll);
         if (!this.initPotentialMSMRTFbos(textures, depth, depthMS))
@@ -270,17 +285,28 @@ class FrameBuffers {
     }
     initPotentialMSMRTFbos(textures, depth, depthMs) {
         const boundColor = System.instance.frameBufferStack.currentColorBuffer;
-        assert(undefined !== boundColor && undefined !== textures.color && undefined !== textures.featureId && undefined !== textures.depthAndOrder && undefined !== textures.accumulation && undefined !== textures.revealage);
-        const colorAndPick = [boundColor, textures.featureId, textures.depthAndOrder];
+        assert(undefined !== boundColor &&
+            undefined !== textures.color &&
+            undefined !== textures.featureId &&
+            undefined !== textures.depthAndOrder &&
+            undefined !== textures.contours &&
+            undefined !== textures.accumulation &&
+            undefined !== textures.revealage);
+        const colorAndPick = [boundColor, textures.featureId, textures.depthAndOrder, textures.contours];
         if (undefined === depthMs) {
             this.opaqueAll = FrameBuffer.create(colorAndPick, depth);
             colorAndPick[0] = textures.color;
             this.opaqueAndCompositeAll = FrameBuffer.create(colorAndPick, depth);
         }
         else {
-            assert(undefined !== textures.colorMsBuff && undefined !== textures.featureIdMsBuff && undefined !== textures.featureIdMsBuffHidden && undefined !== textures.depthAndOrderMsBuff && undefined !== textures.depthAndOrderMsBuffHidden);
-            const colorAndPickMsBuffs = [textures.colorMsBuff, textures.featureIdMsBuff, textures.depthAndOrderMsBuff];
-            const colorAndPickFilters = [GL.MultiSampling.Filter.Linear, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
+            assert(undefined !== textures.colorMsBuff &&
+                undefined !== textures.featureIdMsBuff &&
+                undefined !== textures.featureIdMsBuffHidden &&
+                undefined !== textures.contoursMsBuff &&
+                undefined !== textures.depthAndOrderMsBuff &&
+                undefined !== textures.depthAndOrderMsBuffHidden);
+            const colorAndPickMsBuffs = [textures.colorMsBuff, textures.featureIdMsBuff, textures.depthAndOrderMsBuff, textures.contoursMsBuff];
+            const colorAndPickFilters = [GL.MultiSampling.Filter.Linear, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
             this.opaqueAll = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
             colorAndPick[0] = textures.color;
             this.opaqueAndCompositeAll = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
@@ -389,7 +415,7 @@ class FrameBuffers {
         return this.initPotentialMSFbos(textures, depth, undefined);
     }
     get isDisposed() {
-        return undefined === this.opaqueColor && undefined === this.opaqueAndCompositeColor && undefined === this.depthAndOrder
+        return undefined === this.opaqueColor && undefined === this.opaqueAndCompositeColor && undefined === this.depthAndOrder && undefined === this.contours
             && undefined === this.hilite && undefined === this.hiliteUsingStencil && undefined === this.occlusion
             && undefined === this.occlusionBlur && undefined === this.stencilSet && undefined === this.altZOnly
             && undefined === this.volClassCreateBlend && undefined === this.volClassCreateBlendAltZ && undefined === this.opaqueAll
@@ -402,6 +428,7 @@ class FrameBuffers {
         this.opaqueColor = dispose(this.opaqueColor);
         this.opaqueAndCompositeColor = dispose(this.opaqueAndCompositeColor);
         this.depthAndOrder = dispose(this.depthAndOrder);
+        this.contours = dispose(this.contours);
         this.hilite = dispose(this.hilite);
         this.hiliteUsingStencil = dispose(this.hiliteUsingStencil);
         this.occlusion = dispose(this.occlusion);
@@ -518,6 +545,7 @@ class PixelBuffer {
     _selector;
     _featureId;
     _depthAndOrder;
+    _contours;
     _batchState;
     _scratchModelFeature = ModelFeature.create();
     get _numPixels() { return this._rect.width * this._rect.height; }
@@ -574,11 +602,12 @@ class PixelBuffer {
         depth = Math.max(0.0, depth);
         return depth;
     }
-    decodeRenderOrderRgba(depthAndOrder) {
-        this._scratchUint32Array[0] = depthAndOrder;
+    decodeRenderOrderRgba(depthAndOrder) { return this.decodeUint8(depthAndOrder, 16); }
+    decodeUint8(rgba32, basis) {
+        this._scratchUint32Array[0] = rgba32;
         const encByte = this._scratchUint8Array[0];
         const enc = encByte / 255.0;
-        const dec = Math.floor(16.0 * enc + 0.5);
+        const dec = Math.floor(basis * enc + 0.5);
         return dec;
     }
     _invalidPixelData = new Pixel.Data();
@@ -630,6 +659,28 @@ class PixelBuffer {
                 }
             }
         }
+        let contour;
+        if (this._contours) {
+            const contour32 = this.getPixel32(this._contours.data, index);
+            if (contour32) { // undefined means out of bounds; zero means not a contour.
+                const groupIndexAndType = this.decodeUint8(contour32, 32);
+                const groupIndex = groupIndexAndType & ~(8 | 16);
+                const group = this._contours.display.groups[groupIndex];
+                if (group) {
+                    const elevationFraction = this.decodeDepthRgba(contour32);
+                    let elevation = elevationFraction * (this._contours.zHigh - this._contours.zLow) + this._contours.zLow;
+                    // The shader rounds to the nearest contour elevation using single-precision arithmetic.
+                    // Re-round here using double-precision to get closer.
+                    const interval = group.contourDef.minorInterval;
+                    elevation = (elevation >= 0 ? Math.floor((elevation + interval / 2) / interval) : Math.ceil((elevation - interval / 2) / interval)) * interval;
+                    contour = {
+                        group,
+                        elevation,
+                        isMajor: groupIndexAndType > 15,
+                    };
+                }
+            }
+        }
         let featureTable, iModel, transformToIModel, tileId, viewAttachmentId, inSectionDrawingAttachment;
         if (undefined !== batchInfo) {
             featureTable = batchInfo.featureTable;
@@ -650,6 +701,7 @@ class PixelBuffer {
             tileId,
             viewAttachmentId,
             inSectionDrawingAttachment,
+            contour,
         });
     }
     constructor(rect, selector, compositor) {
@@ -670,6 +722,10 @@ class PixelBuffer {
             else
                 this._selector &= ~Pixel.Selector.Feature;
         }
+        // Note: readContours is a no-op unless contours are actually being drawn.
+        if (Pixel.Selector.None !== (selector & Pixel.Selector.Contours)) {
+            this._contours = compositor.readContours(rect);
+        }
     }
     get isEmpty() { return Pixel.Selector.None === this._selector; }
     static create(rect, selector, compositor) {
@@ -1353,7 +1409,26 @@ class Compositor extends SceneCompositor {
     readPixels(rect, selector) {
         return PixelBuffer.create(rect, selector, this);
     }
-    readDepthAndOrder(rect) { return this.readFrameBuffer(rect, this._fbos.depthAndOrder); }
+    readDepthAndOrder(rect) {
+        return this.readFrameBuffer(rect, this._fbos.depthAndOrder);
+    }
+    readContours(rect) {
+        // Are we actually drawing any contours? If not, don't bother reading an array of all zeroes off the GPU.
+        const contours = this.target.plan.contours;
+        if (!contours || !contours.displayContours || contours.groups.length === 0) {
+            return undefined;
+        }
+        const info = this.readFrameBuffer(rect, this._fbos.contours);
+        if (!info) {
+            return undefined;
+        }
+        return {
+            data: new Uint32Array(info.buffer),
+            display: contours,
+            zLow: this.target.uniforms.frustum.worldFrustumZRange[0],
+            zHigh: this.target.uniforms.frustum.worldFrustumZRange[1],
+        };
+    }
     readFeatureIds(rect) {
         const tex = this._textures.featureId;
         if (undefined === tex)