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

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

@@ -26,7 +26,8 @@ import { SolarShadowMap } from "./SolarShadowMap";
 import { System } from "./System";
 import { TextureHandle } from "./Texture";
 import { RenderBufferMultiSample } from "./RenderBuffer";
-function collectTextureStatistics(texture, stats) {
+import { EDLMode, EyeDomeLighting } from "./EDL";
+export function collectTextureStatistics(texture, stats) {
     if (undefined !== texture)
         stats.addTextureAttachment(texture.bytesUsed);
 }
@@ -294,7 +295,7 @@ class FrameBuffers {
         this.volClassCreateBlendAltZ = dispose(this.volClassCreateBlendAltZ);
     }
 }
-function collectGeometryStatistics(geom, stats) {
+export function collectGeometryStatistics(geom, stats) {
     if (undefined !== geom)
         geom.collectStatistics(stats);
 }
@@ -516,6 +517,7 @@ export class SceneCompositor {
     constructor(target) {
         this.target = target;
         this.solarShadowMap = new SolarShadowMap(target);
+        this.eyeDomeLighting = new EyeDomeLighting(target);
         this._needHiddenEdges = false;
     }
     get needHiddenEdges() { return this._needHiddenEdges; }
@@ -545,6 +547,7 @@ class Compositor extends SceneCompositor {
         this._hiliteRenderState = new RenderState();
         this._noDepthMaskRenderState = new RenderState();
         this._backgroundMapRenderState = new RenderState();
+        this._pointCloudRenderState = new 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;
@@ -553,6 +556,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.BlendFactor.One, GL.BlendFactor.Zero, GL.BlendFactor.One, GL.BlendFactor.OneMinusSrcAlpha);
@@ -784,6 +788,12 @@ class Compositor extends SceneCompositor {
             frameBufferStack: System.instance.frameBufferStack,
         });
         this.target.frameStatsCollector.endTime("onRenderOpaqueTime");
+        // Render point cloud geometry with possible EDL (WebGL2 only)
+        if (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);
@@ -792,7 +802,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);
@@ -813,13 +823,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
@@ -842,28 +852,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;
@@ -933,11 +944,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();
         dispose(this.solarShadowMap);
+        dispose(this.eyeDomeLighting);
     }
     // Resets anything that depends on the dimensions of the render target.
     // Does *not* dispose the solar shadow map.
@@ -950,6 +963,7 @@ class Compositor extends SceneCompositor {
         dispose(this._frameBuffers);
         dispose(this._geom);
         this._haveVolumeClassifier = false;
+        this.eyeDomeLighting.reset();
     }
     init() {
         this.reset();
@@ -961,7 +975,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;
     }
