@itwin/core-frontend 3.6.0-dev.8 → 4.0.0-dev.2

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

@@ -7,7 +7,7 @@
  * @module WebGL
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SceneCompositor = void 0;
+exports.SceneCompositor = exports.collectGeometryStatistics = exports.collectTextureStatistics = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_geometry_1 = require("@itwin/core-geometry");
 const core_common_1 = require("@itwin/core-common");
@@ -29,10 +29,12 @@ const SolarShadowMap_1 = require("./SolarShadowMap");
 const System_1 = require("./System");
 const Texture_1 = require("./Texture");
 const RenderBuffer_1 = require("./RenderBuffer");
+const EDL_1 = require("./EDL");
 function collectTextureStatistics(texture, stats) {
     if (undefined !== texture)
         stats.addTextureAttachment(texture.bytesUsed);
 }
+exports.collectTextureStatistics = collectTextureStatistics;
 function collectMsBufferStatistics(msBuff, stats) {
     if (undefined !== msBuff)
         stats.addTextureAttachment(msBuff.bytesUsed);
@@ -301,6 +303,7 @@ function collectGeometryStatistics(geom, stats) {
     if (undefined !== geom)
         geom.collectStatistics(stats);
 }
+exports.collectGeometryStatistics = collectGeometryStatistics;
 // Maintains the geometry used to execute screenspace operations for a SceneCompositor.
 class Geometry {
     collectStatistics(stats) {
@@ -519,6 +522,7 @@ class SceneCompositor {
     constructor(target) {
         this.target = target;
         this.solarShadowMap = new SolarShadowMap_1.SolarShadowMap(target);
+        this.eyeDomeLighting = new EDL_1.EyeDomeLighting(target);
         this._needHiddenEdges = false;
     }
     get needHiddenEdges() { return this._needHiddenEdges; }
@@ -549,6 +553,7 @@ class Compositor extends SceneCompositor {
         this._hiliteRenderState = new RenderState_1.RenderState();
         this._noDepthMaskRenderState = new RenderState_1.RenderState();
         this._backgroundMapRenderState = new RenderState_1.RenderState();
+        this._pointCloudRenderState = new RenderState_1.RenderState();
         this._debugStencil = 0; // 0 to draw stencil volumes normally, 1 to draw as opaque, 2 to draw blended
         this._haveVolumeClassifier = false;
         this._antialiasSamples = 1;
@@ -557,6 +562,7 @@ class Compositor extends SceneCompositor {
         this._frameBuffers = fbos;
         this._geom = geometry;
         this._opaqueRenderState.flags.depthTest = true;
+        this._pointCloudRenderState.flags.depthTest = true;
         this._translucentRenderState.flags.depthMask = false;
         this._translucentRenderState.flags.blend = this._translucentRenderState.flags.depthTest = true;
         this._translucentRenderState.blend.setBlendFuncSeparate(GL_1.GL.BlendFactor.One, GL_1.GL.BlendFactor.Zero, GL_1.GL.BlendFactor.One, GL_1.GL.BlendFactor.OneMinusSrcAlpha);
@@ -788,6 +794,12 @@ class Compositor extends SceneCompositor {
             frameBufferStack: System_1.System.instance.frameBufferStack,
         });
         this.target.frameStatsCollector.endTime("onRenderOpaqueTime");
+        // Render point cloud geometry with possible EDL (WebGL2 only)
+        if (System_1.System.instance.capabilities.isWebGL2) {
+            this.target.beginPerfMetricRecord("Render PointClouds");
+            this.renderPointClouds(commands, compositeFlags);
+            this.target.endPerfMetricRecord();
+        }
         // Render opaque geometry
         this.target.beginPerfMetricRecord("Render Opaque");
         this.renderOpaque(commands, compositeFlags, false);
@@ -796,7 +808,7 @@ class Compositor extends SceneCompositor {
         this.target.frameStatsCollector.beginTime("translucentTime");
         // Render translucent layers
         this.target.beginPerfMetricRecord("Render Translucent Layers");
-        this.renderLayers(commands, needComposite, 6 /* TranslucentLayers */);
+        this.renderLayers(commands, needComposite, 7 /* TranslucentLayers */);
         this.target.endPerfMetricRecord();
         if (needComposite) {
             this._geom.composite.update(compositeFlags);
@@ -817,13 +829,13 @@ class Compositor extends SceneCompositor {
         // Render overlay Layers
         this.target.frameStatsCollector.beginTime("overlaysTime");
         this.target.beginPerfMetricRecord("Render Overlay Layers");
-        this.renderLayers(commands, false, 10 /* OverlayLayers */);
+        this.renderLayers(commands, false, 11 /* OverlayLayers */);
         this.target.endPerfMetricRecord();
         this.target.frameStatsCollector.endTime("overlaysTime");
         this.target.popViewClip();
     }
     get fullHeight() { return this.target.viewRect.height; }
-    drawForReadPixels(commands, sceneOverlays, overlayDecorations) {
+    drawForReadPixels(commands, sceneOverlays, worldOverlayDecorations, viewOverlayDecorations) {
         this.target.beginPerfMetricRecord("Render Background", true);
         if (!this.preDraw()) {
             this.target.endPerfMetricRecord(true); // End Render Background record if returning
@@ -846,28 +858,29 @@ class Compositor extends SceneCompositor {
             // Ensure it draws before any opaque geometry (including layers), without depth.
             this.target.beginPerfMetricRecord("Render background map", true);
             this.target.drawingBackgroundForReadPixels = true;
-            this.renderLayers(commands, false, 14 /* BackgroundMap */);
+            this.renderLayers(commands, false, 15 /* BackgroundMap */);
             this.target.drawingBackgroundForReadPixels = false;
             this.target.endPerfMetricRecord(true);
             this.target.beginPerfMetricRecord("Render Opaque Layers", true);
             this.renderLayers(commands, false, 1 /* OpaqueLayers */);
             this.target.endPerfMetricRecord(true);
+            // PointClouds are rendered in Opaque pass for readPixels
             this.target.beginPerfMetricRecord("Render Opaque", true);
             this.renderOpaque(commands, 0 /* None */, true);
             this.target.endPerfMetricRecord(true);
             this.target.beginPerfMetricRecord("Render Translucent Layers", true);
-            this.renderLayers(commands, false, 6 /* TranslucentLayers */);
+            this.renderLayers(commands, false, 7 /* TranslucentLayers */);
             this.target.endPerfMetricRecord(true);
             this.target.beginPerfMetricRecord("Render Overlay Layers", true);
-            this.renderLayers(commands, false, 10 /* OverlayLayers */);
+            this.renderLayers(commands, false, 11 /* OverlayLayers */);
             this.target.endPerfMetricRecord(true);
             this.target.popViewClip();
         }
-        if (0 === sceneOverlays.length && (undefined === overlayDecorations || 0 === overlayDecorations.length))
+        if (!sceneOverlays.length && !(worldOverlayDecorations === null || worldOverlayDecorations === void 0 ? void 0 : worldOverlayDecorations.length) && !(viewOverlayDecorations === null || viewOverlayDecorations === void 0 ? void 0 : viewOverlayDecorations.length))
             return;
         // Now populate the opaque passes with any pickable world overlays
         this.target.beginPerfMetricRecord("Overlay Draws", true);
-        commands.initForPickOverlays(sceneOverlays, overlayDecorations);
+        commands.initForPickOverlays(sceneOverlays, worldOverlayDecorations, viewOverlayDecorations);
         if (commands.isEmpty) {
             this.target.endPerfMetricRecord(true); // End Overlay Draws record if returning
             return;
@@ -937,11 +950,13 @@ class Compositor extends SceneCompositor {
             && this._frameBuffers.isDisposed
             && this._geom.isDisposed
             && !this._haveVolumeClassifier
-            && this.solarShadowMap.isDisposed;
+            && this.solarShadowMap.isDisposed
+            && this.eyeDomeLighting.isDisposed;
     }
     dispose() {
         this.reset();
         (0, core_bentley_1.dispose)(this.solarShadowMap);
+        (0, core_bentley_1.dispose)(this.eyeDomeLighting);
     }
     // Resets anything that depends on the dimensions of the render target.
     // Does *not* dispose the solar shadow map.
@@ -954,6 +969,7 @@ class Compositor extends SceneCompositor {
         (0, core_bentley_1.dispose)(this._frameBuffers);
         (0, core_bentley_1.dispose)(this._geom);
         this._haveVolumeClassifier = false;
+        this.eyeDomeLighting.reset();
     }
     init() {
         this.reset();
@@ -965,7 +981,8 @@ class Compositor extends SceneCompositor {
         if (this._depth !== undefined) {
             return this._textures.init(this._width, this._height, this._antialiasSamples)
                 && this._frameBuffers.init(this._textures, this._depth, this._depthMS)
-                && this._geom.init(this._textures);
+                && this._geom.init(this._textures)
+                && this.eyeDomeLighting.init(this._width, this._height, this._depth);
         }
         return false;
     }
@@ -984,27 +1001,27 @@ class Compositor extends SceneCompositor {
         return this._textures.disableMultiSampling();
     }
     renderBackgroundMap(commands, needComposite) {
-        const cmds = commands.getCommands(14 /* BackgroundMap */);
+        const cmds = commands.getCommands(15 /* BackgroundMap */);
         if (0 === cmds.length) {
             return;
         }
         const fbStack = System_1.System.instance.frameBufferStack;
         const fbo = this.getBackgroundFbo(needComposite);
         fbStack.execute(fbo, true, this.useMsBuffers, () => {
-            System_1.System.instance.applyRenderState(this.getRenderState(14 /* BackgroundMap */));
-            this.target.techniques.execute(this.target, cmds, 14 /* BackgroundMap */);
+            System_1.System.instance.applyRenderState(this.getRenderState(15 /* BackgroundMap */));
+            this.target.techniques.execute(this.target, cmds, 15 /* BackgroundMap */);
         });
     }
     renderSkyBox(commands, needComposite) {
-        const cmds = commands.getCommands(13 /* SkyBox */);
+        const cmds = commands.getCommands(14 /* SkyBox */);
         if (0 === cmds.length) {
             return;
         }
         const fbStack = System_1.System.instance.frameBufferStack;
         const fbo = this.getBackgroundFbo(needComposite);
         fbStack.execute(fbo, true, this.useMsBuffers, () => {
-            System_1.System.instance.applyRenderState(this.getRenderState(13 /* SkyBox */));
-            this.target.techniques.execute(this.target, cmds, 13 /* SkyBox */);
+            System_1.System.instance.applyRenderState(this.getRenderState(14 /* SkyBox */));
+            this.target.techniques.execute(this.target, cmds, 14 /* SkyBox */);
         });
     }
     renderBackground(commands, needComposite) {
@@ -1126,7 +1143,7 @@ class Compositor extends SceneCompositor {
         System_1.System.instance.frameBufferStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
             this.target.pushState(this._vcBranchState);
             System_1.System.instance.applyRenderState(this._vcSetStencilRenderState);
-            this.target.techniques.executeForIndexedClassifier(this.target, cmdsByIndex, 5 /* Classification */);
+            this.target.techniques.executeForIndexedClassifier(this.target, cmdsByIndex, 6 /* Classification */);
             this.target.popBranch();
         });
         // Process the stencil for the pick data.
@@ -1134,8 +1151,8 @@ class Compositor extends SceneCompositor {
     }
     renderVolumeClassification(commands, compositeFlags, renderForReadPixels) {
         // Sometimes we need to render the classifier stencil volumes one at a time, if so draw them from the cmdsByIndex list
-        const cmds = commands.getCommands(5 /* Classification */);
-        const cmdsByIndex = commands.getCommands(16 /* ClassificationByIndex */);
+        const cmds = commands.getCommands(6 /* Classification */);
+        const cmdsByIndex = commands.getCommands(17 /* ClassificationByIndex */);
         let numCmdsPerClassifier = 0;
         for (const cmd of cmdsByIndex) { // Figure out how many commands there are per index/primitive
             numCmdsPerClassifier++;
@@ -1144,7 +1161,7 @@ class Compositor extends SceneCompositor {
                 break;
             }
         }
-        const cmdsForVC = commands.getCommands(19 /* VolumeClassifiedRealityData */);
+        const cmdsForVC = commands.getCommands(20 /* VolumeClassifiedRealityData */);
         if (!this.target.activeVolumeClassifierProps || (renderForReadPixels && 0 === cmds.length) || 0 === cmdsForVC.length)
             return;
         let outsideFlags = this.target.activeVolumeClassifierProps.flags.outside;
@@ -1164,13 +1181,13 @@ class Compositor extends SceneCompositor {
         if (this._debugStencil > 0) {
             fbStack.execute(fboColorAndZ, true, this.useMsBuffers, () => {
                 if (1 === this._debugStencil) {
-                    System_1.System.instance.applyRenderState(this.getRenderState(4 /* OpaqueGeneral */));
-                    this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+                    System_1.System.instance.applyRenderState(this.getRenderState(5 /* OpaqueGeneral */));
+                    this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
                 }
                 else {
                     this.target.pushState(this._vcBranchState);
                     System_1.System.instance.applyRenderState(this._vcDebugRenderState);
-                    this.target.techniques.execute(this.target, cmds, 5 /* Classification */);
+                    this.target.techniques.execute(this.target, cmds, 6 /* Classification */);
                     this.target.popBranch();
                 }
             });
@@ -1235,7 +1252,7 @@ class Compositor extends SceneCompositor {
             System_1.System.instance.frameBufferStack.execute(this._frameBuffers.altZOnly, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System_1.System.instance.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.execute(this.target, cmds, 5 /* Classification */);
+                this.target.techniques.execute(this.target, cmds, 6 /* Classification */);
                 // After we create the stencil we need to clear the Z for the next step (so also must turn on z writing temporarily).
                 this._vcSetStencilRenderState.flags.depthMask = true;
                 System_1.System.instance.applyRenderState(this._vcSetStencilRenderState);
@@ -1274,7 +1291,7 @@ class Compositor extends SceneCompositor {
             fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System_1.System.instance.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.execute(this.target, cmds, 5 /* Classification */);
+                this.target.techniques.execute(this.target, cmds, 6 /* Classification */);
                 this.target.popBranch();
                 System_1.System.instance.bindTexture2d(RenderFlags_1.TextureUnit.Two, undefined);
                 System_1.System.instance.bindTexture2d(RenderFlags_1.TextureUnit.Five, undefined);
@@ -1330,7 +1347,7 @@ class Compositor extends SceneCompositor {
                     fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
                         this.target.pushState(this._vcBranchState);
                         System_1.System.instance.applyRenderState(this._vcSetStencilRenderState);
-                        this.target.techniques.execute(this.target, nxtCmds, 5 /* Classification */);
+                        this.target.techniques.execute(this.target, nxtCmds, 6 /* Classification */);
                         this.target.popBranch();
                     });
                     // Process the stencil. Just render the volume normally (us opaque pass), but use blending to modify the source alpha that gets written to the blend texture.
@@ -1341,7 +1358,7 @@ class Compositor extends SceneCompositor {
                         this._vcColorRenderState.flags.cull = true;
                         System_1.System.instance.applyRenderState(this._vcColorRenderState);
                         this.target.activeVolumeClassifierTexture = undefined; // make sure this texture is undefined so we do not use the planar classification shader
-                        this.target.techniques.execute(this.target, nxtCmds, 4 /* OpaqueGeneral */);
+                        this.target.techniques.execute(this.target, nxtCmds, 5 /* OpaqueGeneral */);
                         this._vcColorRenderState.flags.cull = false;
                         this.target.popBranch();
                     });
@@ -1367,7 +1384,7 @@ class Compositor extends SceneCompositor {
                     System_1.System.instance.context.clearDepth(1.0);
                     System_1.System.instance.context.clear(GL_1.GL.BufferBit.Depth);
                     this.target.activeVolumeClassifierTexture = this._geom.volClassCopyZ.texture;
-                    this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+                    this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
                     this.target.activeVolumeClassifierTexture = undefined;
                     this._vcColorRenderState.flags.depthTest = false;
                     this._vcColorRenderState.flags.depthMask = false;
@@ -1384,8 +1401,8 @@ class Compositor extends SceneCompositor {
         // and this stage can be skipped.  In order for this to work the list of commands needs to get reduced to only the ones which draw hilited volumes.
         // We cannot use the hillite shader to draw them since it doesn't handle logZ properly (it doesn't need to since it is only used elsewhere when Z write is turned off)
         // and we don't really want another whole set of hilite shaders just for this.
-        const cmdsSelected = (0, DrawCommand_1.extractHilitedVolumeClassifierCommands)(this.target.hilites, commands.getCommands(15 /* HiliteClassification */));
-        commands.replaceCommands(15 /* HiliteClassification */, cmdsSelected); // replace the hilite command list for use in hilite pass as well.
+        const cmdsSelected = (0, DrawCommand_1.extractHilitedVolumeClassifierCommands)(this.target.hilites, commands.getCommands(16 /* HiliteClassification */));
+        commands.replaceCommands(16 /* HiliteClassification */, cmdsSelected); // replace the hilite command list for use in hilite pass as well.
         // if (cmdsSelected.length > 0 && insideFlags !== this.target.activeVolumeClassifierProps!.flags.selected) {
         if (!doColorByElement && cmdsSelected.length > 0 && insideFlags !== core_common_1.SpatialClassifierInsideDisplay.Hilite) { // assume selected ones are always hilited
             // Set the stencil using just the hilited volume classifiers.
@@ -1397,7 +1414,7 @@ class Compositor extends SceneCompositor {
                     System_1.System.instance.context.clearStencil(0);
                     System_1.System.instance.context.clear(GL_1.GL.BufferBit.Stencil);
                 }
-                this.target.techniques.execute(this.target, cmdsSelected, 5 /* Classification */);
+                this.target.techniques.execute(this.target, cmdsSelected, 6 /* Classification */);
                 this.target.popBranch();
             });
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
@@ -1436,7 +1453,7 @@ class Compositor extends SceneCompositor {
             fbStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System_1.System.instance.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.executeForIndexedClassifier(this.target, flashedClassifierCmds, 4 /* OpaqueGeneral */);
+                this.target.techniques.executeForIndexedClassifier(this.target, flashedClassifierCmds, 5 /* OpaqueGeneral */);
                 this.target.popBranch();
             });
             // Process the stencil to flash the contents.
@@ -1458,30 +1475,30 @@ class Compositor extends SceneCompositor {
             system.context.clearColor(0, 0, 0, 0);
             system.context.clear(GL_1.GL.BufferBit.Color);
             // Draw the normal hilite geometry.
-            this.drawPass(commands, 9 /* Hilite */);
+            this.drawPass(commands, 10 /* Hilite */);
         });
         // Process planar classifiers
-        const planarClassifierCmds = commands.getCommands(17 /* HilitePlanarClassification */);
+        const planarClassifierCmds = commands.getCommands(18 /* HilitePlanarClassification */);
         if (0 !== planarClassifierCmds.length) {
             system.frameBufferStack.execute(this._frameBuffers.hiliteUsingStencil, true, false, () => {
                 system.applyRenderState(this._opaqueRenderState);
-                this.target.techniques.execute(this.target, planarClassifierCmds, 17 /* HilitePlanarClassification */);
+                this.target.techniques.execute(this.target, planarClassifierCmds, 18 /* HilitePlanarClassification */);
             });
         }
         // Process the volume classifiers.
-        const vcHiliteCmds = commands.getCommands(15 /* HiliteClassification */);
+        const vcHiliteCmds = commands.getCommands(16 /* HiliteClassification */);
         if (0 !== vcHiliteCmds.length && undefined !== this._vcBranchState) {
             // Set the stencil for the given classifier stencil volume.
             system.frameBufferStack.execute(this._frameBuffers.stencilSet, false, false, () => {
                 this.target.pushState(this._vcBranchState);
                 system.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.execute(this.target, vcHiliteCmds, 9 /* Hilite */);
+                this.target.techniques.execute(this.target, vcHiliteCmds, 10 /* Hilite */);
                 this.target.popBranch();
             });
             // Process the stencil for the hilite data.
             system.frameBufferStack.execute(this._frameBuffers.hiliteUsingStencil, true, false, () => {
                 system.applyRenderState(this._vcPickDataRenderState);
-                this.target.techniques.execute(this.target, vcHiliteCmds, 9 /* Hilite */);
+                this.target.techniques.execute(this.target, vcHiliteCmds, 10 /* Hilite */);
             });
         }
     }
@@ -1493,27 +1510,29 @@ class Compositor extends SceneCompositor {
     getRenderState(pass) {
         switch (pass) {
             case 1 /* OpaqueLayers */:
-            case 6 /* TranslucentLayers */:
-            case 10 /* OverlayLayers */:
+            case 7 /* TranslucentLayers */:
+            case 11 /* OverlayLayers */:
                 // NB: During pick, we don't want blending - it will mess up our pick buffer data and we don't care about the color data.
                 // During normal draw, we don't use the pick buffers for anything, and we want color blending.
                 // (We get away with this because surfaces always draw before their edges, and we're not depth-testing, so edges always draw atop surfaces without pick buffer testing).
                 this._layerRenderState.flags.blend = !this.target.isReadPixelsInProgress;
                 // Transparent non-overlay Layers are drawn between opaque and translucent passes. Test depth, don't write it, so that they blend with opaque.
-                this._layerRenderState.flags.depthMask = 6 /* TranslucentLayers */ !== pass;
-                this._layerRenderState.depthFunc = (6 /* TranslucentLayers */ === pass) ? GL_1.GL.DepthFunc.Default : GL_1.GL.DepthFunc.Always;
+                this._layerRenderState.flags.depthMask = 7 /* TranslucentLayers */ !== pass;
+                this._layerRenderState.depthFunc = (7 /* TranslucentLayers */ === pass) ? GL_1.GL.DepthFunc.Default : GL_1.GL.DepthFunc.Always;
                 return this._layerRenderState;
             case 2 /* OpaqueLinear */:
             case 3 /* OpaquePlanar */:
-            case 4 /* OpaqueGeneral */:
-            case 17 /* HilitePlanarClassification */:
+            case 5 /* OpaqueGeneral */:
+            case 18 /* HilitePlanarClassification */:
                 return this._opaqueRenderState;
-            case 7 /* Translucent */:
+            case 8 /* Translucent */:
                 return this._translucentRenderState;
-            case 9 /* Hilite */:
+            case 10 /* Hilite */:
                 return this._hiliteRenderState;
-            case 14 /* BackgroundMap */:
+            case 15 /* BackgroundMap */:
                 return this._backgroundMapRenderState;
+            case 4 /* PointClouds */:
+                return this._pointCloudRenderState;
             default:
                 return this._noDepthMaskRenderState;
         }
@@ -1655,7 +1674,8 @@ class MRTFrameBuffers extends FrameBuffers {
             && undefined === this.idsAndZ
             && undefined === this.idsAndAltZ
             && undefined === this.idsAndZComposite
-            && undefined === this.idsAndAltZComposite;
+            && undefined === this.idsAndAltZComposite
+            && undefined === this.edlDrawCol;
     }
     dispose() {
         super.dispose();
@@ -1670,6 +1690,7 @@ class MRTFrameBuffers extends FrameBuffers {
         this.idsAndAltZ = (0, core_bentley_1.dispose)(this.idsAndAltZ);
         this.idsAndZComposite = (0, core_bentley_1.dispose)(this.idsAndZComposite);
         this.idsAndAltZComposite = (0, core_bentley_1.dispose)(this.idsAndAltZComposite);
+        this.edlDrawCol = (0, core_bentley_1.dispose)(this.edlDrawCol);
     }
 }
 class MRTGeometry extends Geometry {
@@ -1749,6 +1770,101 @@ class MRTCompositor extends Compositor {
             system.context.clear(GL_1.GL.BufferBit.Depth);
         });
     }
+    renderPointClouds(commands, compositeFlags) {
+        var _a, _b;
+        const is3d = 2 /* Perspective */ === this.target.uniforms.frustum.type;
+        // separate individual point clouds and get their point cloud settings
+        const pointClouds = [];
+        let pcs;
+        const cmds = commands.getCommands(4 /* PointClouds */);
+        let curPC;
+        let pushDepth = 0;
+        for (const cmd of cmds) {
+            if ("pushBranch" === cmd.opcode) { // should be first command
+                ++pushDepth;
+                if (pushDepth === 1) {
+                    pcs = (_a = cmd.branch.branch.realityModelDisplaySettings) === null || _a === void 0 ? void 0 : _a.pointCloud;
+                    this.target.uniforms.realityModel.pointCloud.updateRange(cmd.branch.branch.realityModelRange, this.target, cmd.branch.localToWorldTransform, is3d);
+                    pointClouds.push(curPC = { pcs, cmds: [cmd] });
+                }
+                else {
+                    (0, core_bentley_1.assert)(undefined !== curPC);
+                    curPC.cmds.push(cmd);
+                }
+            }
+            else {
+                if ("popBranch" === cmd.opcode)
+                    --pushDepth;
+                (0, core_bentley_1.assert)(undefined !== curPC);
+                curPC.cmds.push(cmd);
+            }
+        }
+        const needComposite = 0 /* None */ !== compositeFlags;
+        const fbo = (needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor);
+        const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
+        const system = System_1.System.instance;
+        const fbStack = system.frameBufferStack;
+        this._readPickDataFromPingPong = false;
+        for (const pc of pointClouds) {
+            pcs = pc.pcs;
+            let edlOn = (pcs === null || pcs === void 0 ? void 0 : pcs.edlMode) !== "off" && is3d;
+            if (edlOn) {
+                if (undefined === this._textures.hilite)
+                    edlOn = false;
+                else {
+                    // create fbo on fly if not present, or has changed (from MS)
+                    // ###TODO consider not drawing point clouds to MS buffers, at least if EDL, it isn't worth the overhead.
+                    //         would have to blit depth before draw, use depth for draw, then run shader to copy depth back to MSAA
+                    //         at end, wherever color buf changed (test alpha, else discard)
+                    //         this would also simplify this code considerably
+                    let drawColBufs;
+                    if (undefined !== this._fbos.edlDrawCol)
+                        drawColBufs = this._fbos.edlDrawCol.getColorTargets(useMsBuffers, 0);
+                    if (undefined === this._fbos.edlDrawCol || this._textures.hilite !== (drawColBufs === null || drawColBufs === void 0 ? void 0 : drawColBufs.tex) || this._textures.hiliteMsBuff !== drawColBufs.msBuf) {
+                        this._fbos.edlDrawCol = (0, core_bentley_1.dispose)(this._fbos.edlDrawCol);
+                        const filters = [GL_1.GL.MultiSampling.Filter.Linear];
+                        if (useMsBuffers)
+                            this._fbos.edlDrawCol = FrameBuffer_1.FrameBuffer.create([this._textures.hilite], this._depth, useMsBuffers && this._textures.hiliteMsBuff ? [this._textures.hiliteMsBuff] : undefined, filters, this._depthMS);
+                        else
+                            this._fbos.edlDrawCol = FrameBuffer_1.FrameBuffer.create([this._textures.hilite], this._depth);
+                    }
+                    if (undefined === this._fbos.edlDrawCol)
+                        edlOn = false;
+                    else { // can draw EDL
+                        // first draw pointcloud to borrowed hilite texture(MS) and regular depth(MS) buffers
+                        fbStack.execute(this._fbos.edlDrawCol, true, useMsBuffers, () => {
+                            system.context.clearColor(0, 0, 0, 0);
+                            system.context.clear(GL_1.GL.BufferBit.Color);
+                            system.applyRenderState(this.getRenderState(4 /* PointClouds */));
+                            this.target.techniques.execute(this.target, pc.cmds, 4 /* PointClouds */);
+                        });
+                        if (useMsBuffers)
+                            this._fbos.edlDrawCol.blitMsBuffersToTextures(true, 0); // need to read the non-MS depth and hilite buffers
+                        // next process buffers to generate EDL (depth buffer is passed during init)
+                        this.target.beginPerfMetricRecord("Calc EDL"); // ### todo keep? (probably)
+                        const sts = this.eyeDomeLighting.draw({
+                            edlMode: ((_b = pc.pcs) === null || _b === void 0 ? void 0 : _b.edlMode) === "full" ? EDL_1.EDLMode.Full : EDL_1.EDLMode.On,
+                            edlFilter: !!(pcs === null || pcs === void 0 ? void 0 : pcs.edlFilter),
+                            useMsBuffers,
+                            inputTex: this._textures.hilite,
+                            curFbo: fbo,
+                        });
+                        this.target.endPerfMetricRecord();
+                        if (!sts) {
+                            edlOn = false;
+                        }
+                    }
+                }
+            }
+            if (!edlOn) {
+                // draw the regular way
+                fbStack.execute(fbo, true, useMsBuffers, () => {
+                    system.applyRenderState(this.getRenderState(4 /* PointClouds */));
+                    this.target.techniques.execute(this.target, pc.cmds, 4 /* PointClouds */);
+                });
+            }
+        }
+    }
     renderOpaque(commands, compositeFlags, renderForReadPixels) {
         if (0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */) && !renderForReadPixels) {
             this.renderOpaqueAO(commands);
@@ -1764,7 +1880,8 @@ class MRTCompositor extends Compositor {
             this.drawPass(commands, 2 /* OpaqueLinear */);
             this.drawPass(commands, 3 /* OpaquePlanar */, true);
             if (renderForReadPixels) {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, true);
+                this.drawPass(commands, 4 /* PointClouds */, true); // don't need EDL for this
+                this.drawPass(commands, 5 /* OpaqueGeneral */, true);
                 if (useMsBuffers)
                     fbo.blitMsBuffersToTextures(true);
             }
@@ -1774,16 +1891,17 @@ class MRTCompositor extends Compositor {
         if (!renderForReadPixels) {
             fbo = (needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor);
             fbStack.execute(fbo, true, useMsBuffers, () => {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false);
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
+                this.drawPass(commands, 5 /* OpaqueGeneral */, false);
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
             });
+            // assume we are done with MS at this point, so update the non-MS buffers
             if (useMsBuffers)
                 fbo.blitMsBuffersToTextures(needComposite);
         }
     }
     renderOpaqueAO(commands) {
         const fbStack = System_1.System.instance.frameBufferStack;
-        const haveHiddenEdges = 0 !== commands.getCommands(8 /* HiddenEdge */).length;
+        const haveHiddenEdges = 0 !== commands.getCommands(9 /* HiddenEdge */).length;
         // Output the linear, planar, and pickable surfaces to color and pick data buffers.
         let fbo = this._fbos.opaqueAndCompositeAll;
         const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
@@ -1792,7 +1910,7 @@ class MRTCompositor extends Compositor {
             this.drawPass(commands, 2 /* OpaqueLinear */);
             this.drawPass(commands, 3 /* OpaquePlanar */, true);
             this._primitiveDrawState = PrimitiveDrawState.Pickable;
-            this.drawPass(commands, 4 /* OpaqueGeneral */, true);
+            this.drawPass(commands, 5 /* OpaqueGeneral */, true);
             this._primitiveDrawState = PrimitiveDrawState.Both;
             if (useMsBuffers)
                 fbo.blitMsBuffersToTextures(true);
@@ -1802,9 +1920,9 @@ class MRTCompositor extends Compositor {
         fbo = this._fbos.opaqueAndCompositeColor;
         fbStack.execute(fbo, true, useMsBuffers, () => {
             this._primitiveDrawState = PrimitiveDrawState.NonPickable;
-            this.drawPass(commands, 4 /* OpaqueGeneral */, false);
+            this.drawPass(commands, 5 /* OpaqueGeneral */, false);
             if (haveHiddenEdges)
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
             this._primitiveDrawState = PrimitiveDrawState.Both;
         });
         if (useMsBuffers)
@@ -1828,7 +1946,7 @@ class MRTCompositor extends Compositor {
             fbo = this._fbos.opaqueAndCompositeAllHidden;
             this._primitiveDrawState = PrimitiveDrawState.Pickable;
             fbStack.execute(fbo, true, useMsBuffers, () => {
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
             });
             this._primitiveDrawState = PrimitiveDrawState.Both;
             if (useMsBuffers) {
@@ -1858,13 +1976,13 @@ class MRTCompositor extends Compositor {
         if (renderForReadPixels || needAO) {
             this._readPickDataFromPingPong = true;
             fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll, true, this.useMsBuffers, () => {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, true, 19 /* VolumeClassifiedRealityData */);
+                this.drawPass(commands, 5 /* OpaqueGeneral */, true, 20 /* VolumeClassifiedRealityData */);
             });
         }
         else {
             this._readPickDataFromPingPong = false;
             fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor, true, this.useMsBuffers, () => {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false, 19 /* VolumeClassifiedRealityData */);
+                this.drawPass(commands, 5 /* OpaqueGeneral */, false, 20 /* VolumeClassifiedRealityData */);
             });
         }
     }
@@ -1874,7 +1992,7 @@ class MRTCompositor extends Compositor {
             : (needComposite ? this._fbos.idsAndAltZComposite : this._fbos.idsAndAltZ));
         System_1.System.instance.frameBufferStack.execute(fbo, true, false, () => {
             System_1.System.instance.applyRenderState(state);
-            this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+            this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
         });
         this._readPickDataFromPingPong = false;
     }
@@ -1887,7 +2005,7 @@ class MRTCompositor extends Compositor {
     }
     renderTranslucent(commands) {
         System_1.System.instance.frameBufferStack.execute(this._fbos.translucent, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
+            this.drawPass(commands, 8 /* Translucent */);
         });
     }
     pingPong() {
@@ -1983,7 +2101,7 @@ class MPCompositor extends Compositor {
         switch (pass) {
             case 2 /* OpaqueLinear */:
             case 3 /* OpaquePlanar */:
-            case 4 /* OpaqueGeneral */:
+            case 5 /* OpaqueGeneral */:
                 return this._drawMultiPassDepth ? this._opaqueRenderState : this._opaqueRenderStateNoZWt;
         }
         return super.getRenderState(pass);
@@ -2008,6 +2126,7 @@ class MPCompositor extends Compositor {
     }
     clearHiddenPick() {
     }
+    renderPointClouds(_commands, _compositeFlags) { }
     renderOpaque(commands, compositeFlags, renderForReadPixels) {
         if (0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */) && !renderForReadPixels) {
             this.renderOpaqueAO(commands);
@@ -2021,36 +2140,36 @@ class MPCompositor extends Compositor {
         this.drawOpaquePass(colorFbo, commands, 2 /* OpaqueLinear */, false);
         this.drawOpaquePass(colorFbo, commands, 3 /* OpaquePlanar */, true);
         if (renderForReadPixels || needAO)
-            this.drawOpaquePass(colorFbo, commands, 4 /* OpaqueGeneral */, true);
+            this.drawOpaquePass(colorFbo, commands, 5 /* OpaqueGeneral */, true);
         this._readPickDataFromPingPong = false;
         // The general pass (and following) will not bother to write to pick buffers and so can read from the actual pick buffers.
         if (!renderForReadPixels) {
             System_1.System.instance.frameBufferStack.execute(colorFbo, true, false, () => {
                 this._drawMultiPassDepth = true; // for OpaqueGeneral
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false);
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
+                this.drawPass(commands, 5 /* OpaqueGeneral */, false);
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
             });
         }
     }
     renderOpaqueAO(commands) {
         const fbStack = System_1.System.instance.frameBufferStack;
-        const haveHiddenEdges = 0 !== commands.getCommands(8 /* HiddenEdge */).length;
+        const haveHiddenEdges = 0 !== commands.getCommands(9 /* HiddenEdge */).length;
         // Output the linear, planar, and pickable surfaces to color and pick data buffers.
         this._readPickDataFromPingPong = true;
         const colorFbo = this._fbos.opaqueAndCompositeColor;
         this.drawOpaquePass(colorFbo, commands, 2 /* OpaqueLinear */, false);
         this.drawOpaquePass(colorFbo, commands, 3 /* OpaquePlanar */, true);
         this._primitiveDrawState = PrimitiveDrawState.Pickable;
-        this.drawOpaquePass(colorFbo, commands, 4 /* OpaqueGeneral */, true);
+        this.drawOpaquePass(colorFbo, commands, 5 /* OpaqueGeneral */, true);
         this._primitiveDrawState = PrimitiveDrawState.Both;
         this._readPickDataFromPingPong = false;
         // Output the non-pickable surfaces and hidden edges to just the color buffer.
         fbStack.execute(colorFbo, true, false, () => {
             this._drawMultiPassDepth = true; // for OpaqueGeneral
             this._primitiveDrawState = PrimitiveDrawState.NonPickable;
-            this.drawPass(commands, 4 /* OpaqueGeneral */, false);
+            this.drawPass(commands, 5 /* OpaqueGeneral */, false);
             if (haveHiddenEdges)
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
             this._primitiveDrawState = PrimitiveDrawState.Both;
         });
         if (haveHiddenEdges) {
@@ -2061,10 +2180,10 @@ class MPCompositor extends Compositor {
             this._primitiveDrawState = PrimitiveDrawState.Pickable;
             // Since we only need to draw color and depthAndOrder instead of calling drawOpaquePass just do what we need here.
             this._drawMultiPassDepth = true;
-            fbStack.execute(colorFbo, true, false, () => this.drawPass(commands, 8 /* HiddenEdge */, false));
+            fbStack.execute(colorFbo, true, false, () => this.drawPass(commands, 9 /* HiddenEdge */, false));
             this._drawMultiPassDepth = false;
             this._currentRenderTargetIndex = 2;
-            fbStack.execute(this._fbos.revealage, true, false, () => this.drawPass(commands, 8 /* HiddenEdge */, false));
+            fbStack.execute(this._fbos.revealage, true, false, () => this.drawPass(commands, 9 /* HiddenEdge */, false));
             this._currentRenderTargetIndex = 0;
             this._readPickDataFromPingPong = false;
             this._primitiveDrawState = PrimitiveDrawState.Both;
@@ -2085,7 +2204,7 @@ class MPCompositor extends Compositor {
         const colorFbo = needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor;
         if (renderForReadPixels || needAO) {
             this._readPickDataFromPingPong = true;
-            this.drawOpaquePass(colorFbo, commands, 4 /* OpaqueGeneral */, true, 19 /* VolumeClassifiedRealityData */);
+            this.drawOpaquePass(colorFbo, commands, 5 /* OpaqueGeneral */, true, 20 /* VolumeClassifiedRealityData */);
             if (needAO)
                 this.renderAmbientOcclusion();
         }
@@ -2093,7 +2212,7 @@ class MPCompositor extends Compositor {
             this._readPickDataFromPingPong = false;
             System_1.System.instance.frameBufferStack.execute(colorFbo, true, false, () => {
                 this._drawMultiPassDepth = true; // for OpaqueGeneral
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false, 19 /* VolumeClassifiedRealityData */);
+                this.drawPass(commands, 5 /* OpaqueGeneral */, false, 20 /* VolumeClassifiedRealityData */);
             });
         }
     }
@@ -2104,7 +2223,7 @@ class MPCompositor extends Compositor {
         const fbo = (renderForIntersectingVolumes ? this._fbos.featureIdWithDepth : this._fbos.featureIdWithDepthAltZ);
         System_1.System.instance.frameBufferStack.execute(fbo, true, false, () => {
             System_1.System.instance.applyRenderState(state);
-            this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+            this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
         });
         this._currentRenderTargetIndex = 0;
         this._readPickDataFromPingPong = false;
@@ -2135,11 +2254,11 @@ class MPCompositor extends Compositor {
     }
     renderTranslucent(commands) {
         System_1.System.instance.frameBufferStack.execute(this._fbos.accumulation, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
+            this.drawPass(commands, 8 /* Translucent */);
         });
         this._currentRenderTargetIndex = 1;
         System_1.System.instance.frameBufferStack.execute(this._fbos.revealage, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
+            this.drawPass(commands, 8 /* Translucent */);
         });
         this._currentRenderTargetIndex = 0;
     }