@@ -980,27 +995,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.instance.frameBufferStack;
         const fbo = this.getBackgroundFbo(needComposite);
         fbStack.execute(fbo, true, this.useMsBuffers, () => {
-            System.instance.applyRenderState(this.getRenderState(14 /* BackgroundMap */));
-            this.target.techniques.execute(this.target, cmds, 14 /* BackgroundMap */);
+            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.instance.frameBufferStack;
         const fbo = this.getBackgroundFbo(needComposite);
         fbStack.execute(fbo, true, this.useMsBuffers, () => {
-            System.instance.applyRenderState(this.getRenderState(13 /* SkyBox */));
-            this.target.techniques.execute(this.target, cmds, 13 /* SkyBox */);
+            System.instance.applyRenderState(this.getRenderState(14 /* SkyBox */));
+            this.target.techniques.execute(this.target, cmds, 14 /* SkyBox */);
         });
     }
     renderBackground(commands, needComposite) {
@@ -1122,7 +1137,7 @@ class Compositor extends SceneCompositor {
         System.instance.frameBufferStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
             this.target.pushState(this._vcBranchState);
             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.
@@ -1130,8 +1145,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++;
@@ -1140,7 +1155,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;
@@ -1160,13 +1175,13 @@ class Compositor extends SceneCompositor {
         if (this._debugStencil > 0) {
             fbStack.execute(fboColorAndZ, true, this.useMsBuffers, () => {
                 if (1 === this._debugStencil) {
-                    System.instance.applyRenderState(this.getRenderState(4 /* OpaqueGeneral */));
-                    this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+                    System.instance.applyRenderState(this.getRenderState(5 /* OpaqueGeneral */));
+                    this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
                 }
                 else {
                     this.target.pushState(this._vcBranchState);
                     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();
                 }
             });
@@ -1231,7 +1246,7 @@ class Compositor extends SceneCompositor {
             System.instance.frameBufferStack.execute(this._frameBuffers.altZOnly, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 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.instance.applyRenderState(this._vcSetStencilRenderState);
@@ -1270,7 +1285,7 @@ class Compositor extends SceneCompositor {
             fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 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.instance.bindTexture2d(TextureUnit.Two, undefined);
                 System.instance.bindTexture2d(TextureUnit.Five, undefined);
@@ -1326,7 +1341,7 @@ class Compositor extends SceneCompositor {
                     fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
                         this.target.pushState(this._vcBranchState);
                         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.
@@ -1337,7 +1352,7 @@ class Compositor extends SceneCompositor {
                         this._vcColorRenderState.flags.cull = true;
                         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();
                     });
@@ -1363,7 +1378,7 @@ class Compositor extends SceneCompositor {
                     System.instance.context.clearDepth(1.0);
                     System.instance.context.clear(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;
@@ -1380,8 +1395,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 = 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 = 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 !== SpatialClassifierInsideDisplay.Hilite) { // assume selected ones are always hilited
             // Set the stencil using just the hilited volume classifiers.
@@ -1393,7 +1408,7 @@ class Compositor extends SceneCompositor {
                     System.instance.context.clearStencil(0);
                     System.instance.context.clear(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)
@@ -1432,7 +1447,7 @@ class Compositor extends SceneCompositor {
             fbStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 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.
@@ -1454,30 +1469,30 @@ class Compositor extends SceneCompositor {
             system.context.clearColor(0, 0, 0, 0);
             system.context.clear(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 */);
             });
         }
     }
@@ -1489,27 +1504,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.DepthFunc.Default : GL.DepthFunc.Always;
+                this._layerRenderState.flags.depthMask = 7 /* TranslucentLayers */ !== pass;
+                this._layerRenderState.depthFunc = (7 /* TranslucentLayers */ === pass) ? GL.DepthFunc.Default : 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;
         }
@@ -1651,7 +1668,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();
@@ -1666,6 +1684,7 @@ class MRTFrameBuffers extends FrameBuffers {
         this.idsAndAltZ = dispose(this.idsAndAltZ);
         this.idsAndZComposite = dispose(this.idsAndZComposite);
         this.idsAndAltZComposite = dispose(this.idsAndAltZComposite);
+        this.edlDrawCol = dispose(this.edlDrawCol);
     }
 }
 class MRTGeometry extends Geometry {
@@ -1745,6 +1764,101 @@ class MRTCompositor extends Compositor {
             system.context.clear(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 {
+                    assert(undefined !== curPC);
+                    curPC.cmds.push(cmd);
+                }
+            }
+            else {
+                if ("popBranch" === cmd.opcode)
+                    --pushDepth;
+                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.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 = dispose(this._fbos.edlDrawCol);
+                        const filters = [GL.MultiSampling.Filter.Linear];
+                        if (useMsBuffers)
+                            this._fbos.edlDrawCol = FrameBuffer.create([this._textures.hilite], this._depth, useMsBuffers && this._textures.hiliteMsBuff ? [this._textures.hiliteMsBuff] : undefined, filters, this._depthMS);
+                        else
+                            this._fbos.edlDrawCol = 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.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" ? EDLMode.Full : 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);
@@ -1760,7 +1874,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);
             }
@@ -1770,16 +1885,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.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;
@@ -1788,7 +1904,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);
@@ -1798,9 +1914,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)
@@ -1824,7 +1940,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) {
@@ -1854,13 +1970,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 */);
             });
         }
     }
@@ -1870,7 +1986,7 @@ class MRTCompositor extends Compositor {
             : (needComposite ? this._fbos.idsAndAltZComposite : this._fbos.idsAndAltZ));
         System.instance.frameBufferStack.execute(fbo, true, false, () => {
             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;
     }
@@ -1883,7 +1999,7 @@ class MRTCompositor extends Compositor {
     }
     renderTranslucent(commands) {
         System.instance.frameBufferStack.execute(this._fbos.translucent, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
+            this.drawPass(commands, 8 /* Translucent */);
         });
     }
     pingPong() {
@@ -1979,7 +2095,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);
@@ -2004,6 +2120,7 @@ class MPCompositor extends Compositor {
     }
     clearHiddenPick() {
     }
+    renderPointClouds(_commands, _compositeFlags) { }
     renderOpaque(commands, compositeFlags, renderForReadPixels) {
         if (0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */) && !renderForReadPixels) {
             this.renderOpaqueAO(commands);
@@ -2017,36 +2134,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.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.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) {
@@ -2057,10 +2174,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;
@@ -2081,7 +2198,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();
         }
@@ -2089,7 +2206,7 @@ class MPCompositor extends Compositor {
             this._readPickDataFromPingPong = false;
             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 */);
             });
         }
     }
@@ -2100,7 +2217,7 @@ class MPCompositor extends Compositor {
         const fbo = (renderForIntersectingVolumes ? this._fbos.featureIdWithDepth : this._fbos.featureIdWithDepthAltZ);
         System.instance.frameBufferStack.execute(fbo, true, false, () => {
             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;
@@ -2131,11 +2248,11 @@ class MPCompositor extends Compositor {
     }
     renderTranslucent(commands) {
         System.instance.frameBufferStack.execute(this._fbos.accumulation, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
+            this.drawPass(commands, 8 /* Translucent */);
         });
         this._currentRenderTargetIndex = 1;
         System.instance.frameBufferStack.execute(this._fbos.revealage, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
+            this.drawPass(commands, 8 /* Translucent */);
         });
         this._currentRenderTargetIndex = 0;
     }